c语言排序算法总结(主要是代码实现)
C语言数组的五种简单排序，选择法排序，冒泡法排序、交换法排序、插入法排序、折半法排序
C语⾔数组的五种简单排序，选择法排序，冒泡法排序、交换法排序、插⼊法排序、折半法排序⽂章⽬录1、选择法排序选择法排序是指每次选择索要排序的数组中的最⼩值（这⾥是由⼩到⼤排序，如果是由⼤到⼩排序则需要选择最⼤值）的数组元素，将这些数组元素的值与前⾯没有进⾏排序的数组元素值进⾏互换代码实现需要注意的是：声明⼀个数组和两个整形变量，数组⽤于存储输⼊的数字，⽽整形变量⽤于存储最⼩的数组元素的数值与该元素的位置，在我的代码中实现为a[] temp position。
代码具体如下#include<stdio.h>int main(){int m,n,k;printf("please input the length of the array:");scanf("%d",&k);int a[k];int temp;int position;printf("please input the number of the array:\n");for(m=0;m<k;m++){printf("a[%d]=",m+1);scanf("%d",&a[m]);}/*从⼩到⼤排序*/for(m=0;m<k-1;m++){temp=a[m]; //设置当前的值为最⼩值position=m; //记录当前的位置for(n=m+1;n<k;n++){if(a[n]<temp){temp=a[n]; //如果找到⽐当前的还要⼩的数值，则更换最⼩的数值与位置position=n;}}a[position]=a[m];a[m]=temp;}for(m=0;m<k;m++){printf("%d\t",a[m]);}return 0;}结果如下2、冒泡法排序冒泡法排序就是值在排序时，每次⽐较数组中相邻的两个数组元素的值，将⽐较⼩的（从⼩到⼤排序算法，如果是从⼤到⼩排序算法就是将较⼤的数排在较⼩的数前⾯）排在⽐较⼤的前⾯在代码实现的过程中：声明⼀个数组与⼀个整型变量，数组⽤于存放数据元素，整型变量⽤于交换时作为中间变量。
10个经典的C语言基础算法及代码
10个经典的C语言基础算法及代码1.冒泡排序算法冒泡排序是一种简单但效率较低的排序算法，在每一轮遍历中比较相邻的两个元素，如果顺序不正确则交换它们，直到整个数组有序为止。
```cvoid bubbleSort(int arr[], int n)for (int i = 0; i < n-1; i++)for (int j = 0; j < n-1-i; j++)if (arr[j] > arr[j+1])int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}```2.选择排序算法选择排序是一种简单直观的排序算法，它每次从待排序的数组中选择最小（或最大）的元素，并放到已排序的数组末尾。
```cvoid selectionSort(int arr[], int n)for (int i = 0; i < n-1; i++)int min_index = i;for (int j = i+1; j < n; j++)if (arr[j] < arr[min_index])min_index = j;}}int temp = arr[i];arr[i] = arr[min_index];arr[min_index] = temp;}```3.插入排序算法插入排序的基本思想是将数组分为已排序和未排序两部分，每次将未排序的元素插入到已排序的合适位置。
```cvoid insertionSort(int arr[], int n)for (int i = 1; i < n; i++)int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key)arr[j+1] = arr[j];j--;}arr[j+1] = key;}```4.快速排序算法快速排序使用分治法的思想，每次选择一个基准元素，将小于基准的元素放到左边，大于基准的元素放到右边，然后递归地对左右两个子数组进行排序。
C语言常用算法程序汇总
C语言常用算法程序汇总C语言是一门广泛应用于计算机编程的语言，具有较高的效率和灵活性。
在C语言中，常见的算法程序包括排序算法、查找算法、递归算法等等。
以下是一些常用的C语言算法程序的汇总：1.排序算法：-冒泡排序：通过多次迭代比较相邻元素并交换位置，将最大的元素逐渐移动到正确的位置。
-插入排序：将待排序的元素与已排序的部分依次比较并插入到正确的位置。
-选择排序：每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。
-快速排序：通过选择一个基准元素，将数组划分为两个子数组进行递归排序。
2.查找算法：-顺序查找：逐个比较数组中的元素，直到找到目标元素或到数组末尾。
-二分查找：通过比较目标元素与数组中间元素的大小，逐步缩小范围，直到找到目标元素。
-哈希查找：通过散列函数将目标元素映射到哈希表的索引位置进行查找。
3.递归算法：-阶乘：通过递归调用自身计算一个正整数的阶乘。
-斐波那契数列：通过递归调用自身计算斐波那契数列的第n个数。
-二叉树遍历：通过递归调用自身遍历二叉树的各个节点。
4.图算法：- 最短路径算法：如Dijkstra算法和Floyd算法，用于计算图中两个节点之间的最短路径。
-拓扑排序：通过对有向无环图进行排序，使得所有的边从排在前面的节点指向排在后面的节点。
- 最小生成树：如Prim算法和Kruskal算法，用于找到图中连接所有节点的最小子树。
5.动态规划：-最长公共子序列：通过寻找两个字符串中的最长公共子序列，解决字符串匹配问题。
-背包问题：通过动态规划解决在给定容量下选取物品使得总价值最大的问题。
-最大子序列和：通过动态规划解决一个数组中选取连续子序列使得和最大的问题。
以上只是一些C语言中常用的算法程序的汇总，实际上，还有很多其他的算法，如逆波兰表达式、霍夫曼编码、最小割等等。
通过学习这些算法，可以更好地理解C语言的应用和开发。
C语言简单查找排序方法及代码
第一部分查找1、线性查找法：import java.util.Scanner;public class SearchDataElement {public static void main(String[] args) {Scanner scanner=new Scanner(System.in);int[]array;array=new int[]{8,7,5,4,1,5,9,6,3,4};for(int i=0;i<array.length;i++)System.out.println(""+array[i]);System.out.println();int replay=0;do{System.out.print("请输入要查找的数字0-10");int num=scanner.nextInt();lable:{for(int t=0;t<array.length;t++){if(num==array[t]){System.out.println("array["+t+"]="+array[t]);break lable;}}System.out.println("输入的数字数组中不存在");}System.out.println("重新查找1:继续 0:结束?");replay=scanner.nextInt();}while(replay==1);}}2、二分查找算法import java.util.Scanner;public class SearchBinary {public static int searchB(int[]arr,int key){int low=0;int high=arr.length-1;//while(high>=low){int mid=(low+high)/2;if(key<arr[mid])high=mid-1;else if(key==arr[mid])return mid;elselow=mid+1;}return-1;}public static void main(String[] args) {// TODO Auto-generated method stubint[]array=new int[]{2,4,7,11,14,25,33,42,55,64,75,88,89,90,92};int key;Scanner scanner=new Scanner(System.in);System.out.println("\n 请输入关键字:");key=scanner.nextInt();//int result=searchB(array,key);if(result!=-1)System.out.printf("\n%d found in arrray element %d\n", key,result);elseSystem.out.printf("\n %d not found in array\n",key);}}C语言排序方法学的排序算法有：插入排序，合并排序，冒泡排序，选择排序，希尔排序，堆排序，快速排序，计数排序，基数排序，桶排序（没有实现）。
C语言算法全总结
C语言算法全总结C语言是一种广泛应用于计算机科学领域的编程语言，具有高效、可移植和灵活的特点。
在程序设计中，算法是解决问题的一系列有序步骤，可以通过C语言来实现。
本文将为您总结C语言中常用的算法，包括排序算法、查找算法和图算法。
一、排序算法排序算法是将一组元素按照特定的顺序重新排列的算法。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序和归并排序。
这些算法的核心思想是通过比较和交换元素的位置来进行排序。
1.冒泡排序冒泡排序通过多次比较和交换相邻元素的位置来实现排序。
它的基本思想是将最大的元素不断地往后移动，直到整个序列有序。
2.选择排序选择排序通过每次选择最小的元素来实现排序。
它的基本思想是通过比较找到最小元素的位置，然后将其与第一个元素交换，接着在剩下的元素中继续找到最小元素并进行交换，如此重复直到整个序列有序。
3.插入排序插入排序通过构建有序序列，对未排序序列逐个元素进行插入，从而实现排序。
它的基本思想是将当前元素插入到前面已经排好序的序列中的适当位置。
4.快速排序快速排序是一种分治算法，通过选择一个基准元素，将其他元素划分为小于基准元素和大于基准元素的两部分，然后递归地对这两部分进行排序，最终实现整个序列有序。
5.归并排序归并排序也是一种分治算法，将序列分成两个子序列，分别对这两个子序列进行排序，然后将排序后的子序列合并成一个有序序列，从而达到整个序列有序的目的。
二、查找算法查找算法是在一个数据集合中寻找特定元素的算法。
常见的查找算法包括线性查找、二分查找和散列查找。
这些算法的核心思想是通过比较元素的值来确定待查找元素的位置。
1.线性查找线性查找是从数据集合的开头开始，依次比较每个元素的值，直到找到目标元素为止。
它的时间复杂度为O(n)，其中n为数据集合的大小。
2.二分查找二分查找是针对有序序列进行查找的算法，它的基本思想是通过不断缩小查找范围，将目标元素与中间元素进行比较，从而确定待查找元素的位置。
C语言八大排序算法
C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法，附动图和详细代码解释！来源：C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式，那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分，系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作，其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。
反之，若参加排序的记录数量很⼤，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类，⼤致可分为：交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰：3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序：简单选择排序，快速排序，希尔排序，堆排序稳定排序：冒泡排序，直接插⼊排序，归并排序，奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序，然后将第3个元素插⼊到已经排好序的元素中，依次类推（插⼊排序最好的情况就是数组已经有序了）因为插⼊排序每次只能操作⼀个元素，效率低。
元素个数N，取奇数k=N/2，将下标差值为k的数分为⼀组（⼀组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为⼀组，构成有序序列，直到k=1，然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换，再在剩余的数中⼜选择最⼩的和第⼆个数交换，依次类推4、堆排序以升序排序为例，利⽤⼩根堆的性质（堆顶元素最⼩）不断输出最⼩元素，直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶，再重新构造成⼩根堆，再输出堆顶元素，以此类推5、冒泡排序改进1：如果某次冒泡不存在数据交换，则说明已经排序好了，可以直接退出排序改进2：头尾进⾏冒泡，每次把最⼤的沉底，最⼩的浮上去，两边往中间靠16、快速排序选择⼀个基准元素，⽐基准元素⼩的放基准元素的前⾯，⽐基准元素⼤的放基准元素的后⾯，这种动作叫分区，每次分区都把⼀个数列分成了两部分，每次分区都使得⼀个数字有序，然后将基准元素前⾯部分和后⾯部分继续分区，⼀直分区直到分区的区间中只有⼀个元素的时候，⼀个元素的序列肯定是有序的嘛，所以最后⼀个升序的序列就完成啦。
C语言常用简单算法
C语言常用简单算法C语言是一门功能强大的编程语言，其算法也是很多的。
下面是一些常用的简单算法：1.二分查找算法：二分查找是一种在有序数组中查找特定元素的算法。
它的基本思想是首先在数组的中间位置找到待查找的元素，如果该元素等于目标值，则查找成功；如果该元素大于目标值，说明目标值在数组的前半部分，则在前半部分继续进行查找；如果该元素小于目标值，则说明目标值在数组的后半部分，则在后半部分继续进行查找。
重复以上步骤，直到找到目标值或者确定目标值不存在。
2.冒泡排序算法：冒泡排序是一种简单直观的排序算法。
它的基本思想是通过反复交换相邻的两个元素，将较大的元素逐渐往后移动，从而实现排序的目的。
具体实现时，每一轮比较都会使最大的元素移动到最后。
3.插入排序算法：插入排序是一种简单直观的排序算法。
它的基本思想是将数组分成已排序部分和未排序部分，每次从未排序部分取出一个元素，然后将该元素插入到已排序部分的合适位置，从而实现排序的目的。
4.选择排序算法：选择排序是一种简单直观的排序算法。
它的基本思想是每次选择一个最小（或最大）的元素放到已排序部分的末尾，从而实现排序的目的。
具体实现时，每一轮选择都通过比较找出未排序部分的最小（或最大）元素。
5.快速排序算法：快速排序是一种高效的排序算法。
它的基本思想是通过选取一个基准元素，将数组分成两个子数组，一个子数组中的元素都小于基准元素，另一个子数组中的元素都大于基准元素，然后对这两个子数组分别进行快速排序，最终实现排序的目的。
6.斐波那契数列算法：斐波那契数列是一列数字，其中每个数字都是前两个数字之和。
常见的斐波那契数列算法有递归算法和迭代算法。
递归算法通过反复调用自身来计算斐波那契数列的值，而迭代算法则通过循环来计算。
7.求最大公约数算法：求两个数的最大公约数是一种常见的问题。
常见的求最大公约数的算法有欧几里得算法和辗转相除法。
欧几里得算法通过不断用较小数除以较大数的余数，直到余数为0，得到最大公约数。
c语言实现简单排序(8种方法)
#include<stdio.h>#include<stdlib.h>//冒泡排序voidbubleSort(int data[], int n);//快速排序voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high);//插入排序voidbInsertSort(int data[], int n);//希尔排序voidshellSort(int data[], int n);//选择排序voidselectSort(int data[], int n);//堆排序voidheapSort(int data[], int n);void swap(int data[], inti, int j);voidheapAdjust(int data[], inti, int n);//归并排序voidmergeSort(int data[], int first, int last);void merge(int data[], int low, int mid, int high); //基数排序voidradixSort(int data[], int n);intgetNumPos(intnum, intpos);int main() {int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");/*printf("冒泡排序:");bubleSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("快速排序:");quickSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("插入排序:");bInsertSort(data,10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("希尔排序:");shellSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("选择排序:");selectSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf(" 堆排序:");heapSort(data, 10);for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf("归并排序:");mergeSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");*/printf("基数排序:");radixSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");return 0;}/*--------------------冒泡排序---------------------*/ voidbubleSort(int data[], int n) {inti,j,temp;//两个for循环，每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。
c语言 字符串全排列算法
c语言字符串全排列算法在计算机科学中，字符串全排列算法是一种常见的算法，它用于生成一个字符串的所有可能排列。
这对于测试算法或解决一些涉及字符串的问题非常有用。
下面，我们将介绍一种使用C语言实现字符串全排列的算法。
一、算法概述字符串全排列是指将一个字符串的所有字符重新排列，形成所有可能的字符串。
这种方法可以生成所有可能的字符串，其中每个字符都可能出现在任何位置。
二、C语言实现下面是一个使用C语言实现字符串全排列的简单示例代码：```c#include <stdio.h>#include <string.h>void swap(char *x, char *y) {char temp;temp = *x;*x = *y;*y = temp;}void permute(char *a, int l, int r) {int i;if (l == r) {printf("%s\n", a);} else {for (i = l; i <= r; i++) {swap((a + l), (a + i));permute(a, l + 1, r);swap((a + l), (a + i)); // backtrack}}}int main() {char str[100];printf("Enter a string: ");fgets(str, sizeof(str), stdin); // read string from user inputpermute(str, 0, strlen(str) - 1); // call the function to generate all permutationsreturn 0;}```这段代码首先定义了一个交换函数`swap()`，用于交换两个字符的位置。
然后，`permute()`函数用于生成字符串的全排列。
数组排序函数c语言
数组排序函数c语言数组排序函数是计算机编程中常用的一种函数，它的作用是将一个数组中的元素按照一定的规则进行排序。
在C语言中，有多种方法可以实现数组的排序，包括冒泡排序、选择排序、插入排序、快速排序等。
本文将介绍这些排序算法的原理和实现方式。
一、冒泡排序冒泡排序是一种简单直观的排序算法，它的原理是通过比较相邻元素的大小，将较大的元素逐渐“冒泡”到数组的末尾。
具体实现时，我们可以使用两层循环来完成冒泡排序的过程。
外层循环控制比较的轮数，内层循环用于比较相邻元素的大小并进行交换。
经过多轮比较和交换，最终数组中的元素按照从小到大的顺序排列。
二、选择排序选择排序是一种简单但低效的排序算法，它的原理是每次从未排序的元素中选择最小的元素，然后与未排序部分的第一个元素交换位置，这样每一轮都能确定一个最小元素的位置。
具体实现时，我们可以使用两层循环来完成选择排序的过程。
外层循环控制比较的轮数，内层循环用于寻找未排序部分的最小元素并进行交换。
经过多轮比较和交换，最终数组中的元素按照从小到大的顺序排列。
三、插入排序插入排序是一种简单直观的排序算法，它的原理是将一个元素插入到已经排好序的数组中的合适位置。
具体实现时，我们可以使用两层循环来完成插入排序的过程。
外层循环控制待插入的元素，内层循环用于比较已排序部分的元素并进行移动。
经过多轮比较和移动，最终数组中的元素按照从小到大的顺序排列。
四、快速排序快速排序是一种高效的排序算法，它的原理是通过选择一个基准元素，将数组分成两部分，左边部分的元素都小于基准元素，右边部分的元素都大于基准元素，然后递归地对左右两部分进行排序。
具体实现时，我们可以使用递归函数来完成快速排序的过程。
在每一轮排序中，我们选择一个基准元素，将数组分成两部分，并对这两部分进行递归排序。
经过多轮递归排序，最终数组中的元素按照从小到大的顺序排列。
以上是常见的几种数组排序函数的原理和实现方式。
在实际编程中，我们可以根据具体的需求选择合适的排序算法。
C语言常用算法大全
C语言常用算法大全1.排序算法-冒泡排序：依次比较相邻的两个元素，如果顺序不对则交换，每轮找出一个最大或最小的元素-选择排序：从未排序的元素中选择最小或最大的放到已排序的最后，以此类推-插入排序：将未排序的元素插入到已排序的合适位置，从后向前进行比较和交换-快速排序：选择一个基准元素，将小于基准元素的放在左边，大于基准元素的放在右边，然后对左右两边递归地进行快速排序-归并排序：将待排序的序列不断划分为左右两部分，分别排序后再将排序好的左右两部分按顺序合并-堆排序：构建大顶堆，将堆顶元素与末尾元素交换，然后重新调整堆，重复这个过程直到排序完成2.查找算法-顺序查找：从给定的元素序列中逐个比较，直到找到目标元素或遍历完整个序列-二分查找：对于有序序列，在序列的中间位置比较目标元素和中间元素的大小关系，通过每次缩小一半的范围来查找目标元素-插值查找：根据目标元素与有序序列的最小值和最大值的比例推测目标元素所在的位置，然后递归地进行查找-斐波那契查找：根据斐波那契数列的性质来确定目标元素所在的位置，然后递归地进行查找3.图算法-深度优先（DFS）：从图的一些顶点出发，依次访问其未被访问过的邻接顶点，直到所有顶点都被访问过为止-广度优先（BFS）：从图的一些顶点出发，逐层遍历图的顶点，直到所有顶点都被访问过为止- 最小生成树算法：Prim算法和Kruskal算法，用于找到连接图中所有顶点的最小权值边，构成一棵包含所有顶点的生成树- 最短路径算法：Dijkstra算法和Floyd-Warshall算法，用于找到图中两个顶点之间的最短路径-拓扑排序：用于有向无环图（DAG）中的顶点排序，确保排序后的顶点满足所有依赖关系-关键路径算法：找出网络中的关键路径，即使整个工程完成的最短时间4.字符串算法- KMP算法：通过预处理模式串构建next数组，利用next数组在匹配过程中跳过一部分不可能匹配的子串- Boyer-Moore算法：从模式串的末尾开始匹配，利用坏字符和好后缀规则进行跳跃匹配- Rabin-Karp算法：利用哈希函数对主串和匹配串的子串进行哈希计算，然后比较哈希值是否相等- 字符串匹配算法：BM算法、Shift-And算法、Sunday算法等，用于寻找模式串在主串中的出现位置5.动态规划算法-最长公共子序列（LCS）：用于寻找两个序列中最长的公共子序列-最长递增子序列（LIS）：用于寻找给定序列中最长的递增子序列-0-1背包问题：将有限的物品放入容量为C的背包中，使得物品的总价值最大-最大子数组和：用于求解给定数组中连续子数组的最大和-最大正方形：在给定的0-1矩阵中，找出只包含1的最大正方形的边长这些算法是在C语言中常用的算法，它们涵盖了排序、查找、图、字符串和动态规划等多个领域。
c语言降序排序算法代码
c语言降序排序算法代码题目：C语言降序排序算法探究与实现摘要：在计算机科学中，排序算法是一种通过重新排列一组元素的方法，使得这些元素按照某个特定的顺序进行排列。
本文将着重介绍C语言中的降序排序算法，并通过一步一步的分析和实现，帮助读者更深入地理解该算法的原理和实际应用。
第一部分：介绍排序算法1.1 排序算法的定义和分类在计算机科学领域，排序算法是一种将一组数据按照特定顺序重新排列的方法。
常见的排序算法包括冒泡排序、选择排序、插入排序、归并排序、快速排序等。
这些算法根据其操作的特点和效率的不同，可以分为内部排序和外部排序，稳定排序和非稳定排序等。
1.2 降序排序算法的意义和应用降序排序算法将一组数据按照从大到小的顺序进行排列，其应用领域广泛。
例如，在数据分析中，我们可能需要按照某个指标的降序排列数据，以便于分析和决策。
在计算机编程中，排序算法也是常用的工具，有助于解决众多问题，如查找、查重、数据统计等。
第二部分：降序排序算法的实现2.1 冒泡排序算法的原理和实现步骤冒泡排序是一种简单直观的排序算法。
其基本原理是通过不断交换相邻的元素，将较大的元素逐渐“冒泡”到右侧。
下面是该算法的具体实现步骤：- 从序列的第一个元素开始，依次比较相邻的两个元素，如果前者大于后者，则交换它们的位置；- 迭代进行以上比较和交换操作，直到没有任何交换发生；- 此时，序列已按照升序排列，如果需要降序排列，只需将比较的条件改为前者小于后者即可。
2.2 选择排序算法的原理和实现步骤选择排序是一种简单高效的排序算法。
其基本原理是每次从未排序的部分中选择最大的元素，并将其放置在已排序部分的末尾。
下面是该算法的具体实现步骤：- 设定一个游标，指向未排序部分的起始位置；- 从未排序部分中选择最大的元素，并将其与游标所在位置的元素交换；- 将游标右移一位，对未排序部分进行相同的操作，直到未排序部分为空；- 此时，序列已按照升序排列，如果需要降序排列，只需将选择最大元素的条件修改为选择最小元素即可。
c语言几种数组排序方法
常用的c语言排序算法主要有三种即冒泡法排序、选择法排序、插入法排序。
一、冒泡排序冒泡排序：是从第一个数开始，依次往后比较，在满足判断条件下进行交换。
代码实现（以降序排序为例）#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp;for (int i = 0; i < 10; i++){//循环次数for (int j = 0; j <10 - i-1; j++){if (array[j] < array[j+1]){//前面一个数比后面的数大时发生交换temp = array[j];array[j] = array[j+1];array[j + 1] = temp;}}} //打印数组for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}二、选择排序以升序排序为例：就是在指定下标的数组元素往后（指定下标的元素往往是从第一个元素开始，然后依次往后），找出除指定下标元素外的值与指定元素进行对比，满足条件就进行交换。
与冒泡排序的区别可以理解为冒泡排序是相邻的两个值对比，而选择排序是遍历数组，找出数组元素与指定的数组元素进行对比。
（以升序为例）#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp, index;for (int i = 0; i < 9; i++) {index = i;for (int j = i; j < 10; j++){if (array[j] < array[index])index = j;}if(i != index){temp = array[i]; array[i] = array[index]; array[index] = temp; }for(int i=0;i<10:i++) printf("%2d"array[i]）return 0；}三、快速排序是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
C语言奇偶排序算法详解及实例代码
C语言奇偶排序算法详解及实例代码C语言奇偶排序算法详解及实例代码归并排序（Merge sort）是创建在归并操作上的一种有效的排序算法。
该算法是采用分治法的一个非常典型的应用。
本文特意为大家收集整理了C语言奇偶排序算法详解及实例代码，希望大家喜欢！一个归并排序的例子:对一个随机点的链表进行排序算法描述归并操作的过程如下：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列设定两个指针，最初位置分别为两个已经排序序列的起始位置比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置重复步骤3直到某一指针到达序列尾将另一序列剩下的所有元素直接复制到合并序列尾特点：归并排序是稳定的排序.即相等的'元素的顺序不会改变, 速度仅次于快速排序，但较稳定。
归并操作归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。
如：设有数列 [6，202，100，301，38，8，1]初始状态：6, 202, 100, 301, 38, 8, 1第一次归并后：[6, 202], [100, 301], [8, 38], [1]，比较次数：3；第二次归并后：[6, 100, 202, 301]，[1, 8, 38]，比较次数：4；第三次归并后：[1, 6, 8, 38, 100, 202, 301]，比较次数：4；总的比较次数为：3+4+4=11,；逆序数为14；算法实现// Completed on 2014.10.11 17:20// Language: C99//// 版权所有（C）codingwu(mail:****************)// 博客地址：/archimedes/#include#includevoid merge_sort(int *list, const int first, const int last) {int len= last-first+1;int left_min,left_max; //左半区域边界int right_min,right_max; //右半区域边界int index;int i;int *tmp;tmp = (int *)malloc(sizeof(int)*len);if( tmp == NULL || len <= 0 )return;for( i = 1; i < len; i *= 2 ){for( left_min = 0; left_min < len - i; left_min = right_max){int j;right_min = left_max = left_min + i;right_max = left_max + i;j = left_min;if ( right_max > len )right_max = len;index = 0;while( left_min < left_max && right_min < right_max ){tmp[index++] = (list[left_min] > list[right_min] ? list[right_min++] : list[left_min++]);}while( left_min < left_max ){list[--right_min] = list[--left_max];}while( index > 0 ){list[--right_min] = tmp[--index];}}}free(tmp);}int main(){int a[] = {288, 52, 123, 30, 212, 23, 10, 233};int n, mid;n = sizeof(a) / sizeof(a[0]);mid = n / 2;merge_sort(a, 0, n - 1);for(int k = 0; k < n; k++)printf("%d ", a[k]);printf("n");return 0;}使用递归实现：// Completed on 2014.10.11 18:20// Language: C99//// 版权所有（C）codingwu(mail:****************) // 博客地址：/archimedes/#include#includevoid merge(int *array,const int first, const int mid, const int last){int i,index;int first1,last1;int first2,last2;int *tmp;tmp = (int *)malloc((last-first+1)*sizeof(int));if( tmp == NULL )return;first1 = first;last1 = mid;first2 = mid+1;last2 = last;index = 0;while( (first1 <= last1) && (first2 <= last2) ){if( array[first1] < array[first2] ){tmp[index++] = array[first1];first1++;}else{tmp[index++] = array[first2];first2++;}}while( first1 <= last1 ){tmp[index++] = array[first1++];}while( first2 <= last2 ){tmp[index++] = array[first2++];}for( i=0; i<(last-first+1); i++){array[first+i] = tmp[i];}free(tmp);}void merge_sort(int *array, const int first, const int last) {int mid = 0;if(first < last){mid = (first + last) / 2;merge_sort(array, first, mid);merge_sort(array, mid + 1, last);merge(array, first, mid, last);}}int main(){int a[] = {288, 52, 123, 30, 212, 23, 10, 233};int n, mid;n = sizeof(a) / sizeof(a[0]);mid = n / 2;merge_sort(a, 0, n - 1);for(int k = 0; k < n; k++)printf("%d ", a[k]);printf("n");return 0;}【C语言奇偶排序算法详解及实例代码】。
C语言经典算法大全精选
C语言经典算法大全精选1.排序算法1.1冒泡排序：通过不断交换相邻元素的位置，将最大（最小）值“冒泡”到序列的末尾（开头）。
1.2插入排序：将未排序的元素逐个插入已排序的序列中，保持序列始终有序。
1.3选择排序：每次从未排序的元素中选择最小（最大）的元素，放到已排序序列的末尾（开头）。
1.4快速排序：通过递归地将序列分割为较小和较大的两部分，然后分别对两部分进行排序。
1.5归并排序：将序列递归地分割为两个子序列，分别排序后再将结果合并。
1.6堆排序：构建最大（最小）堆，然后逐步将堆顶元素与最后一个元素交换，并调整堆结构。
2.查找算法2.1顺序查找：逐个比较元素，直到找到目标元素或遍历完整个序列。
2.2二分查找：在有序序列中，通过不断缩小查找范围，找到目标元素。
2.3插值查找：根据目标元素与序列中最大、最小元素的关系，按比例选择查找范围。
2.4哈希查找：利用哈希函数将目标元素映射到一个唯一的位置，从而快速定位目标元素。
3.字符串算法3.1字符串匹配算法：在文本串中查找给定的模式串，并返回匹配位置。
3.2字符串翻转：将一个字符串逆序输出。
3.3字符串压缩：将连续出现多次的字符压缩为一个字符，并输出压缩后的字符串。
3.4字符串拆分：按照指定的分隔符将字符串拆分为多个子串，并返回子串列表。
3.5字符串反转单词：将一个句子中的单词顺序逆序输出。
4.图算法4.1深度优先：从起始顶点出发，递归地访问所有能到达的未访问顶点。
4.2广度优先：从起始顶点出发，逐层地访问与当前层相邻的未访问顶点。
4.3最小生成树：找到连接所有顶点的具有最小权值的无环边集合。
4.4最短路径：找到两个顶点之间最短路径的权值和。
4.5拓扑排序：找到一个顶点的线性序列，满足所有有向边的起点在终点之前。
5.数学算法5.1质数判断：判断一个数是否为质数（只能被1和自身整除）。
5.2求最大公约数：找到两个数的最大公约数。
5.3求最小公倍数：找到两个数的最小公倍数。
c语言常见排序算法
常见的C语言排序算法有以下几种：
1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果前一个元素大于后一个元素，则交换它们的位置，重复这个过程直到整个序列有序。
2. 插入排序（Insertion Sort）：将未排序的元素逐个插入到已排序序列中的正确位置，直到整个序列有序。
3. 选择排序（Selection Sort）：每次从未排序的元素中选择最小的元素，将其放到已排序序列的末尾，重复这个过程直到整个序列有序。
4. 快速排序（Quick Sort）：选择一个基准元素，将序列分成两部分，一部分小于等于基准元素，一部分大于基准元素，然后对两部分递归地进行快速排序。
5. 归并排序（Merge Sort）：将序列分成两部分，分别对两部分进行归并排序，然后将两个有序的子序列合并成一个有序的序列。
6. 堆排序（Heap Sort）：将序列构建成一个最大堆，然后将堆顶元素与堆末尾元素交换，重复这个过程直到整个序列有序。
7. 希尔排序（Shell Sort）：将序列按照一定的间隔分成若干个子序列，对每个子序列进行插入排序，然后逐渐减小间隔直到间隔为1，最后对整个序列进行插入排序。
8. 计数排序（Counting Sort）：统计序列中每个元素出现的次数，然后按照元素的大小顺序将它们放入一个新的序列中。
9. 基数排序（Radix Sort）：按照元素的个位、十位、百位等依次进行排序，直到所有位数都排完为止。
以上是常见的C语言排序算法，每种算法都有其特点和适用场景，选择合适的排序算法可以提高排序效率。
快速排序法c语言代码
快速排序法c语言代码快速排序法是一种高效的排序算法，它的核心思想是分治法，将一个大问题分解成若干个小问题，然后递归地解决每个小问题。
下面是快速排序法的C语言代码实现：```c#include <stdio.h>void quick_sort(int a[], int left, int right){int i = left, j = right;int pivot = a[(left + right) / 2]; //选择中间的数作为基准值while (i <= j){while (a[i] < pivot)i++;while (a[j] > pivot)j--;if (i <= j){//交换a[i]和a[j]int temp = a[i];a[i] = a[j];a[j] = temp;i++;j--;}}if (left < j) //递归排序左半部分quick_sort(a, left, j);if (i < right) //递归排序右半部分quick_sort(a, i, right);}int main(){int a[] = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 };int n = sizeof(a) / sizeof(a[0]); //计算数组的长度quick_sort(a, 0, n - 1);for (int i = 0; i < n; i++)printf('%d ', a[i]);printf('');return 0;}```快速排序法是一种常用的排序算法，它的时间复杂度为O(nlogn)，空间复杂度为O(1)，是一种不占用额外空间的原地排序算法。
但是它的最坏时间复杂度为O(n^2)，当待排序的数列已经基本有序时，快速排序法的效率会大大降低。
因此，为了保证快速排序法的效率，需要对选择基准值的方法进行优化。
归并排序c语言代码
归并排序c语言代码归并排序是一种基于分治思想的排序算法，它的核心思想是将待排序数列分成两个子序列，分别进行排序，然后再将两个有序子序列合并为一个有序序列。
以下是归并排序的C语言代码实现：```#include <stdio.h>/* 将数组a的两个有序区间[left, mid]和[mid+1, right]合并成一个有序区间 */void merge(int a[], int temp[], int left, int mid, int right) {int i = left; // 左序列指针int j = mid + 1; // 右序列指针int k = 0; // 临时数组指针// 扫描左右两个有序区间，将较小的元素存入临时数组temp中 while (i <= mid && j <= right) {if (a[i] <= a[j]) {temp[k++] = a[i++];} else {temp[k++] = a[j++];}}// 将左序列剩余元素存入临时数组temp中while (i <= mid) {temp[k++] = a[i++];}// 将右序列剩余元素存入临时数组temp中while (j <= right) {temp[k++] = a[j++];}// 将临时数组temp中的元素复制到原数组a中for (i = 0; i < k; i++) {a[left + i] = temp[i];}}/* 归并排序 */void merge_sort(int a[], int temp[], int left, int right) {if (left < right) {int mid = (left + right) / 2;// 递归地对左右两个区间进行排序merge_sort(a, temp, left, mid);merge_sort(a, temp, mid+1, right);// 合并两个有序区间merge(a, temp, left, mid, right);}}int main() {int a[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};int n = sizeof(a) / sizeof(int);int temp[n]; // 临时数组merge_sort(a, temp, 0, n-1);printf('排序后的结果为：');for (int i = 0; i < n; i++) {printf('%d ', a[i]);}printf('');return 0;}```该代码实现了归并排序并对一个整型数组进行了排序，最终输出了排序后的结果。
C语言常用算法归纳
C语言常用算法归纳C语言是一种常用的编程语言，广泛应用于各种计算机领域。
在C语言中，算法是一种解决问题的方法论，是实现程序的关键所在。
本文将介绍C语言常用的算法，并对其进行归纳总结。
1.排序算法排序算法是将一组数据按照一定的顺序重新排列的过程。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。
-冒泡排序：该算法比较相邻的两个元素，并将较大的元素向后移动，重复此过程直到序列有序。
-选择排序：该算法通过不断选择最小的元素，并放到已排序部分的末尾，重复此过程直到整个序列有序。
-插入排序：该算法将元素逐个插入到已排好序的序列中，重复此过程直到整个序列有序。
-快速排序：该算法通过选择一个基准元素，将元素分为两个分区，并对每个分区递归地快速排序，最终将整个序列有序。
-归并排序：该算法将序列分为两个部分，并对每个部分递归地归并排序，最后将两个有序的部分归并。
上述排序算法中，冒泡排序和选择排序的时间复杂度为O(n^2)，插入排序的时间复杂度为O(n^2)或O(n)，快速排序和归并排序的平均时间复杂度为O(nlogn)。
2.查找算法查找算法是在一组数据中找到指定的元素的过程。
常见的查找算法包括线性查找、二分查找、哈希查找等。
-线性查找：该算法从序列的首个元素开始，逐个比较元素，直到找到指定元素或遍历完整个序列。
-二分查找：该算法通过比较中间元素和目标元素的大小关系，逐渐缩小查找范围，最终找到目标元素。
-哈希查找：该算法通过将元素与哈希函数的运算结果关联，将元素存储在哈希表中；查询时，通过哈希函数确定元素的位置，从而快速查找。
二分查找的时间复杂度为O(logn)，哈希查找的平均时间复杂度为O(1)。
3.字符串算法字符串算法是对字符串进行处理和操作的一系列算法。
常见的字符串算法包括字符串复制、字符串连接、字符串比较、字符串截取等。
- 字符串复制：可以使用strcpy函数实现字符串复制。
例如，strcpy(dest, src)将将src字符串复制到dest字符串中。
C语言常用算法归纳
C语言常用算法归纳C语言作为一种非常流行的编程语言，拥有丰富的算法库和常用算法。
在本篇文章中，我将为您介绍C语言中常用的算法分类，以及每个分类中的常用算法。
希望这篇文章能对您学习C语言算法有所帮助。
1.排序算法：排序算法用于将一组数据按照一定的顺序进行排列。
C语言中常用的排序算法有以下几种：-冒泡排序：通过依次比较相邻元素的大小，将较大的元素逐渐向后移动，实现排序。
-插入排序：将未排序的元素一个个插入到已经排序的序列中，使得整个序列有序。
-选择排序：每次从待排序的序列中选择最小（或最大）的元素，放到已排序序列的末尾。
-快速排序：通过一趟排序将待排序的数据分割成独立的两部分，然后再按照该方法对两部分数据分别进行快速排序，递归实现排序。
-归并排序：将待排序的数据递归地分成两部分，分别进行排序，然后将两个有序的子序列合并成一个有序的序列。
2.查找算法：查找算法用于在一组数据中寻找指定的元素。
C语言中常用的查找算法有以下几种：-顺序查找：从序列的起始位置依次遍历，直到找到目标元素。
-二分查找：对于已经排序的序列，通过每次将查找范围减半的方式进行查找，提高查找效率。
-插值查找：对于有序的序列，根据目标元素在序列中的分布情况，通过插值计算来确定查找位置。
3.字符串处理算法：字符串处理算法用于对字符串进行处理和操作。
C语言中常用的字符串处理算法有以下几种：-字符串比较：用于比较两个字符串是否相等。
-字符串拼接：将两个字符串合并成一个字符串。
-字符串查找：在一个字符串中寻找指定的子串。
-字符串替换：将字符串中指定的子串替换为新的子串。
4.图算法：图算法用于研究图结构的相关问题。
C语言中常用的图算法有以下几种：-广度优先：从图的其中一个顶点开始，按广度优先的原则依次访问与该顶点相邻的未访问的顶点。
-深度优先：从图的其中一个顶点开始，按深度优先的原则访问与该顶点相邻的未访问的顶点，直到无法继续访问为止。
- 最短路径算法：用于寻找两个顶点之间最短路径的算法，常见的最短路径算法有Dijkstra算法和Floyd算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
冒泡排序（Bubble Sort）是一种简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
#include <stdio.h>void bubbleSort(int arr[], int count){int i = count, j;int temp;while(i > 0){for(j = 0; j < i - 1; j++){if(arr[j] > arr[j + 1]){ temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}i--;}}int main(int arc, char* const argv[]){int arr[] = {5, 4, 1, 3, 6};bubbleSort(arr, 5);int i;for(i = 0; i < 5; i++)printf("%4d", arr[i]);}选择排序(Selection sort)是一种简单直观的排序算法。
它的工作原理如下。
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
#include <stdio.h>int main(){int a[]={2,3,4,5,1,7,0,9};int len=sizeof(a)/sizeof(a[0]);select_sort(a,len);for(int i=0;i<len;i++){printf("%d ",a[i]);}return 0;}void select_sort( int *a, int n){register int i, j, min, t;for( i = 0; i < n - 1; i ++){min = i;//查找最小值for( j = i + 1; j < n; j ++)if( a[ min] > a[ j])min = j;//交换if( min != i){t = a[ min];a[ min] = a[ i];a[ i] = t;}}}插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
#include <stdio.h>#include <stdlib.h>int main(){int a[]={1,3,2,13,34,45,16,10};int length=8;InsertSort(a,8);for(int i=0;i<length;i++){printf("%d ",a[i]);}return 0;}void InsertSort(int a[],int length){int i,j,temp=0;//分别为有序区和无序区指针for(i=1;i<length;i++)//逐步扩大有序区{temp=a[i];//存储待排序元素for(j=i;j>0&&temp<a[j-1];--j){a[j]=a[j-1];}a[j]=temp;//将元素插入}}希尔排序是基于插入排序的以下两点性质而提出改进方法的：1、插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率2、但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位#include <stdio.h>#include <stdlib.h>void shellsort(int *a,int n){int h, j, k, t;for (h=n/2; h>0; h=h/2) /*控制增量*/{for (j=h; j<n; j++) /*这个实际上就是上面的直接插入排序*/{t = *(a+j);for (k=j-h; (k>=0 && t<*(a+k)); k-=h){*(a+k+h) = *(a+k);}*(a+k+h)=t;}}}int main(){int a[]= {8,10,3,5,7,4,6,1,9,2};int N=sizeof(a)/sizeof(a[0]);shellsort(a,N);for(int k = 0;k < N;k++)printf("a[%d] = %d\n",k,a[k]);return 0;}/*int main(){const int n = 5;int i, j, temp;int gap = 0;int a[] = {5, 4, 3, 2, 1};while (gap<=n){gap = gap * 3 + 1;}while (gap > 0){for ( i = gap; i < n; i++ ){j = i - gap;temp = a[i];while (( j >= 0 ) && ( a[j] > temp )){a[j + gap] = a[j];j = j - gap;}a[j + gap] = temp;}gap = ( gap - 1 ) / 3;}}*/快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
步骤为：1.从数列中挑出一个元素，称为"基准"（pivot），2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
在这个分区退出之后，该基准就处于数列的中间位置。
这个称为分区（partition）操作。
3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。
虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
#include <stdlib.h>#include <stdio.h>#define NUM_ITEMS 100void quickSort(int numbers[], int array_size); void q_sort(int numbers[], int left, int right); int numbers[NUM_ITEMS];int main(){int i;//seed random number generatorsrand(getpid());//fill array with random integersfor (i = 0; i < NUM_ITEMS; i++)numbers[i] = rand();//perform quick sort on arrayquickSort(numbers, NUM_ITEMS);printf("Done with sort.\n");for (i = 0; i < NUM_ITEMS; i++)printf("%i<", numbers[i]);}void quickSort(int numbers[], int array_size) {q_sort(numbers, 0, array_size - 1);}void q_sort(int numbers[], int left, int right) {int pivot, l_hold, r_hold;l_hold = left;r_hold = right;pivot = numbers[left];while (left < right){while ((numbers[right] >= pivot) && (left < right))right--;if (left != right){numbers[left] = numbers[right];left++;}while ((numbers[left] <= pivot) && (left < right))left++;if (left != right){numbers[right] = numbers[left];right--;}}numbers[left] = pivot;pivot = left;left = l_hold;right = r_hold;if (left < pivot)q_sort(numbers, left, pivot-1);if (right > pivot)q_sort(numbers, pivot+1, right);}选择排序(Selection sort)是一种简单直观的排序算法。
它的工作原理如下。
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
#include <stdio.h>int main(){int a[]={2,3,4,5,1,7,0,9};int len=sizeof(a)/sizeof(a[0]);select_sort(a,len);for(int i=0;i<len;i++){printf("%d ",a[i]);}return 0;}void select_sort( int *a, int n){register int i, j, min, t;for( i = 0; i < n - 1; i ++){min = i;//查找最小值for( j = i + 1; j < n; j ++)if( a[ min] > a[ j])min = j;//交换if( min != i){t = a[ min];a[ min] = a[ i];a[ i] = t;}}}基数排序(Radix sort)是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。