排序算法总结
排序是对一串元素按关键字进行有序的排列。其中排序算法有很多种，常见的有冒泡排序、快速排序、希尔排序、堆排序、直接选择排序、基数排序、直接插入排序、折半插入排序、归并排序。
当中快速排序、希尔排序、堆排序、直接选择排序不是稳定的排序算法
而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。
当中快速排序、希尔排序、堆排序、直接选择排序、冒泡排序、直接插入排序、归并排序是比较排序，计数排序、桶排序、基数排序是非比较排序。
一、冒泡排序
1、概念：冒泡排序就是把数字小的经过交换慢慢排到前端，如此循环，最后成为一个升序或降序的排列。就像汽水的气泡慢慢浮到顶端一样。实质上就是把大（小）的元素往前（后）调。是一种稳定的排序算法。冒泡排序平均时间复杂度为 O(n2)。
2、原理：
①比较相邻的元素。如果第一个比第二个大，就交换他们两个。
②对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
③针对所有的元素重复以上的步骤，除了最后一个。
④持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
3、C++代码
int arr[]= { 51, 75, 24, 12, 34, 62 };
int len = sizeof(arr) / sizeof(arr[0]);
int temp = 0;
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
二、快速排序
1、概念：快速排序就是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。实质上就是把元素分割成两个部分，一部分要比另一部分小，再循环。不是一种稳定的排序算法。时间复杂度为O(nlogn)。
2、原理：
①首先设定一个分界值，通过该分界值将数组分成左右两部分。
②将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
③然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
④重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
3、C++代码
int arr[]= { 51, 75, 24, 12, 34, 62 };
void Qsort(int arr[], int low, int high){
if (high <= low) return;
int i = low;
int j = high + 1;
int key = arr[low];
while (true)
{
/*从左向右找比key大的值*/
while (arr[++i] < key)
{
if (i == high){
break;
}
}
/*从右向左找比key小的值*/
while (arr[--j] > key)
{
if (j == low){
break;
}
}
if (i >= j) break;
/*交换i,j对应的值*/
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/*中枢值与j对应值交换*/
int temp = arr[low];
arr[low] = arr[j];
arr[j] = temp;
Qsort(arr, low, j - 1);
Qsort(arr, j + 1, high);
}
三、希尔排序
1、概念：希尔排序就是将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。。实质上就是把元素按增量进行分组，每组分别进行排序，再缩小增量进行循环。不是一种稳定的排序算法。希尔排序的时间的时间复杂度为O( n3/2 )。比直接插入算法好。
2、原理：
先取一个正整数d1数组元素放一组，组内进行直接插入排序；然后取d2。
3、C++代码
void insert_sort(int st, int ed, int delta)
{
for(int i = st + delta; i < ed; i += delta)
{
for(int j = i; j > st; j -= delta)
{
if(*j < *(j - delta))
{
std::swap(*j, *(j - delta));
}
else
{
break;
}
}
}
}
void shell_sort(int st, int ed)
{
for(int delta = ed - st; delta; delta /= 2)
{
for(int i = 0; i < delta; i++)
{
insert_sort(st + i, ed, delta);
}
}
}
四、堆排序
1、概念：堆排序就是利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序的时间的时间复杂度为O( nlogn )。
2、原理：
最大堆调整（Max Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
创建最大堆（Build Max Heap）：将堆中的所有数据重新排序
堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算
3、C++代码
void max_heapify(int arr[], int start, int end)
{
//建立父节点指标和子节点指标
int dad = start;
int son = dad * 2 + 1;
while (son <= end) //若子节点指标在范围内才做比较
{
if (son + 1 <= end && arr[son] < arr[son + 1]) //先比较两个子节点大小，选择最大的
son++;
if (arr[dad] > arr[son]) //如果父节点大於子节点代表调整完毕，直接跳出函数
return;
else //否则交换父子内容再继续子节点和孙节点比较
{
swap(arr[dad], arr[son]);
dad = son;
son = dad * 2 + 1;
}
}
}
void heap_sort(int arr[], int len)
{
//初始化，i从最後一个父节点开始调整
for (int i = len / 2 - 1; i >= 0; i--)
max_heapify(arr, i, len - 1);
//先将第一个元素和已经排好的元素前一位做交换，再从新调整(刚调整的元素之前的元素)，直到排序完毕
for (int i = len - 1; i > 0; i--)
{
swap(arr[0], arr[i]);
max_heapify(arr, 0, i - 1);
}
}
五、直接选择排序
1、原理：直接选择排序就是第一次从R[0]-R[n-1]中选取最小值，与R[0]交换，第二次从R[1]-R[n-1]中选取最小值，与R[1]交换，…，第i次从R[i-1]-R[n-1]中选取最小值，与R[i-1]交换，…，第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列
2、C++代码
void SelectSort(elemtype R[], int n) {
int i, j, m;
elemtype t;
for (i = 0; i < n - 1; i++) {
m = i;
for (j = i + 1; j < n; j++)
if (R[j] < R[m]) m = j;
if (m != i) {
t = R[i];
R[i] = R[m];
R[m] = t;
}
}
}
六、基数排序
1、概念：基数排序属于“分配式排序”，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog（r）m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。
2、原理：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
3、C++代码
int maxbit(int data[], int n) //辅助函数，求数据的最大位数
{
int d = 1; //保存最大的位数
int p = 10;
for(int i = 0; i < n; ++i)
{
while(data[i] >= p)
{
p *= 10;
++d;
}
}
return d;
}
void radixsort(int data[], int n) //基数排序
{
int d = maxbit(data, n);
int *tmp = newint[n];
int *count = newint[10]; //计数器
int i, j, k;
int radix = 1;
for(i = 1; i <= d; i++) //进行d次排序
{
for(j = 0; j < 10; j++)
count[j] = 0; //每次分配前清空计数器
for(j = 0; j < n; j++)
{
k = (data[j] / radix) % 10; //统计每个桶中的记录数
count[k]++;
}
for(j = 1; j < 10; j++)
count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶
for(j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中
{
k = (data[j] / radix) % 10;
tmp[count[k] - 1] = data[j];
count[k]--;
}
for(j = 0; j < n; j++) //将临时数组的内容复制到data中
data[j] = tmp[j];
radix = radix * 10;
}
delete[]tmp;
delete[]count;
}
七、直接插入排序
1、概念：直接插入排序就是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。其时间复杂度为O (n^2)，
2、原理：在当前有序区R[1…i-1]中查找R[i]的正确插入位置k(1≤k≤i-1)；然后将R[k．．i-1]中的记录均后移一个位置，腾出k位置上的空间插入R[i]。
3、C++代码
int main()
{
int a[]={98,76,109,34,67,190,80,12,14,89,1};
int k=sizeof(a)/sizeof(a[0]);
int i,j;
for(i=1;i<k;i++)//循环从第2个元素开始
{
if(a[i]<a[i-1])
{
int temp=a[i];
for(j=i-1;j>=0 && a[j]>temp;j--)
{
a[j+1]=a[j];
}
a[j+1]=temp;//此处就是a[j+1]=temp;
}
}
for(int f=0;f<k;f++)
{
cout<<a[f]<<" ";
}
return 0;
}
八、折半插入排序
1、概念：折半插入排序就是不断的依次将元素插入前面已排好序的序列中。
2、原理：在将一个新元素插入已排好序的数组的过程中，寻找插入点时，将待插入区域的首元素设置为a[low]，末元素设置为a[high]，则轮比较时将待插入元素与a[m]，其中m=(low+high)/2相比较,如果比参考元素小，则选择a[low]到a[m-1]为新的插入区域(即high=m-1)，否则选择a[m+1]到a[high]为新的插入区域（即low=m+1），如此直至low<=high不成立，即将此位置之后所有元素后移一位，并将新元素插入a[high+1]。
3、C++代码
void BInsertSort(Record *arr, int length) // length是要排序的元素的个数，0号单元除外
{
for (int i = 2; i <= length; ++i)
{
arr[0] = arr[i]; // 将arr[i]暂存到arr[0]
int low = 1;
int high = i - 1;
while (low <= high) // 在arr[low..high]中折半查找有序插入的位置
{
int m = (low + high) / 2; // 折半
if (arr[0].key < arr[m].key) // 关键字相同时，使low = m + 1，到高半区，保证稳定性
{
high = m - 1; // 插入点在低半区
}
else
{
low = m + 1; // 插入点在高半区
}
}
for (int j = i - 1; j >= high + 1; --j)
{
arr[j + 1] = arr[j]; // 记录后移
}
arr[high + 1] = arr[0]; // 插入
}
}
int main(void)
{
freopen("in.txt", "r", stdin);
Record a[LEN + 1] = {0};
for (int i = 1; i <= LEN; i++)
cin >> a[i].key >> a[i].otherinfo;
BInsertSort(a, LEN);
for (int i = 1; i <= LEN; i++)
cout << a[i].key << '\t' << a[i].otherinfo << endl;
return 0;
}
九、归并排序
1、概念：归并排序就是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
2、原理：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。设定两个指针，最初位置分别为两个已经排序序列的起始位置。比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。
重复直到某一指针超出序列尾。
3、C++代码
void merge(int *data, int start, int mid, int end, int *result)
{
int i, j, k;
i = start;
j = mid + 1; //避免重复比较data[mid]
k = 0;
while (i <= mid && j <= end) //数组data[start,mid]与数组(mid,end]均没有全部归入数组result中去
{
if (data[i] <= data[j]) //如果data[i]小于等于data[j]
result[k++] = data[i++]; //则将data[i]的值赋给result[k]，之后i,k各加一，表示后移一位
else
result[k++] = data[j++]; //否则，将data[j]的值赋给result[k]，j,k各加一
}
while (i <= mid) //表示数组data(mid,end]已经全部归入result数组中去了，而数组data[start,mid]还有剩余
result[k++] = data[i++]; //将数组data[start,mid]剩下的值，逐一归入数组result
while (j <= end) //表示数组data[start,mid]已经全部归入到result数组中去了，而数组(mid,high]还有剩余
result[k++] = data[j++]; //将数组a[mid,high]剩下的值，逐一归入数组result
for (i = 0; i < k; i++) //将归并后的数组的值逐一赋给数组data[start,end]
data[start + i] = result[i]; //注意，应从data[start+i]开始赋值
}
void merge_sort(int *data, int start, int end, int *result)
{
if (start < end)
{
int mid = start + (end-start) / 2;//避免溢出int
merge_sort(data, start, mid, result); //对左边进行排序
merge_sort(data, mid + 1, end, result); //对右边进行排序
merge(data, start, mid, end, result); //把排序好的数据合并
}
}
void amalgamation(int *data1, int *data2, int *result)
{
for (int i = 0; i < 10; i++)
result[i] = data1[i];
for (int i = 0; i < 10; i++)
result[i + 10] = data2[i];
}
摘自百度百科
3093
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
