七大排序算法總結（含優化）

冒泡排序
#include <cstdio>
#define N 100
using namespace std;
int a[N];
void bubbleSort(int n)        //冒泡排序優化
{
	int t, j, flag=n, temp;
	while(flag>0)
	{
		j=flag;
		flag=0;
		for(t=1; t<j; ++t)           //其實冒泡排序每次排都是選出一段區域最大的
		{
			if(a[t]<a[t-1])
			{
				temp = a[t];
				a[t] = a[t-1];
				a[t-1] = temp;
				flag = t;                
			}
		}                               //每次循環結束後flag後面的都是已經排好序了，都比前面大，所以下一次就可以從0-flag排
	}
}
void print(int n)
{
	for(int t=0; t<n; ++t)
	{
		if(t+1<n)
			printf("%d ", a[t]);
		else printf("%d\n", a[t]); 
	}
}
/*
6
3 2 1 2 4 1
*/
int main()
{
	int n;
	scanf("%d", &n);
	for(int t=0; t<n; ++t)
	{
		scanf("%d", a+t);
	}
	bubbleSort(n);
	print(n);
	return 0;
}

直接插入排序
#include <cstdio>
#define N 100
using namespace std;
int a[N];
void insertSort(int n)              //直接插入排序優化
{
	int i, temp, j;
	for(i=1; i<n; ++i)
	{
		for(j=i-1; j>=0&&a[j]>a[j+1]; --j)         //每次都把a[i]放入0~(i-1)有序的序列中
		{
			temp = a[j];
			a[j] = a[j+1];
			a[j+1] = temp;
		}
	}
}
void print(int n)
{
	for(int t=0; t<n; ++t)
	{
		if(t+1<n)
			printf("%d ", a[t]);
		else printf("%d\n", a[t]); 
	}
}
/*
6
3 2 1 2 4 1
*/
int main()
{
	int n;
	scanf("%d", &n);
	for(int t=0; t<n; ++t)
	{
		scanf("%d", a+t);
	}
	insertSort(n);
	print(n);
	return 0;
}

