八大排序算法总结
深入浅出-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. 哈希查找哈希查找是一种基于哈希表的查找算法，它通过利用哈希函数将目标元素映射到哈希表中的某个位置，从而快速地找到目标元素。
三、图算法图算法是解决图结构中相关问题的算法。
- 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++;
}
｝。