相关资料在百度上获取。
每个排序法的定义都是由百度的定义摘抄下来。
作者仅是整理一遍重要的信息。具体相关可以直接上百度查询。
若是文字太小可以按住Ctrl + 滑轮上下移动，来进行缩放
1.插入排序：
有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——
插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，
时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的
数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
其中包括：直接插入排序，二分插入排序（又称折半插入排序），链表插入排序，希尔排序（又称缩小增量排序）。
直接插入排序
直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
voidinsertion_sort(intarray[],intfirst,intlast)
{
inti,j;
inttemp;
for
(i=first+1;i<last;i++)
{
temp=array[i];
j=i-1;
//与已排序的数逐一比较，大于temp时，该数移后
while
((j>=0)&&(array[j]>temp))
{
array[j+1]=array[j];
j--;
}
//存在大于temp的数
if
(j!=i-1)
{array[j+1]=temp;}
}
}
|
折半插入排序（二分插入排序）
即在插入法的基础上加入了二分法，从而提高了效率。执行折半插入排序的前提是文件记录必须按顺序存储。
希尔排序法 希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
各组内的排序通常采用直接插入法。由于开始时s的取值较大，每组内记录数较少，所以排序比较快。随着不断增大，每组内的记录数逐步增多，但由于已经按排好序，因此排序速度也比较快。
/*
希尔排序，个人理解：一共n个数据，分成m组数据，每组有n/m个数据。然后对每组进行排序，因为每组数据少，所以排序 快。然后是m-1，再次分组，每组n/（m-1）个数据，然后排序......
假如有16个数据，分成4组，每组4个数据，进行排序，然后4-1=3.
分成3组，每组5个元素（最后一组为6个元素），进行排序，3-1=2
分成2组，每组8个元素，进行排序
最后分成1组数据（即不分组）。改组16个元素，进行排序
因为一开始元素比较少，所以排序快。最后因为已经排序好（已经有一定的顺序），所以排序也快。
*/
算法复杂度
如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需（n-1）次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。插入排序的赋值操作是比较操作的次数加上 (n-1）次。平均来说插入排序算法的时间复杂度为O(n^2）。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择
——————————————————————————————————————————————————————————————
2.选择排序：
选择排序（Selection sort）是一种简单直观的
排序算法
。它的工作原理是每一次从待排序的
数据元素
中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。
时间复杂度：
选择排序的交换操作介于 0 和 (n - 1） 次之间。选择排序的比较操作为 n (n - 1） / 2 次之间。选择排序的赋值操作介于 0 和 3 (n - 1） 次之间。
比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数N=(n-1）+(n-2）+...+1=n*(n-1）/2。交换次数O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，
选择排序比冒泡排序快
。
———————————————————————————————————————————————————————————————
3.冒泡排序
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名
冒泡排序算法的运作如下：（从后往前）
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
算法稳定性
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
{
int
i, j, temp;
for
(j = 0; j < n - 1; j++)
for
(i = 0; i < n - 1 - j; i++)
{
if
(a[i] > a[i + 1])
{
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
}
}
}
————————————————————————————————————————————————————————————————
4.快速排序
快速排序（Quicksort）是对
冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以
递归进行，以此达到整个数据变成有序
序列。
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后
将所有比它小的数都放到它前面，所有比它大的数都放到它后面
，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的
排序算法
，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
1）设置两个变量i、j，
排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给
key，即
key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于
key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于
key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于
key,4中A[i]不大于
key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
————————————————————————————————————————————————————————————————
5.堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
特点
堆排序（HeapSort）是一树形
选择排序。堆排序的特点是：在排序过程中，将R[l..n]看成是一棵
完全二叉树的
顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系（参见二叉树的顺序存储结构），在当前无序区中选择
关键字最大（或最小）的记录
堆排序利用了大根堆（或小根堆）堆顶记录的
关键字
最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#include <stdio.h>
void
swap(
int
*a,
int
*b);
void
adjustHeap(
int
param1,
int
j,
int
inNums[]);
void
HeapSort(
int
nums,
int
inNums[]);
//大根堆进行调整
void
adjustHeap(
int
param1,
int
j,
int
inNums[])
{
int
temp=inNums[param1];
for
(
int
k=param1*2+1;k<j;k=k*2+1)
{
//如果右边值大于左边值，指向右边
if
(k+1<j && inNums[k]< inNums[k+1])
{
k++;
}
//如果子节点大于父节点，将子节点值赋给父节点,并以新的子节点作为父节点（不用进行交换）
if
(inNums[k]>temp)
{
inNums[param1]=inNums[k];
param1=k;
}
else
break
;
}
//put the value in the final position
inNums[param1]=temp;
}
//堆排序主要算法
void
HeapSort(
int
nums,
int
inNums[])
{
//1.构建大顶堆
for
(
int
i=nums/2-1;i>=0;i--)
{
//put the value in the final position
adjustHeap(i,nums,inNums);
}
//2.调整堆结构+交换堆顶元素与末尾元素
for
(
int
j=nums-1;j>0;j--)
{
//堆顶元素和末尾元素进行交换
int
temp=inNums[0];
inNums[0]=inNums[j];
inNums[j]=temp;
adjustHeap(0,j,inNums);
//重新对堆进行调整
}
}
int
main() {
int
data[] = {6,5,8,4,7,9,1,3,2};
int
len =
sizeof
(data) /
sizeof
(
int
);
HeapSort(len,data);
return
0;
}
|
————————————————————————————————————————————————————————————————
6.归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路
归并。
归并过程为：比较a[i]和b[j]的大小，若a[i]≤b[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素b[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
排序
复杂度：
时间复杂度为O(nlog₂n) 这是该算法中最好、最坏和平均的时间性能。
空间复杂度为 O(n)
比较操作的次数介于(nlogn) / 2和nlogn - n + 1。
赋值操作的次数是(2nlogn)。归并算法的空间复杂度为：0 (n)
归并
排序比较占用内存，但却是一种效率高且稳定的算法。
定义
11万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