希爾排序
#include <cstdio>
#define N 100
using namespace std;
int a[N];
//希爾排序，希爾排序在時間效率上比冒泡排序、直接插入排序高
void ShellSort1(int n)           
{
	int j, i, gap, k;                 //間隔,同一組中元素間隔
	for(gap=n/2; gap>0; gap/=2)    
	{
		for(i=gap; i<n; ++i)
		{
			if(a[i]<a[i-gap])       //同一組元素中進行直接插入排序
			{
				k = a[i];           //插入a[i]元素進前面的i-gap,i-2*gap,...
				j = i-gap;
				while(j>=0&&k<a[j])       //直接插入排序
				{
					a[j+gap] = a[j];         
					j -= gap;
				}
				a[j+gap] = k;
			}
		}
	}
}
void ShellSort2(int n)             //優化後的希爾排序
{
	int j, i, gap, k, temp;
	for(gap=n/2; gap>0; gap/=2)
	{
		for(i=gap; i<n; ++i)
		{
			for(j=i-gap; j>=0&&a[j]>a[j+gap]; j-=gap)       //冒泡排序
			{
				temp = a[j+gap];
				a[j+gap] = a[j];
				a[j] = temp;
			}
		}
	}
}
void print(int n)
{
	for(int t=0; t<n; ++t)
	{
		if(t+1<n)
			printf("%d ", a[t]);
		else printf("%d\n", a[t]); 
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	for(int t=0; t<n; ++t)
	{
		scanf("%d", a+t);
	}
	ShellSort2(n);         
	print(n);
	return 0;
}

直接選擇排序
#include <cstdio>
#define N 100
using namespace std;
int a[N];
void swap1(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
void swap2(int &a, int &b)
{
	if(a!=b)            //注意異或交換兩個元素時要判斷，否則a^b=0
	{
		a = a^b;
		b = a^b;
		a = a^b;
	}
}
void SelectSort(int n)                   //直接選擇排序
{
	int i, t, minIndex, temp;
	for(i=0; i<n; ++i)
	{
		minIndex = i;
		for(t=i+1; t<n; ++t)
		{
			if(a[t]<a[minIndex])
				minIndex = t;
		}
		if(minIndex != i)       //交換兩個元素
		{		
			swap2(a[i], a[minIndex]);
		}
	}
}

void print(int n)
{
	for(int t=0; t<n; ++t)
	{
		if(t+1<n)
			printf("%d ", a[t]);
		else printf("%d\n", a[t]); 
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	for(int t=0; t<n; ++t)
	{
		scanf("%d", a+t);
	}
	SelectSort(n);
	print(n);
	return 0;
}

歸併排序
#include <cstdio>
#define N 100
using namespace std;
int a[N];
//歸併排序的時間複雜度爲N*logN,效率是比較高的，比選擇、直接插入、冒泡、快排快
void mergearray(int l, int mid, int r, int *temp)        //temp數組只是暫時存放數據
{
	int t, i=l, j=mid+1, k=0;
	while(i<=mid&&j<=r)
	{
		if(a[i]<a[j])
			temp[k++] = a[i++];
		else temp[k++] = a[j++];
	}
	while(i<=mid)
	{
		temp[k++] = a[i++];
	}
	while(j<=r)
	{
		temp[k++] = a[j++];
	}
	for(t=0; t<k; ++t)
	{
		a[l+t] = temp[t];            //更新數組順序
	}
}
void mergesort(int *temp, int l, int r)       //遞歸分組
{
	int mid;
	if(r>l)
	{
		mid = (l+r)>>1;
		mergesort(temp, l, mid);          //遞歸   左邊有序
		mergesort(temp, mid+1, r);        //遞歸   右邊有序
		mergearray(l, mid, r, temp);      //合併   將兩個數組合並
	}
}

void MergeSort(int n)          //歸併排序，先遞歸分組，然後在合併排序
{
	int *temp = new int[n];
	mergesort(temp, 0, n-1);
	delete []temp;
}

void print(int n)
{
	for(int t=0; t<n; ++t)
	{
		if(t+1<n)
			printf("%d ", a[t]);
		else printf("%d\n", a[t]); 
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	for(int t=0; t<n; ++t)
	{
		scanf("%d", a+t);
	}
	MergeSort(n);
	print(n);
	return 0;
}

快速排序
#include <cstdio>
#define N 100
using namespace std;
int a[N];
//快速排序，時間複雜度爲N*logN,採用挖坑填數(使得所選的基準數左邊都是比它小，右邊比它大)+分治法（整個數組有序）
//在各種排序中是最重要的!!!
void QuickSort(int l, int r) 
{
	int temp, i=l, j=r;
	temp = a[l];          //選取最左邊的數作爲基準數,已它爲界,在l的位置挖了個坑
	if(l<r)
	{
		while(i<j)
		{
			while(j>i&&a[j]>=temp)         //從右邊開始找小於temp的數
			{
				j--;
			}
			if(j>i)
			{
				a[i++] = a[j];            //填補左邊坑，右邊挖了坑
			}
			while(j>i&&a[i]<temp)         //從左邊開始找大於temp的數
			{
				i++;
			}
			if(j>i)
			{
				a[j--] = a[i];             //填補右邊坑，左邊完了坑
			}
		}
		a[i] = temp;           //循環一直以來就有一個坑始終未填，最後填上temp，這是i左邊都比temp小，右邊都比temp大
		QuickSort(l, i-1);     //分治，左邊區間
		QuickSort(i+1, r);
	}
}

void print(int n)
{
	for(int t=0; t<n; ++t)
	{
		if(t+1<n)
			printf("%d ", a[t]);
		else printf("%d\n", a[t]); 
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	for(int t=0; t<n; ++t)
	{
		scanf("%d", a+t);
	}
	QuickSort(0, n-1);
	print(n);
	return 0;
}

堆排序
#include <cstdio>
#include <cmath>
#include <iomanip>
#define N 100
using namespace std;
int a[N];
//堆排序，建立最大堆，因爲輸出時數組元素是遞增的
//堆排序其實是建立一棵完全二叉樹

void MaxHeapFixDown(int i, int n)      //下沉
{
	int j=i*2, temp=a[i];           //j表示i的左孩子結點
	while(j<n)                        
	{
		if(j+1<n)
			a[j]>=a[j+1]?j:j++;
		if(temp>=a[j])              //表示它下面都是符合最大堆的性質，跳出循環
			break;
		a[i] = a[j];
		i = j;
		j = i*2;
	}
	a[i] = temp;
}

void MakeMaxHeap(int n)          //建立最大堆
{
	int t;          
	for(t=n/2-1; t>=0; --t)        //先從最後面非葉子結點開始,最後再到根節點(底部有序，才能放根節點)
	//注意，這裏n是不存在的點
	{
		MaxHeapFixDown(t, n);   
	}
}

void HeapSort(int n)                 //堆排序，升序
{
	for(int t=n-1; t>0; --t)
	{
		swap(a[t], a[0]);            //最後一個元素與根元素交換
		MaxHeapFixDown(0, t);        //因爲除了根節點，下面的堆都是有序的，每次整個數組都不包括原來與a[t]相換的a[0]
	}
}

void print(int n)
{
	for(int t=0; t<n; ++t)
	{
		if(t+1<n)
			printf("%d ", a[t]);
		else printf("%d\n", a[t]); 
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	for(int t=0; t<n; ++t)
	{
		scanf("%d", a+t);
	}
	MakeMaxHeap(n);	
	HeapSort(n);
	print(n);
	return 0;
}

/*
6
3 2 1 2 4 1
*/