总结各种排序算法(C++)

    排序算法是面试中常考的知识点，最近对常见的排序算法作了复习和了解，下面对各种的排序算法C++实现做下总结。

1、快速排序

void QuickSort(int * num, int left, int right)
{
if (left >= right)
return;
int i = left;
int j = right + 1;
int temp;
do
{
do
{
i++;
} while (i < right && num[i] < num[left]);
do
{
j--;
} while (j > left && num[j] > num[left]);
if (i < j)
{
swap(&num[i], &num[j]);
}
}while (i < j);
swap(&num[j], &num[left]);

QuickSort(num, left, j-1);
QuickSort(num, j+1, right);
}

2、选择排序

void SelectSort(int * num, int length)
{
for (int i=0;i<length-1;i++)
{
int minNum = num[i];
int minPos = i;
for (int j=i+1;j<length;j++)
{
if (num[j] < minNum)
{
minNum = num[j];
minPos = j;
}
}
num[minPos] = num[i];
num[i] = minNum;
}
}

3、冒泡排序

void BubbleSort(int * num, int length)
{
for (int i = 0; i < length; i++)
{
for (int j = i; j < length; j++)
{
if (num[i] > num[j])
{
swap(&num[i], &num[j]);
}
}
}
}

4、插入排序

void InsertSort(int * num, int length)
{
for (int i=0;i<length;i++)
{
int j = i;
int target = num[i];

while (j > 0 && target < num[j - 1])
{
num[j] = num[j - 1];
j--;
}
num[j] = target;
}
}

5、希尔排序

void ShellSort(int * num, int length)
{
for (int gap = length / 2; gap > 0; gap /= 2) //步长
{
for (int i = gap; i < length; i++)
{
for (int j = i - gap; j >= 0; j -= gap)  //插入排序
{
if (num[j] > num[j + gap])
{
swap(&num[j], &num[j+gap]);
}
}
}
}
}

6、归并排序

// 归并排序中的合并算法
void Merge(int array[], int start, int mid, int end)
{
　　　 int temp1[10], temp2[10];
　　　 int n1, n2;
　　　 n1 = mid - start + 1;
　　　 n2 = end - mid;
　　　 // 拷贝前半部分数组
　　　 for (int i = 0; i < n1; i++)
　　　 {
　　　　　　　 temp1[i] = array[start + i];
　　　 }
　　　 // 拷贝后半部分数组
　　　 for (int i = 0; i < n2; i++)
　　　 {
　　　　　　　 temp2[i] = array[mid + i + 1];
　　　 }
　　　 // 把后面的元素设置的很大
　　　 temp1[n1] = temp2[n2] = 1000;
　　　 // 逐个扫描两部分数组然后放到相应的位置去
　　　 for (int k = start, i = 0, j = 0; k <= end; k++)
　　　 {
　　　　　　　 if (temp1[i] <= temp2[j])
　　　　　　　 {
　　　　　　　　　　　 array[k] = temp1[i];
　　　　　　　　　　　 i++;
　　　　　　　 }
　　　　　　　 else
　　　　　　　 {
　　　　　　　　　　　 array[k] = temp2[j];
　　　　　　　　　　　 j++;
　　　　　　　 }
　　　 }
}
// 归并排序
void MergeSort(int array[], int start, int end)
{
　　　 if (start < end)
　　　 {
　　　　　　　 int i;
　　　　　　　 i = (end + start) / 2;
　　　　　　　 // 对前半部分进行排序
　　　　　　　 MergeSort(array, start, i);
　　　　　　　 // 对后半部分进行排序
　　　　　　　 MergeSort(array, i + 1, end);
　　　　　　　 // 合并前后两部分
　　　　　　　 Merge(array, start, i, end);
　　　 }
}

7、堆排序

void Heapfy(int A[],int idx,int max)      //建立最大堆
{
int left=idx*2+1;
int right=left+1;

int largest=idx;

if(left<max&&A[left]>A[idx]){largest=left;}

if(right<max&&A[largest]<A[right]){largest=right;}

if(largest!=idx)
{
int temp=A[largest];   //较大的节点值将交换到其所在节点的父节点
A[largest]=A[idx];
A[idx]=temp;

Heapfy(A,largest,max); //递归遍历

}
}

void buildHeap(int A[],int ll)
{
int len=ll;

for(int i=len/2-1;i>=0;--i)
{
Heapfy(A,i,len);     //建立最大堆，将堆中最大的值交换到根节点
}

for(int i=len-1;i>=1;--i)
{
int temp=A[0];   //将当前堆的根节点交换到堆尾的指定位置
A[0]=A[i];
A[i]=temp;

Heapfy(A,0,i);  //建立下一次的最大堆
}
}

8、外排序

外排序（External sorting）是指能够处理极大量数据的排序算法。通常来说，外排序处理的数据不能一次装入内存，只能放在读写较慢的外存储器（通常是硬盘）上。外排序通常采用的是一种“排序-归并”的策略。在排序阶段，先读入能放在内存中的数据量，将其排序输出到一个临时文件，依此进行，将待排序数据组织为多个有序的临时文件。尔后在归并阶段将这些临时文件组合为一个大的有序文件，也即排序结果。

外排序是指在排序期间全部对象个数太多，不能同时存放在内存，必须根据排序过程的要求，不断在内、外存之间移动的排序。比如常见的有外归并排序。