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

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