八大排序算法总结
深入浅出-C语言8种经典排序算法
C语言——8种经典排序算法1.排序算法的稳定性分析:若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。
(1)冒泡排序冒泡排序就是把小的元素往前调或者把大的元素往后调。
比较是相邻的两个元素比较，交换也发生在这两个元素之间。
所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
(2)选择排序选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。
那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。
比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。
(3)插入排序插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。
当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。
比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。
如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。
所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
(4)快速排序快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index 是中枢元素的数组下标，一般取为数组第0个元素。
十大经典排序算法总结
⼗⼤经典排序算法总结最近⼏天在研究算法，将⼏种排序算法整理了⼀下，便于对这些排序算法进⾏⽐较，若有错误的地⽅，还请⼤家指正0、排序算法说明0.1 排序术语稳定：如果a=b,且a原本排在b前⾯，排序之后a仍排在b的前⾯不稳定：如果a=b,且a原本排在b前⾯，排序之后排在b的后⾯时间复杂度：⼀个算法执⾏所耗费的时间空间复杂度：⼀个算法执⾏完所需内存的⼤⼩内排序：所有排序操作都在内存中完成外排序：由于数据太⼤，因此把数据放在磁盘中，⽽排序通过磁盘和内存的数据传输才能进⾏0.2算法时间复杂度、空间复杂度⽐较0.3名词解释n:数据规模k:桶的个数In-place:占⽤常数内存，不占⽤额外内存Out-place:占⽤额外内存0.4算法分类1.冒泡排序冒泡排序是⼀种简单的排序算法。
它重复地⾛访过要排序的数列，⼀次⽐较两个元素，如果它们的顺序错误就把它们交换过来。
⾛访数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端1.1算法描述⽐较相邻的元素，如果前⼀个⽐后⼀个打，就交换对每⼀对相邻元素做同样的⼯作，从开始第⼀对到结尾最后⼀对，这样在最后的元素应该会是最⼤的数针对所有的元素重复以上的步骤，除了最后⼀个重复步骤1-3，知道排序完成1.2动图演⽰1.3代码实现public static int[] bubbleSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++)for (int j = 0; j < array.length - 1 - i; j++)if (array[j + 1] < array[j]) {int temp = array[j + 1];array[j + 1] = array[j];array[j] = temp;}return array;}1.4算法分析最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)2.选择排序表现简单直观的最稳定的排序算法之⼀，因为⽆论什么数据都是O(n2)的时间复杂度，⾸先在未排序序列中找到最⼩（⼤）元素，与数组中第⼀个元素交换位置，作为排序序列的起始位置，然后再从剩余未排序元素中继续寻找最⼩（⼤）的元素，与数组中的下⼀个元素交换位置，也就是放在已排序序列的末尾2.1算法描述1.初始状态：⽆序区为R[1..n],有序区为空2.第i躺排序开始时，当前有序区和⽆序区R[1..i-1]、R[i..n]3.n-1趟结束，数组有序化2.2动图演⽰2.3代码实现public static int[] selectionSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++) {int minIndex = i;for (int j = i; j < array.length; j++) {if (array[j] < array[minIndex]) //找到最⼩的数minIndex = j; //将最⼩数的索引保存}int temp = array[minIndex];array[minIndex] = array[i];array[i] = temp;}return array;}2.4算法分析最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)3、插⼊排序是⼀种简单直观的排序算法，通过构建有序序列，对于未排序序列，在已排序序列中从后向前扫描，找到相应位置并插⼊，需要反复把已排序元素逐步向后挪位，为最新元素腾出插⼊空间3.1算法描述1.从第⼀个元素开始，该元素可以认为已经被排序2.取出下⼀个元素（h），在已排序的元素序列中从后往前扫描3.如果当前元素⼤于h，将当前元素移到下⼀位置4.重复步骤3，直到找到已排序的元素⼩于等于h的位置5.将h插⼊到该位置6.重复步骤2-53.2动图演⽰3.3代码实现public static int[] insertionSort(int[] array) {if (array.length == 0)return array;int current;for (int i = 0; i < array.length - 1; i++) {current = array[i + 1];int preIndex = i;while (preIndex >= 0 && current < array[preIndex]) {array[preIndex + 1] = array[preIndex];preIndex--;}array[preIndex + 1] = current;}return array;}3.4算法分析最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)4、希尔排序是简单插⼊排序经过改进之后的⼀个更⾼效的版本，也称为缩⼩增量排序，同时该算法是冲破O(n2）的第⼀批算法之⼀。
10种常用典型算法
10种常用典型算法1. 冒泡排序(Bubble Sort)冒泡排序是一种简单的排序算法。
它通过依次比较相邻的两个元素，如果顺序不对则交换位置。
这样，每一趟排序都会将最大的元素移动到末尾。
通过多次重复这个过程，直到所有元素按照升序排列为止。
2. 选择排序(Selection Sort)选择排序也是一种简单的排序算法。
它通过每次从未排序的部分中选出最小的元素，放到已排序部分的末尾。
通过多次重复这个过程，直到所有元素按照升序排列为止。
3. 插入排序(Insertion Sort)插入排序是一种简单且稳定的排序算法。
它通过将未排序的元素逐个插入到已排序部分的正确位置。
每次插入一个元素，已排序部分都是有序的。
通过多次重复这个过程，直到所有元素按照升序排列为止。
4. 快速排序(Quick Sort)快速排序是一种高效的排序算法。
它通过选择一个基准元素，将数组分成两部分，一部分元素小于基准，另一部分元素大于基准。
然后对这两部分递归地进行快速排序。
通过多次重复这个过程，直到所有元素按照升序排列为止。
5. 归并排序(Merge Sort)归并排序是一种稳定的排序算法。
它通过将数组递归地分成两半，分别对这两半进行归并排序，然后将排序好的两部分合并起来。
通过多次重复这个过程，直到所有元素按照升序排列为止。
6. 堆排序(Heap Sort)堆排序是一种高效的排序算法。
它利用堆的性质来进行排序，通过构建一个最大堆或最小堆，并不断地取出堆顶元素并调整堆。
通过多次重复这个过程，直到所有元素按照升序排列为止。
7. 计数排序(Counting Sort)计数排序是一种非比较性的整数排序算法。
它通过统计每个元素的个数来排序。
首先统计每个元素出现的次数，然后根据元素的大小顺序将其放入新的数组中。
通过多次重复这个过程，直到所有元素按照升序排列为止。
8. 桶排序(Bucket Sort)桶排序是一种非比较性的排序算法。
它通过将元素划分到不同的桶中，每个桶内再使用其他排序算法进行排序。
算法_八大排序算法总结
算法_⼋⼤排序算法总结最近笔试⾯试中经常考到排序算法，及其对应的时间复杂度和空间复杂度分析，现做如下总结。
⼀，冒泡排序思想：对于0~n-1，依次⽐较相邻两个数，前者⽐后者⼤就交换，⼀轮后A[n-1]是最⼤数，在对0~n-2执⾏以上步骤，则A[n-2]是第⼆⼤的数，循环执⾏上⾯的步骤即可，形象的可以理解为⼤的数⼀个个冒到后⾯去，所以叫冒泡排序。
⽰意图：⾸先6和3⽐较，6⽐3⼤，交换6和5⽐较，交换6和7⽐较，不⽤交换依次执⾏以上步骤，第⼀轮后，序列变为接着，在0到n-2上执⾏以上步骤⼀轮过后，则变为依次执⾏以上步骤，最后序列为时间复杂度： O(n^2)空间复杂度：O(1)代码：1class BubbleSort {2public:3int* bubbleSort(int* A, int n)4 {5int temp;6// write code here7for(int i = 0; i < n; i++)8 {9for(int j = 0; j < n - i - 1; j++)10 {11if(A[j] > A[j+1])12 {13 temp = A[j];14 A[j] = A[j + 1];15 A[j + 1] = temp;16 }17 }1819 }20return A;21 }22 };⼆，选择排序思想：在序列中依次选择最⼩值放到最前端，重复以上步骤，只到排序完成⽰意图：最⼩数为0，放到最前端1到n-1最⼩数为1，放到最前端依次执⾏以上步骤，最后为时间复杂度：O(n^2)空间复杂度：O(1)代码：1class SelectionSort {2public:3int* selectionSort(int* A, int n)4 {5// write code here6//从前往后依次放⼊为排序的数组的最⼩值7int min_b;8int temp;9for(int i = 0; i < n - 1; i++)10 {11 min_b = i;12for(int j = i; j < n; j++) //寻找最⼩值13 {14if(A[min_b] > A[j])15 min_b = j;1617 }18 temp = A[i];19 A[i] = A[min_b];20 A[min_b] = temp;21 }22return A;23 }24 };三，插⼊排序思想：对于数组A[n]，保证前⾯的A[0]~A[m]是排序好的，再把A[m+1]插⼊到前⾯排好序的序列中，m递增，知道m=n-2⽰意图：原始序列为：6和5⽐较，6⽐5⼤，要交换接下来把3插⼊到前⾯排好序的序列中，⾸先3和6⽐，6⼤，后移⼀位接着3和5⽐较，5⼤，后移⼀位只到前⾯没有数了，或者前⾯的数⽐要插⼊的数⼩，就在对应的位置插⼊该数再对1执⾏以上步骤重复以上步骤，只到整个序列排序完成时间复杂度：O(n^2)空间复杂度：O(1)代码1class InsertionSort {2public:3int* insertionSort(int* A, int n)4 {5// write code here6int temp;7for(int i = 1; i < n; i ++)8 {9 temp = A[i];10for(int j = i - 1; j >= 0; j--)11 {12if(temp < A[j])13 {14 A[j + 1] = A[j];15if(j == 0)16 {17 A[j] = temp;18 }19 }20else21 {22 A[j + 1] = temp;23break;24 }25 }26 }27return A;28 }29 };四，归并排序思想：对数组中每个数看成是长度为1的有序区间，接着合并相邻两个长度为1的有序区间，变为长度为2的有序区间，接着合并相邻长度为2的有序区间变成长度为4的有序区间，依次进⾏，只到排序完成⽰意图：⾸先为长度为1的有序区间合并为长度为2的有序区间合并为长度为4的有序区间合并为长度为8的有序区间，排序完成时间复杂度：O(nlogn)空间复杂度：O(N)代码1class MergeSort {2public:3int* mergeSort(int* A, int n)4 {5 mergeSort(A,0,n-1);6return A;78 }9void mergeSort(int* A, int left, int right)10 {11if(left == right)12return;13int mid=(left+right)/2;14 mergeSort(A,left,mid);15 mergeSort(A,mid+1,right);16 merge_p(A,left,mid,right);17return;18 }1920void merge_p(int* A, int left, int mid, int right)21 {22int* temp = new int[right - left + 1];23int l = left;24int r = mid + 1;25int k = 0;26while(l <= mid && r <= right)27 {28if(A[l] < A[r])29 temp[k++] = A[l++];30else31 temp[k++] = A[r++];32 }33while(l <= mid)34 temp[k++] = A[l++];35while(r <= right)36 temp[k++] = A[r++];37for(int i = 0; i < k; i++)38 {39 A[left + i] = temp[i];40 }41 }4243 };五，快速排序思想：随机选择数组中的数，⼩于等于这个数的放在左边，⼤于这个数的放在右边，递归调⽤以上步骤，完成排序⽰意图：⾸先随机选择，划分区间递归调⽤，即可完成排序。
排序算法总结
排序算法总结排序算法是计算机科学中最基础且常用的算法之一。
它们的作用是将一组数据按照指定的顺序进行排列。
根据数据量的大小和特点，选择适合的排序算法可以提高程序的性能。
常见的排序算法有冒泡排序、插入排序、选择排序、希尔排序、归并排序、快速排序、堆排序和计数排序等。
冒泡排序是最简单、最直观的排序算法。
它通过多次比较相邻的元素，将较大的数往后移动，将较小的数往前移动，从而实现排序。
但是冒泡排序的时间复杂度较高，为O(n^2)。
插入排序的思想是将数组分为有序区和无序区，每次将无序区的第一个元素插入到有序区的合适位置。
它的时间复杂度也为O(n^2)，但在实际应用中对小规模数据进行排序时表现良好。
选择排序每次从数组中选择最小的元素，与数组的第一个元素交换位置，然后从剩下的元素中选择最小的元素，与数组的第二个元素交换位置，依此类推。
它的时间复杂度也为O(n^2)，但它的交换次数相对较少。
希尔排序是直接插入排序的改进版，它将数组按照一定的步长进行分组，对每组进行插入排序，然后缩小步长，直到步长为1，最后再进行一次插入排序。
希尔排序的时间复杂度介于O(n^1.3)和O(n^2)之间，具体取决于步长的选择。
归并排序是一种稳定且分治的排序算法，它将数组分为两个子数组，分别对子数组进行排序，然后将排好序的子数组合并成一个有序的数组。
归并排序的时间复杂度为O(nlogn)，但需要额外的空间来存储临时数组。
快速排序是一种高效且不稳定的排序算法，它通过选取一个基准元素，将数组分为左右两个子数组，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素，然后在左右子数组中递归地进行快速排序。
快速排序的时间复杂度为O(nlogn)，但在最坏情况下可能达到O(n^2)。
堆排序利用堆这种数据结构进行排序。
堆排序的思想是将数组构建成一个最大堆或最小堆，然后将堆顶的元素与数组的最后一个元素交换位置，再对剩余的元素进行调整，再重复执行这个过程。
各种排序方法总结
选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
冒泡法：这是最原始，也是众所周知的最慢的算法了。
他的名字的由来因为它的工作看来象是冒泡：复杂度为O(n*n)。
当数据为正序，将不会有交换。
复杂度为O(0)。
直接插入排序：O(n*n)选择排序：O(n*n)快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的，大多数情况下总是最好的。
归并排序：l og2(n)*n堆排序：l og2(n)*n希尔排序：算法的复杂度为n的1.2次幂这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况1.数组的大小是2的幂，这样分下去始终可以被2整除。
假设为2的k次方，即k=log2(n)。
2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。
第一层递归，循环n次，第二层循环2*(n/2)......所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n所以算法复杂度为O(lo g2(n)*n) 其他的情况只会比这种情况差，最差的情况是每次选择到的midd le都是最小值或最大值，那么他将变成交换法（由于使用了递归，情况更糟）。
但是你认为这种情况发生的几率有多大？？呵呵，你完全不必担心这个问题。
实践证明，大多数的情况，快速排序总是最好的。
如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况下速度要慢于快速排序（因为要重组堆）。
排序题方法总结
排序题方法总结
排序方法可以总结为以下几种：
1. 冒泡排序：重复比较相邻的两个元素，若顺序错误则交换位置，直至整个数组有序。
时间复杂度为O(n^2)。
2. 选择排序：每次从数组中选择最小（或最大）的元素，放到已排序的末尾，直至整个数组有序。
时间复杂度为O(n^2)。
3. 插入排序：将数组分为已排序和未排序两部分，每次从未排序部分中取出一个元素，并插入到已排序部分的适当位置，直至整个数组有序。
时间复杂度为O(n^2)。
4. 归并排序：将数组不断地分割成更小的子数组，然后再将子数组合并，直至整个数组有序。
时间复杂度为O(nlogn)。
5. 快速排序：选择一个基准元素，将数组分为小于和大于基准元素的两部分，再对两部分分别进行快速排序，直至整个数组有序。
时间复杂度为O(nlogn)。
6. 堆排序：将数组构建成大顶堆（或小顶堆），然后不断地将堆顶元素与最后一个元素交换，并重新调整堆，直至整个数组有序。
时间复杂度为O(nlogn)。
7. 计数排序：统计数组中每个元素出现的次数，然后根据计数从小到大将元素重新排列。
时间复杂度为O(n+k)，其中k是值的范围。
8. 基数排序：按照位数从低到高的顺序，将数组分配到桶中，然后重组桶中的元素，直至整个数组有序。
时间复杂度为
O(d*(n+k))，其中d是最大位数，k是每个桶的大小。
以上是常见的排序算法，每种算法都有不同的适用场景和特点，需要根据实际问题选择合适的算法。
数据结构的常用算法
数据结构的常用算法一、排序算法排序算法是数据结构中最基本、最常用的算法之一。
常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。
1. 冒泡排序冒泡排序是一种简单的排序算法，它重复地比较相邻的两个元素，如果它们的顺序错误就将它们交换过来。
通过多次的比较和交换，最大（或最小）的元素会逐渐“浮”到数列的顶端，从而实现排序。
2. 选择排序选择排序是一种简单直观的排序算法，它每次从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾，直到全部元素排序完毕。
3. 插入排序插入排序是一种简单直观的排序算法，它将待排序的数据分为已排序区和未排序区，每次从未排序区中取出一个元素，插入到已排序区的合适位置，直到全部元素排序完毕。
4. 快速排序快速排序是一种常用的排序算法，它采用分治的思想，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分小，然后再按此方法对这两部分数据进行快速排序，递归地进行，最终实现整个序列有序。
5. 归并排序归并排序是一种稳定的排序算法，它采用分治的思想，将待排序的数据分成若干个子序列，分别进行排序，然后将排好序的子序列合并成更大的有序序列，直到最终整个序列有序。
二、查找算法查找算法是在数据结构中根据给定的某个值，在数据集合中找出目标元素的算法。
常见的查找算法有线性查找、二分查找、哈希查找等。
1. 线性查找线性查找是一种简单直观的查找算法，它从数据集合的第一个元素开始，依次比较每个元素，直到找到目标元素或遍历完整个数据集合。
2. 二分查找二分查找是一种高效的查找算法，它要求数据集合必须是有序的。
通过不断地将数据集合分成两半，将目标元素与中间元素比较，从而缩小查找范围，最终找到目标元素或确定目标元素不存在。
3. 哈希查找哈希查找是一种基于哈希表的查找算法，它通过利用哈希函数将目标元素映射到哈希表中的某个位置，从而快速地找到目标元素。
三、图算法图算法是解决图结构中相关问题的算法。
用Java实现常见的8种内部排序算法
⽤Java实现常见的8种内部排序算法⼀、插⼊类排序插⼊类排序就是在⼀个有序的序列中，插⼊⼀个新的关键字。
从⽽达到新的有序序列。
插⼊排序⼀般有直接插⼊排序、折半插⼊排序和希尔排序。
1. 插⼊排序1.1 直接插⼊排序/*** 直接⽐较，将⼤元素向后移来移动数组*/public static void InsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i]; //temp ⽤于存储元素，防⽌后⾯移动数组被前⼀个元素覆盖int j;for(j = i; j > 0 && temp < A[j-1]; j--) { //如果 temp ⽐前⼀个元素⼩，则移动数组A[j] = A[j-1];}A[j] = temp; //如果 temp ⽐前⼀个元素⼤，遍历下⼀个元素}}/*** 这⾥是通过类似于冒泡交换的⽅式来找到插⼊元素的最佳位置。
⽽传统的是直接⽐较，移动数组元素并最后找到合适的位置*/public static void InsertSort2(int[] A) { //A[] 是给定的待排数组for(int i = 0; i < A.length - 1; i++) { //遍历数组for(int j = i + 1; j > 0; j--) { //在有序的序列中插⼊新的关键字if(A[j] < A[j-1]) { //这⾥直接使⽤交换来移动元素int temp = A[j];A[j] = A[j-1];A[j-1] = temp;}}}}/*** 时间复杂度：两个 for 循环 O(n^2)* 空间复杂度：占⽤⼀个数组⼤⼩，属于常量，所以是 O(1)*/1.2 折半插⼊排序/** 从直接插⼊排序的主要流程是：1.遍历数组确定新关键字 2.在有序序列中寻找插⼊关键字的位置* 考虑到数组线性表的特性，采⽤⼆分法可以快速寻找到插⼊关键字的位置，提⾼整体排序时间*/public static void BInsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i];//⼆分法查找int low = 0;int high = i - 1;int mid;while(low <= high) {mid = (high + low)/2;if (A[mid] > temp) {high = mid - 1;} else {low = mid + 1;}}//向后移动插⼊关键字位置后的元素for(int j = i - 1; j >= high + 1; j--) {A[j + 1] = A[j];}//将元素插⼊到寻找到的位置A[high + 1] = temp;}}2. 希尔排序希尔排序⼜称缩⼩增量排序，其本质还是插⼊排序，只不过是将待排序列按某种规则分成⼏个⼦序列，然后如同前⾯的插⼊排序⼀般对这些⼦序列进⾏排序。
8种排序算法
J=2(38) [38 49] 65 97 76 13 27 49
J=3(65) [38 49 65] 97 76 13 27 49
J=4(97) [38 49 65 97] 76 13 27 49
J=5(76) [38 49 65 76 97] 13 27 49
2. 堆的定义: N个元素的序列K1,K2,K3,...,Kn.称为堆，当且仅当该序列满足特性：
Ki≤K2i Ki ≤K2i+1(1≤ I≤ [N/2])
堆实质上是满足如下性质的完全二叉树：树中任一非叶子结点的关键字均大于等于其孩子结点的关键字。例如序列10,15,56,25,30,70就是一个堆，它对应的完全二叉树如上图所示。这种堆中根结点（称为堆顶）的关键字最小，我们把它称为小根堆。反之，若完全二叉树中任一非叶子结点的关键字均大于等于其孩子的关键字，则称之为大根堆。
(6)基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。
2. 排序过程：
【示例】：
初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 ［38 65 97 76 49 27 49]
第二趟排序后 13 27 ［65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
其次，说一下稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换的次数可能会少一些(个人感觉，没有证实)。
《数据结构》八大排序算法必读!
引言概述：数据结构是计算机科学中的重要基础知识，而排序算法则是数据结构中最基本也是最常用的算法之一。
本文将介绍数据结构中的八大排序算法，包括插入排序、选择排序、冒泡排序、快速排序、归并排序、堆排序、计数排序和桶排序。
通过深入理解这些排序算法的原理和特点，能够为我们在实际编程中选择合适的排序算法提供指导。
正文内容：一、插入排序1.直接插入排序：将待排序的元素逐个插入已排好序的序列中。
2.希尔排序：将待排序的元素按照一定间隔分组，然后在每个分组内进行插入排序操作。
二、选择排序1.简单选择排序：每次从待排序序列中选择最小的元素放到已排序序列的末尾。
2.堆排序：构建一个大顶堆，每次取堆顶元素并调整堆的结构。
三、冒泡排序1.冒泡排序：通过相邻元素的比较和交换，将最大的元素逐渐冒泡到待排序序列的末尾。
四、快速排序1.快速排序：选择一个基准元素，将序列分为两部分，小于基准元素的放在左边，大于基准元素的放在右边，然后递归地对左右子序列进行排序。
五、归并排序1.归并排序：将序列分成两部分分别进行排序，然后将两个有序的子序列合并成一个有序序列。
六、堆排序1.堆排序：通过构建一个最大堆或最小堆，将最大或最小元素依次取出并调整堆的结构，从而得到有序序列。
七、计数排序1.计数排序：统计待排序序列中各元素出现的次数，然后按照元素的大小顺序从小到大依次输出。
八、桶排序1.桶排序：将待排序的元素分到不同的桶中，每个桶中的元素可以使用其他排序算法进行排序，然后将桶中的元素按顺序依次输出。
总结：数据结构中的八大排序算法各有特点和适用场景。
插入排序适用于小规模的数据排序，选择排序适用于大规模且基本有序的数据排序，冒泡排序适用于简单排序，快速排序适用于大规模数据排序，归并排序适用于链表和外排序，堆排序适用于需要稳定排序的场景，计数排序适用于数据范围较小的场景，桶排序适用于浮点数排序。
通过熟练掌握这些排序算法的原理和实现方式，可以在实际编程中根据需求选择合适的排序算法，提升程序的效率和性能。
八大排序
八大排序算法排序的基本概念排序是将一批(组)任意次序的记录重新排列成按关键字有序的记录序列的过程。
排序算法有许多，但就全面性能而言，还没有一种公认为最好的。
每种算法都有其优点和缺点，分别适合不同的数据量和硬件配置。
评价排序算法的标准有：执行时间和所需的辅助空间，其次是算法的稳定性。
若排序算法所需的辅助空间不依赖问题的规模n，即空间复杂度是O(1) ，则称排序方法是就地排序，否则是非就地排序。
排序的分类待排序的记录数量不同，排序过程中涉及的存储器的不同，有不同的排序分类。
① 待排序的记录数不太多：所有的记录都能存放在内存中进行排序，称为内部排序；② 待排序的记录数太多：所有的记录不可能存放在内存中， 排序过程中必须在内、外存之间进行数据交换，这样的排序称为外部排序。
内部排序的基本操作对内部排序地而言，其基本操作有两种：◆ 比较两个关键字的大小；◆ 存储位置的移动：从一个位置移到另一个位置。
第一种操作是必不可少的；而第二种操作却不是必须的，取决于记录的存储方式，具体情况是：① 记录存储在一组连续地址的存储空间：记录之间的逻辑顺序关系是通过其物理存储位置的相邻来体现，记录的移动是必不可少的；② 记录采用链式存储方式：记录之间的逻辑顺序关系是通过结点中的指针来体现，排序过程仅需修改结点的指针，而不需要移动记录；③ 记录存储在一组连续地址的存储空间：构造另一个辅助表来保存各个记录的存放地址(指针) ：排序过程不需要移动记录，而仅需修改辅助表中的指针，排序后视具体情况决定是否调整记录的存储位置。
①比较适合记录数较少的情况；而②、③则适合记录数较少的情况。
为讨论方便，假设待排序的记录是以①的情况存储，且设排序是按升序排列的；关键字是一些可直接用比较运算符进行比较的类型。
一交换类排序法所谓交换排序法是指借助数据元素之间互相交换进行排序的方法。
冒泡排序与快速排序法都属于交换类排序方法。
交换排序— 冒泡排序：基本思想：1.比较相邻的元素。
数据结构--排序算法介绍
数据结构--排序算法总结概述排序的分类：内部排序和外部排序内部排序：数据记录在内存中进行排序外部排序：因排序的数据量大，需要内存和外存结合使用进行排序这里总结的八大排序是属于内部排序：当n比较大的时候，应采用时间复杂度为（nlog2n）的排序算法：快速排序、堆排序或归并排序。
其中，快速排序是目前基于比较的内部排序中被认为最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。
———————————————————————————————————————————————————————————————————————插入排序——直接插入排序（Straight Insertion Sort）基本思想：将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。
即：先将序列的第1个记录看成一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。
要点：设立哨兵，用于临时存储和判断数组边界直接插入排序示例：插入排序是稳定的，因为如果一个带插入的元素和已插入元素相等，那么待插入元素将放在相等元素的后边，所以，相等元素的前后顺序没有改变。
算法实现：[cpp]view plain copy1.#include<iostream>ing namespace std;3.4.void print(int a[], int n ,int i)5.{6. cout<<i<<":";7.for(int j= 0; j<8; j++){8. cout<<a[j] <<" ";9. }10. cout<<endl;11.}12.13.void InsertSort(int a[],int n)14.{15.int i,j,tmp;16.for(i=1;i<n;++i)17. {18.// 如果第i个元素大于第i-1个元素，直接插入19.// 否则20.// 小于的话，移动有序表后插入21.if(a[i]<a[i-1])22. {23. j=i-1;24. tmp=a[i]; // 复制哨兵，即存储待排序元素25. a[i]=a[i-1]; // 先后移一个元素26.while(tmp<a[j])27. {28.// 哨兵元素比插入点元素小，后移一个元素29. a[j+1]=a[j];30. --j;31. }32. a[j+1]=tmp; // 插入到正确的位置33. }34. print(a,n,i); // 打印每一趟排序的结果35. }36.}37.38.int main()39.{40.int a[8]={3,1,5,7,3,4,8,2};41. print(a,8,0); // 打印原始序列42. InsertSort(a,8);43.return 0;44.}分析：时间复杂度：O（n^2）———————————————————————————————————————————————————————————————————————插入排序——希尔排序（Shell Sort）基本思想：先将整个待排序的记录序列分割成为若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录依次进行直接插入排序。
十大经典算法排序
十大经典算法排序十大经典算法排序是指在计算机科学和算法领域中被广泛认可和应用的十个经典算法，它们具有重要的理论和实际意义。
下面将按照一定的顺序列举这十个经典算法，并进行简要的介绍。
1. 冒泡排序（Bubble Sort）冒泡排序是一种简单但效率较低的排序算法。
它的基本思想是通过相邻元素之间的比较和交换，将最大（或最小）的元素逐步“冒泡”到数列的末尾。
冒泡排序的时间复杂度为O(n^2)。
2. 快速排序（Quick Sort）快速排序是一种高效的排序算法，它采用分治的思想。
通过选择一个基准元素，将数列分割成两部分，其中一部分的元素都小于基准，另一部分的元素都大于基准。
然后递归地对这两部分进行排序。
快速排序的平均时间复杂度为O(nlogn)。
3. 归并排序（Merge Sort）归并排序也是一种高效的排序算法，它同样采用分治的思想。
将数列递归地分成两半，对每一半进行排序，然后将两个有序的子数列合并成一个有序的数列。
归并排序的时间复杂度为O(nlogn)。
4. 插入排序（Insertion Sort）插入排序是一种简单但有效的排序算法。
它的基本思想是将数列分成已排序和未排序两部分，每次从未排序部分取一个元素，插入到已排序部分的合适位置。
插入排序的时间复杂度为O(n^2)。
5. 选择排序（Selection Sort）选择排序是一种简单但效率较低的排序算法。
它的基本思想是每次从未排序部分选择最小（或最大）的元素，放到已排序部分的末尾。
选择排序的时间复杂度为O(n^2)。
6. 堆排序（Heap Sort）堆排序是一种高效的排序算法，它利用堆这种数据结构来进行排序。
将待排序数列构建成一个大根堆（或小根堆），然后依次取出堆顶元素，得到有序数列。
堆排序的时间复杂度为O(nlogn)。
7. 计数排序（Counting Sort）计数排序是一种非比较排序算法，它适用于数列元素的取值范围较小的情况。
计数排序的基本思想是统计每个元素出现的次数，然后根据统计结果将元素放置到正确的位置上。
八大排序总结
1.冒泡排序（稳定排序）思想：从第一个开始，每两个数进行比较，将较大（较小）的数交换到前面直到最后一个数。
两层循环嵌套，内层用于遍历一次数组，每次两两比较，外层控制遍历的次数。
时间复杂度：O（n^2）.空间复杂度：O（1）。
2.直接插入排序（稳定排序）思想：每次把一个待排的数记录下来，按其值的大小插入前面适当的位置，知道全部插完为止。
时间复杂度：O(n^2)。
空间复杂度：O（1）。
3.选择排序（不稳定排序）思想：两层for循环嵌套，内层用于每次从（j=i+1）的位置开始，将最大（最下）的数找出来，和i位置的值交换，i++，外层控制找最大值的次数。
时间复杂度：O(n^2)。
空间复杂度：O（1）。
4.希尔排序（不稳定排序）思想：他是一种分组插入排序的方法，对于分的组数应该互为素数。
每次将下标间距相等的数分为一组，对每组进行插入排序，直到组数变成一为止，最后对整个数组进行一次排序。
时间复杂度：O(n^1.3)。
空间复杂度：O（1）。
5.堆排序（不稳定排序）思想：堆排序利用堆积树进行选择排序。
堆是二叉树，当由小到大排序时，建立大根堆，首先对树进行调整（从最后一棵枝桠开始），调整后的最大值便存储在0节点，将0节点的值与最后一个节点的值交换，便找出了整个数组的最大值，用for循环对整个树在进行调整，依次得到较大的值，知道数组有序。
时间复杂度：O(nlog2n)。
空间复杂度：O（1）。
6.快速排序（不稳定排序）思想：快排是对冒泡排序的一种改进。
每次将第一个数作为基准，一趟排序后，数组要分成两部分，比基准小的都放在左边，大的放在右边，因此需要定义low，high分别指向每块的第一个数和最后一个数。
通过对基准左边和右边数的个数的判断，分别对左右两边进行找基准排序，对此，既可以使用递归进行后面的排序，也可用while循环进行。
优化一：每次用rand（）函数随机产生high指向的值。
rand（）%（end-start）+start.产生从0到（end-start）+start.的随机数优化二：三数取中法。
八大排序详解
八大排序详解八大排序算法包括插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序和基数排序。
1. 插入排序：这是一种简单直观的排序算法，其工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
在插入过程中，如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面，因此插入排序是稳定的。
2. 希尔排序：也称递减增量排序算法，是插入排序的一种更高效的改进版本。
3. 选择排序：它的工作原理是首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
4. 冒泡排序：这种排序算法会重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
5. 归并排序：归并排序是一种采用分治法的排序算法。
它将待排序的序列分成若干个子序列，每个子序列单独进行排序，然后将已排序的子序列进行合并，得到最终的排序结果。
6. 快速排序：快速排序采用分治法进行排序。
在每一步中，它选择一个“基准”元素，并将数组分为两部分，其中一部分的所有元素都比基准元素小，另一部分的所有元素都比基准元素大。
然后，对这两部分独立地进行快速排序。
7. 堆排序：堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆是一种特殊的树形数据结构，它的每个父节点都大于或等于（小于或等于）其子节点（通常称为大顶堆或小顶堆）。
8. 基数排序：基数排序是一种非比较整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。
以上就是八大排序算法的详解，这些算法各有特点和使用场景，可以根据实际情况选择合适的算法。
数据的排序方法有哪些
数据的排序方法有哪些数据的排序方法主要有以下几种：1. 冒泡排序：冒泡排序是最简单的排序算法之一。
它重复地比较相邻的两个元素，如果它们的顺序错误就交换位置，直到整个序列有序。
2. 选择排序：选择排序是一种简单但低效的排序算法。
它每次从未排序的部分选择一个最小（或最大）的元素放到已排序部分的末尾。
3. 插入排序：插入排序类似于整理扑克牌的过程，将无序部分的元素逐个插入有序部分的合适位置，最终使整个序列有序。
4. 希尔排序：希尔排序是插入排序的优化版本，通过将序列拆分成多个子序列进行插入排序，最终得到完全有序的序列。
5. 归并排序：归并排序使用分治法，将序列拆分成两个子序列，分别对子序列进行排序，然后合并成一个有序序列。
它的核心思想是将两个有序的子序列合并成一个有序的序列。
6. 快速排序：快速排序使用分治法，选择一个基准元素将序列分成两个子序列，其中一个子序列的元素都小于基准元素，另一个子序列的元素都大于基准元素，然后分别对两个子序列进行排序。
7. 堆排序：堆排序是一种利用二叉堆数据结构进行排序的算法。
它首先将序列构建成一个大顶堆（或小顶堆），然后按照堆的性质逐个取出堆顶元素，得到有序序列。
8. 计数排序：计数排序是一种用于整数的线性时间排序算法。
它通过统计序列中每个元素出现的次数，然后根据统计结果重构有序序列。
9. 桶排序：桶排序是一种将元素分布在多个桶中的排序算法。
它先将序列分布到多个桶中，然后对每个桶中的元素进行排序，最后按照桶的顺序将元素依次取出，得到有序序列。
10. 基数排序：基数排序是一种按照数字位数从低位到高位进行排序的算法。
它先按照最低有效位进行排序，然后依次向高位进行排序，最终得到有序序列。
以上是常见的数据排序方法，每种方法都有其适用的场景和优劣势。
在实际应用中，需要根据具体情况选择合适的排序方法来提高排序效率。
八大排序算法
算法实现： 我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数 即：先将要排序的一一组记录按某个增量d（n/2,n为要排序数的个数）分成若干干组子子序列，每组中记录的 下标相差d.对每组中全部元素进行行直接插入入排序，然后再用用一一个较小小的增量（d/2）对它进行行分组，在每 组中再进行行直接插入入排序。继续不断缩小小增量直至至为1，最后使用用直接插入入排序完成排序。 1. void print(int a[], int n ,int i){ 2. 3. 4. 5. 6. 7. } 8. 9. 10. 11. 12. 13. 14. 15. void ShellInsertSort(int a[], int n, int dk) 16. { 17. 18. 19. 20. 21. 22. for(int i= dk; i<n; ++i){ if(a[i] < a[i-dk]){ int j = i-dk; int x = a[i]; a[i] = a[i-dk]; while(x < a[j]){ } cout<<endl; cout<<i <<":"; for(int j= 0; j<8; j++){ cout<<a[j] <<" ";
操作方方法： 1. 选择一一个增量序列t1，t2，…，tk，其中ti>tj，tk=1； 2. 按增量序列个数k，对序列进行行k 趟排序； 3. 每趟排序，根据对应的增量ti，将待排序列分割成若干干长度为m 的子子序列，分别对各子子表进行行直接 插入入排序。仅增量因子子为1 时，整个序列作为一一个表来处理，表长度即为整个序列的长度。 希尔排序的示示例：
数据结构之——八大排序算法
数据结构之——⼋⼤排序算法排序算法⼩汇总 冒泡排序⼀般将前⾯作为有序区（初始⽆元素），后⾯作为⽆序区（初始元素都在⽆序区⾥），在遍历过程中把当前⽆序区最⼩的数像泡泡⼀样，让其往上飘，然后在⽆序区继续执⾏此操作，直到⽆序区不再有元素。
这块是对⽼式冒泡排序的⼀种优化，因为当某次冒泡结束后，可能数组已经变得有序，继续进⾏冒泡排序会增加很多⽆⽤的⽐较次数，提⾼时间复杂度。
所以我们增加了⼀个标识变量flag，将其初始化为1，外层循环还是和⽼式的⼀样从0到末尾，内存循环我们改为从最后⾯向前⾯i（外层循环所处的位置）处遍历找最⼩的，如果在内存没有出现交换，说明⽆序区的元素已经变得有序，所以不需要交换，即整个数组已经变得有序。
(感谢@站在远处看童年在评论区的指正)#include<iostream>using namespace std;void sort(int k[] ,int n){int flag = 1;int temp;for(int i = 0; i < n-1 && flag; i++){flag = 0;for(int j = n-1; j > i; j--){/*下⾯这⾥和i没关系，注意看这块，从下往上travel，两两⽐较，如果不合适就调换，如果上来后⼀次都没调换，说明下⾯已经按顺序拍好了，上⾯也是按顺序排好的，所以完美！*/if(k[j-1] > k[j]){temp = k[j-1];k[j-1] = k[j];k[j] = temp;flag = 1;}}}}int main(){int k[3] = {0,9,6};sort(k,3);for(int i =0; i < 3; i++)printf("%d ",k[i]);}快速排序（Quicksort），基于分治算法思想，是对冒泡排序的⼀种改进。
快速排序由C. A. R. Hoare在1960年提出。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
插入排序
1、直接插入排序
原理:将数组分为无序区与有序区两个区,然后不断将无序区得第一个元素按大小顺序插入到有序区中去,最终将所有无序区元素都移动到有序区完成排序。
要点:设立哨兵,作为临时存储与判断数组边界之用。
实现:
Void InｓertSｏrt(Nｏde L[],ｉnt leｎgｔｈ)
{
Inｔi，ｊ;//分别为有序区与无序区指针
for(i=1;i<lenｇth;i++)／/逐步扩大有序区
{
j=ｉ+１;
ｉf（L[j]<Ｌ[i］)
{
L[0]=L［ｊ]；／／存储待排序元素
Whiｌｅ（L[０]<L［i])//查找在有序区中得插入位置,同时移动元素
{
Ｌ[i+１]=Ｌ［i];／／移动
i--；／/查找
}
L[i+1]=Ｌ［０];/／将元素插入
}
i=j－1；//还原有序区指针
｝
｝
2、希尔排序
原理:又称增量缩小排序。
先将序列按增量划分为元素个数相同得若干组,使用直接插入排序法进行排序,然后不断缩小增量直至为1,最后使用直接插入排序完成排序。
要点:增量得选择以及排序最终以1为增量进行排序结束。
实现:Void shellＳｏrｔ（Noｄe L[］,ｉｎt d）
{
Wｈilｅ(d>=1）//直到增量缩小为１
{
Shell(L,d)；
ｄ＝d/２；//缩小增量
}
｝
Void Ｓｈeｌl(Ｎode L[］,int d)
{
Ｉnt ｉ,j；
For(i=d+1;i<ｌenｇth；i++）
{
if(L[i]<L[ｉ-d])
{
L[0]=L[i];
ｊ=i-ｄ;
While(j>０&＆L［j]>L[0])
{
L［j+ｄ]=Ｌ[j];//移动
ｊ=ｊ-d;／/查找
}
Ｌ[ｊ+d]=Ｌ[0]；
｝
}
｝
交换排序
1、冒泡排序
原理：将序列划分为无序与有序区,不断通过交换较大元素至无序区尾完成排序。
要点：设计交换判断条件，提前结束以排好序得序列循环。
实现:Void ＢｕbbｌeＳｏrt(ＮoｄｅＬ[］)
｛
Int i ,j；
Bｏoｌiｓchａｎged;／／设计跳出条件
For(j＝ｎ；j<０;j--）
{
ischaｎgｅd =faｌｓe;
Foｒ(i＝0;i<j;i++)
{
Ｉf（Ｌ[ｉ］>Ｌ[ｉ+１])//如果发现较重元素就向后移动
{
Ｉｎt temｐ＝Ｌ[i]；
Ｌ[i]＝L［ｉ＋1];
L[i＋1]=temp;
Ischanged =tｒue;
}
}
Iｆ(!ischａnｇｅd)//若没有移动则说明序列已经有序,直接跳出
Ｂrｅak;
}
｝
2、快速排序
原理：不断寻找一个序列得中点,然后对中点左右得序列递归得进行排序,直至全部序列排序完成,使用了分治得思想。
要点:递归、分治
实现:
选择排序
1、直接选择排序
原理：将序列划分为无序与有序区,寻找无序区中得最小值与无序区得首元素交换,有序区扩大一个,循环最终完成全部排序。
要点:
实现：Void ＳeleｃtSorｔ（Node L[])
{
Iｎt i,j，k;//分别为有序区，无序区，无序区最小元素指针
For(i=0;i<lengtｈ;ｉ++）
｛
k=ｉ;
For(j=i+1;j<lengtｈ;ｊ+＋)
{
Iｆ（L[j]<Ｌ［k］)
k=j；
}
If(k！=i)//若发现最小元素,则移动到有序区
{
Ｉｎｔtｅmｐ=L[k];
L[k]=Ｌ[i];
L[i]=L[temp];
}
｝
}
２、堆排序
原理：利用大根堆或小根堆思想,首先建立堆，然后将堆首与堆尾交换,堆尾之后为有序区。
要点：建堆、交换、调整堆
实现：ＶｏｉｄＨeａpSort（Ｎode Ｌ[])
｛
ＢuｉldingHｅａp(L）；／/建堆(大根堆)
For(iｎt i＝n;i>０;i--)／/交换
{
Ｉｎｔtemp＝L[i];
L[i］=Ｌ[0];
L［0]=temp;
Heapｉfｙ(L,0，i)；//调整堆
}
｝
Void BuildiｎgHｅap（Ｎode L[])
{ For（i=leｎgｔh/２-1;i>0；i-－)
Heaｐifｙ(Ｌ，i，lengtｈ);
}
归并排序
原理:将原序列划分为有序得两个序列,然后利用归并算法进行合并，合并之后即为有序序列。
要点:归并、分治
实现:Void ＭeｒｇeSort(Nｏde L[],int m，inｔn）
{
Int k;
Ｉf(m<n）
｛
K=(m+n)/2;
MergeＳorｔ(L,m，ｋ）;
ＭerｇeSoｒt(L,k+１，n)；
Mergｅ(L,ｍ,k,n);
}
｝
基数排序
原理:将数字按位数划分出n个关键字，每次针对一个关键字进行排序，然后针对排序后得序列进行下一个关键字得排序,循环至所有关键字都使用过则排序完成。
要点:对关键字得选取,元素分配收集。
实现:Ｖoｉd ＲａｄiｘＳort(Noｄe L[],length，maxｒadix)
｛
Int m,n,k,lｓp;
k=1;m＝1；
Iｎｔtemp［10］[ｌｅngth-1];
Emptｙ（tｅmp)；//清空临时空间
Wｈiｌｅ(k＜maxradix）/／遍历所有关键字
{
Fｏr(int i=０;ｉ<ｌength;i++）／/分配过程
{
If(L[i］<m)
Ｔemp[0］[n]=L［i];
Ｅlsｅ
Lｓp=（Ｌ[i］/m）％１0；//确定关键字
Ｔemｐ[ｌsp][n]=L［i]；
n++;
}
ＣollectElemeｎｔ（Ｌ,Temp); //收集
n＝０;
ｍ＝m＊1０;
k++;
}
｝。