恩，关于一个软件工程师必须要知道的排序算法！

排序的八算法都是自己反复咀嚼过很多遍的，力求精益求精！

不懂得可以看看，很常用！



#include<iostream>

void Swap(int *a,int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

/*插入算法（insertion sort）把要排序的数组分成两部分：
第一部分包含了这个数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素。
在第一部分排序后，再把这个最后元素插入到此刻已是有序的第一部分里的正确位置中。
有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，
但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,
从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，
时间复杂度为⊙(㎡)。是稳定的排序方法。
*/
void InsertSort(int array[],int length)
{
int temp,i,j;
for(i=1;i<length;i++)
{
temp = array[i];//存储原有数组
for(j=i-1;j>=0&&array[j]>temp;j--)//注意循环第一趟跳出时j = -1
{
array[j+1] = array[j];
}
array[j+1] = temp;
}
}
//折半插入排序
void HalfInsertSort(int array[],int length)
{
int temp,i,j,k;
int low,mid,high;
for(i=1;i<length;i++)
{
temp = array[i];//存储原有数组
low = 0;
high = i-1;
while(low<=high)
{
mid = (low + high)/2;
if(temp>array[mid])
low = mid+1;
else
high = mid-1;
}

for(j=i-1;j>high;j--)
{
array[j+1] = array[j];
}
array[high+1] = temp;
for(k=0;k<length;k++) printf(" %4d ",array[k]);
printf("/n");

}
}
/*
希尔排序是一种插入排序法
不断把待排序的对象分成若干个小组，对同一小组内的对象采用直接插入法排序，
当完成了所有对象都分在一个组内的排序后，排序过程结束。

希尔排序实际上是对插入排序的一种优化，主要是为了节省数组移动的次数。
具体做法是，扩大数字之间的比较间隔，如何是个数字进行排序的话，根据公式h=h*3+1，
那么比较间隔为。也就是说是数组下标{0，，};{1，，};{2，};{3，}进行比较，
然后将比较间隔降低，根据公式h=(h-1)*3得,在进行比较(实际就是插入排序的方法了)，左后得出结果。
*/
void ShellSort(int array[],int length)
{
int temp,i,j,increment = 0;
while(length/3>increment)
{
increment = increment*3 + 1;
}
while(increment>0)
{
for(i=increment;i<length;i++)
{
temp = array[i];
for(j=i-increment;j>=0&&array[j]>temp;j-=increment)
{
array[j+increment] = array[j];
}
array[j+increment] = temp;//跳出后j的值是原先j-increment的值
for(int k=0;k<length;k++) printf(" %4d ",array[k]);
printf("/n");
}
increment = (increment-1)/3;
}
}
/*
冒泡排序算法的思想：很简单，每次遍历完序列都把最大（小）的元素放在最前面，
然后再对剩下的序列从父前面的一个过程，每次遍历完之后待排序序列就少一个元素，
当待排序序列减小为只有一个元素的时候排序就结束了。
因此，复杂度在最坏的情况下是O（N ^ 2）。
*/
void BubbleSort(int array[],int length)
{
bool exchange;
for(int i=0;i<length;i++)
{
exchange = false;
for(int j=0;j<length-i-1;j++)
{
if(array[j+1]<array[j])
{
exchange = true;
Swap(&array[j+1],&array[j]);
}
for(int k=0;k<length;k++) printf(" %4d ",array[k]);
printf("/n");
}
if(false == exchange)
break;
}
}
/*
选择排序
　 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
　　选择排序是不稳定的排序方法。
　　n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
　　①初始状态：无序区为R[1..n]，有序区为空。
　　②第趟排序
　　在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第个记录R[1]交换，
使R[1..1]和R[2..n]分别变为记录个数增加个的新有序区和记录个数减少个的新无序区。
　　……
　　③第i趟排序
　　第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。
该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第个记录R交换，
使R[1..i]和R分别变为记录个数增加个的新有序区和记录个数减少个的新无序区。
　　这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。
*/
void ChooseSort(int array[],int length)
{
int k,i,j;
for(i=0;i<length;i++)
{
k = i;
for(j=i+1;j<length;j++)//j始终开始时I的下一个存储地址
{
if(array[j]<array[k])
{
k = j;
}
if(k!=i)
{
Swap(&array[i],&array[k]);
}
}
}
}
/*
归并排序的算法思想：把待排序序列分成相同大小的两个部分，
依次对这两部分进行归并排序，完毕之后再按照顺序进行合并。
采用分治法进行自顶向下的算法设计，形式更为简洁。
合并过程 　
合并过程中，设置i，j和p三个指针，
其初值分别指向这三个记录区的起始位置。
合并时依次比较R[i]和R[j]的关键字，取关键字较小的记录复制到R1[p]中
，然后将被复制记录的指针i或j加，以及指向复制位置的指针p加。 　
重复这一过程直至两个输入的子文件有一个已全部复制完毕(不妨称其为空)，
此时将另一非空的子文件中剩余记录依次复制到R1中即可。
*/
void Merge(int *array,int low,int mid,int high)
{
int *temp;
int i=low,j=mid+1,p=0; //置初始值
temp = (int *)malloc((high-low+1)*sizeof(int));
if(!temp)//分配失败
return;
while(i<=mid&&j<=high) //两子文件非空时取其小者输出到temp[p]上
{
temp[p++]=(array[i]<=array[j])?array[i++]:array[j++];
}
while(i<=mid) //若第个子文件非空，则复制剩余记录到temp中
{
temp[p++]=array[i++];
}
while(j<=high) //若第个子文件非空，则复制剩余记录到temp中
{
temp[p++]=array[j++];
}
for(p=0,i=low;i<=high;p++,i++) array[i]=temp[p]; //归并完成后将结果复制回array[low..high]

}
void MergeSort(int array[],int low,int high)
{
if(low < high)
{
int mid;
mid = (low + high)/2;
MergeSort(array,low,mid); // 对前半部分进行排序
MergeSort(array,mid+1,high);// 对后半部分进行排序
Merge(array,low,mid,high); // 合并前后两部分
}
}

/*
堆的定义：
n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质（简称为堆性质）：
（）ki≤K2i且ki≤K2i+1 或（）Ki≥K2i且ki≥K2i+1（≤i≤）
若将此序列所存储的向量R[1……n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：
树中任一非叶结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。
堆的这个性质使得可以迅速定位在一个序列之中的最小（大）的元素。

堆排序算法的过程如下：
得到当前序列的最小（大）的元素
把这个元素和最后一个元素进行交换，这样当前的最小（大）的元素就放在了序列的最后，而原先的最后一个元素放到了序列的最前面
的交换可能会破坏堆序列的性质（注意此时的序列是除去已经放在最后面的元素），因此需要对序列进行调整，使之满足于上面堆的性质
重复上面的过程，直到序列调整完毕为止。
*/
// array是待调整的堆数组,i是待调整的数组元素的位置,length是数组的长度
void HeapAdjust(int array[], int i, int nLength)
{
int nChild, nTemp;
for(nTemp = array[i]; 2 * i + 1 < nLength; i = nChild)//注意此处循环是循环一个结点的子结点的所有子结点
{
nChild = 2 * i + 1;// 子结点的位置是父结点位置* 2 + 1　
if(nChild != nLength - 1 && array[nChild + 1] > array[nChild])
{
++nChild;// 得到子结点中较大的结点　
}

if (nTemp < array[nChild]) // 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
{
array[i] = array[nChild];
}
else
{
break;
}
}
array[i] = nTemp;// 最后把需要调整的元素值放到合适的位置
}
// 堆排序算法
void HeapSort(int array[], int length)
{
int j;
for (int i = length / 2 - 1; i >= 0; --i)// 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
{
HeapAdjust(array, i, length);
for(j=0;j<10;j++) printf("%4d",array[j]);
printf("/n");
}
for (int i = length - 1; i > 0; --i)// 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
{
Swap(&array[0], &array[i]);// 把第一个元素和当前的最后一个元素交换,　保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
HeapAdjust(array, 0, i); // 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
for(j=0;j<10;j++) printf("%4d",array[j]);
printf("/n");
}
}

/*
快速排序的算法思想：
选定一个枢纽元素，对待排序序列进行分割，
分割之后的序列一个部分小于枢纽元素，一个部分大于枢纽元素，再对这两个分割好的子序列进行上述的过程。
首先你的脑子里先浮现一个数组和三个指针，
第一个指针称为p指针，在整个过程结束之前它牢牢的指向第一个数，
第二个指针和第三个指针分别为lo指针和hi指针，分别指向最左边的值和最右边的值。
lo指针和hi指针从两边同时向中间逼近，在逼近的过程中不停的与p指针的值比较，
如果lo指针的值比p指针的值小，lo++，还小还++，再小再++，直到碰到一个大于p指针的值，这时视线转移到hi指针，
如果hi指针的值比p指针的值大，hi--，还大还--，再大再--，直到碰到一个小于p指针的值。
这时就把lo指针的值和hi指针的值做一个调换。
持续这过程直到两个指针碰面，这时把p指针的值和碰面的值做一个调换，然后返回p指针新的位置。
*/
// 对一个给定范围的子序列选定一个枢纽元素,执行完函数之后返回分割元素所在的位置,
// 在分割元素之前的元素都小于枢纽元素,在它后面的元素都大于这个元素
int Partition(int array[], int low, int high)
{
int pivot = array[low]; // 采用子序列的第一个元素为枢纽元素
while (low < high)
{
while (low < high && array[high] >= pivot)
{
high--; // 从后往前在后半部分中寻找第一个小于枢纽元素的元素
}
Swap(&array[low], &array[high]); // 将这个比枢纽元素小的元素交换到前半部分

while (low < high && array[low] <= pivot)
{
low++; // 从前往后在前半部分中寻找第一个大于枢纽元素的元素
}
Swap(&array[low], &array[high]); // 将这个比枢纽元素大的元素交换到后半部分

}
array[low] = pivot;
return low; // 返回枢纽元素所在的位置S
}
int Partition2(int array[], int low, int high)
{
int pivot = array[low]; // 采用子序列的第一个元素为枢纽元素
int i = array[low];
for(int j=low+1;j<=high;j++)
{
if(array[j] <= pivot)
{
i++;
if(i != j)
Swap(&array[i],&array[j]);
}
}
Swap(&array[low],&array[i]);
return i; // 返回枢纽元素所在的位置S
}

int Median(int a[],int low,int high)
{
int mid = (low+high)/2;
if(a[low]>a[mid]) Swap(&a[low],&a[mid]);
if(a[low]>a[high]) Swap(&a[low],&a[high]);
if(a[mid]>a[high]) Swap(&a[mid],&a[high]);

return a[low];
}

int Partition3(int array[], int low, int high)
{
int pivot = Median(array,low,high); // 采用子序列的第一个元素为枢纽元素

while(low<high)
{
while (low < high && array[high] > pivot)
{
high--;
}
Swap(&array[low], &array[high]);

while (low < high && array[low] < pivot)
{
low++;
}
Swap(&array[low], &array[high]);
}

return low;
}

// 快速排序
void QuickSort(int array[], int low, int high)
{
if (low < high)
{
int n = Partition(array, low, high);
QuickSort(array, low, n-1);
QuickSort(array, n + 1, high);
}
}