一、排序的基本概念和分类

假设含有n个记录的序列为{r₁,r₂,…,r_n}，其相应的关键字分别为{k₁,k₂,…,k_n}，需确定1,2，…，n的一种排列p₁,p₂,…p_n,使其相应的关键字分别满足k_p1<=k_p2<=…<=k_pn非递减（或非递增）关系，即使得序列称为一个按关键字有序序列{r_p1,r_p2,…,r_pn}，这样的操作就称为排序。

• 排序的稳定性

假设k_i=k_j（i<=n，1<=j<=n，i!=j），且在排序前的序列中r_i领先于r_i（即i<j）。如果排序后r_i仍领先于r_j，则称所用的排序方法是稳定的；反之，若可能使得排序后的序列中r_j领先r_i，则称所用的排序方法是不稳定的。

• 内排序与外排序

内排序是在排序整个过程中，待排序的所有记录全部被放置在内存中。外排序是由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行。

二、常见的排序方法

• 冒泡排序

冒泡排序可能是大家最耳熟能详的一种排序算法，简单易懂，这里不做赘述；

void BubbleSort(int arr[], int len) {
		for(int i = 0; i < len; ++i) {
			for(int j = i; j < len; ++j) {
				if(arr[j] > arr[j+1]) {
					swap(arr[j], arr[j+1]);
				}
			}
		}
	}

• 优化后的冒泡排序

因为冒泡排序存在许多没有必要的循环，所以加了一个flag，当其不发生交换时，说明该索引后面的数，已经是有序的了，避免了效率的浪费。

void SBubbleSort(int arr[], int len) {
		bool flag = true;
		for(int i = 0; i < len && flag; ++i) {
			flag = false;
			for(int j = 0; j < len; ++j) {
				if(arr[j] > arr[j+1]) {
					swap(arr[j], arr[j+1]);
					flag = true;
				}
			}
		}
	}

• 选择排序

void SelectSort(int arr[], int len) {
		int minIndex;
		for(int i = 0; i < len; ++i) {
			minIndex = i;
			for(int j = i + 1; j < len; ++j) {
				if(arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}
			swap(arr[minIndex], arr[i]);
		}
	}

• 插入排序

void InsertSort(int arr[], int len) {
		int temp;
		int i, j;
		for(i = 1; i < len; ++i) {
			if(arr[i] < arr[i-1]) {
				temp = arr[i];
				for(j = i - 1; arr[j] > temp; --j) {
					arr[j+1] = arr[j];
				}
				arr[j+1] = temp;
			}
		}
	}

• 快速排序

void QuickSort(int arr[], int first, int last) {
		int i = first, j = last;
		if(i > j) {
			return;
		}
		while(i < j) {
			while(i < j && arr[j] >= arr[first]) {
				--j; 
			}
			while(i < j && arr[i] <= arr[first]) {
				++i;
			}
			if(i < j) {
				swap(arr[i], arr[j]);
			}
		}
		swap(arr[first], arr[j]);
		QuickSort(arr, first, j - 1);
		QuickSort(arr, j + 1, last);
	}

三、测试

#include<iostream>
#include<ctime>

using namespace std;

class Sort {
public:
	void BubbleSort(int arr[], int len) {
		for(int i = 0; i < len; ++i) {
			for(int j = i; j < len; ++j) {
				if(arr[j] > arr[j+1]) {
					swap(arr[j], arr[j+1]);
				}
			}
		}
	}
	
	void SBubbleSort(int arr[], int len) {
		bool flag = true;
		for(int i = 0; i < len && flag; ++i) {
			flag = false;
			for(int j = 0; j < len; ++j) {
				if(arr[j] > arr[j+1]) {
					swap(arr[j], arr[j+1]);
					flag = true;
				}
			}
		}
	}
	
	void SelectSort(int arr[], int len) {
		int minIndex;
		for(int i = 0; i < len; ++i) {
			minIndex = i;
			for(int j = i + 1; j < len; ++j) {
				if(arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}
			swap(arr[minIndex], arr[i]);
		}
	}
	
	void InsertSort(int arr[], int len) {
		int temp;
		int i, j;
		for(i = 1; i < len; ++i) {
			if(arr[i] < arr[i-1]) {
				temp = arr[i];
				for(j = i - 1; arr[j] > temp; --j) {
					arr[j+1] = arr[j];
				}
				arr[j+1] = temp;
			}
		}
	}
	
	void QuickSort(int arr[], int first, int last) {
		int i = first, j = last;
		if(i > j) {
			return;
		}
		while(i < j) {
			while(i < j && arr[j] >= arr[first]) {
				--j; 
			}
			while(i < j && arr[i] <= arr[first]) {
				++i;
			}
			if(i < j) {
				swap(arr[i], arr[j]);
			}
		}
		swap(arr[first], arr[j]);
		QuickSort(arr, first, j - 1);
		QuickSort(arr, j + 1, last);
	}
};

#include"AllSort.h"

#define NUM 20

int main() {
	srand((unsigned)time(NULL));
	int arr[NUM];
	for(int i = 0; i < NUM; ++i) {
		arr[i] = rand() % 20;
	}
	Sort sort;
	clock_t start; 
	start = clock();
	//sort.BubbleSort(arr, NUM);
	//sort.SBubbleSort(arr, NUM);
	sort.InsertSort(arr, NUM);
	//sort.SelectSort(arr, NUM);
	//sort.QuickSort(arr, 0, NUM - 1);
	cout << "用时：" << (((double)clock() - start) / CLOCKS_PER_SEC) <<endl;
	for(int i = 0; i < NUM; ++i) {
		cout << arr[i] << "  ";
	}
	
	getchar();
	return 0;
}