排序算法

// 两个数的交换
void swap(int arr[], int i, int j)
{
	int tmp;

	tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}
// 当交换的两个数相等或与自身交换时，下面两种实现不能用
void swap(int arr[], int i, int j)
{
	arr[i] ^= arr[j];
	arr[j] ^= arr[i];
	arr[i] ^= arr[j];
}

void swap(int arr[], int i, int j)
{
	arr[i] -= arr[j];
	arr[j] += arr[i];
	arr[i] = arr[j] - arr[i];
}

1.插入排序
基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子表中的适当位置，直到全部记录插入完成为止。常规插入排序分两种，即直接插入排序和希尔排序。
1.1 直接插入排序
假设待排序的记录放在数组R[0...n-1]中，排序过程的某一中间时刻，R被划分成两个子区间R[0..i-1]和R[i..n-1],其中：前一个区间是已经排好序的有序区，后一个子区间是当前未排序的部分，不妨称为无序区。直接插入排序的基本操作是将当前无序区的第一个记录R[i]插入到R[0..i-1]中适当的位置，使R[0..i]变为新的有序区-------算法时间复杂度o(n^2)。
实现：

void insertSort(int arr[], int n)
{
	int i, j;
    int tmp;
  
    for (i = 1; i < n; i++) {
        tmp = arr[i];
        for (j = i - 1; j >= 0  && tmp < arr[j]; j--) {
            arr[j + 1] = arr[j];
        }
        arr[j + 1] = tmp;
    }
}

1.2 shell排序
希尔排序也是一种插入排序方法，有时也叫做缩小增量排序(diminishing increment sort)，实际上是一种分组插入方法。基本思想是：先取定一个小于n的整数d1作为第一个增量，把表的全部记录分成d1个组，所有距离为d1的倍数的记录放在同一个组中，在各组内进行直接插入排序；然后取第二个增量d2(<d1),重复上述的分组和排序，直至所取的增量dt=1(dt<dt-1<..d2<d1)，及所有记录放在同一组中进行直接插入排序为止。算法最好时间复杂度o(nlogn)。
实现:

void shellSort(int arr[], int n)
{
	int tmp, i, j;
	int inc; // increment

	for (inc = n / 2; inc > 0; inc /= 2) {
		// 对一组增量为inc的元素进行插入排序
		for (i = inc; i < n; i++) {
			tmp = arr[i];
			for (j = i - inc; j >= 0 && arr[j] > tmp; j -= inc)
				arr[j+inc] = arr[j];
			arr[j+inc] = tmp;
		}
	}
}

2.交换排序
基本思想：两两比较待排序记录的关键字，发现两个记录的次序相反时，即进行交换，直到没有反序的记录为止。
2.1 冒泡排序
基本思想是，通过无序区中相邻记录关键字间的比较和位置的交换，使关键字最小的记录如气泡一般逐渐往上“漂浮”直至“水面”。整个算法是从最后面的记录开始，对每两个相邻的关键字进行比较，且使关键字较小的记录换至关键字较大的记录之上，使得经过一趟冒泡排序后，关键字最小的记录到达最上端，接着，再在剩下的记录中找到关键字次小的记录，并把它换在第二个位置上，依次类推，一直到所有记录都有序为止。算法时间复杂度o(n^2)。
// 第一层一般记录执行了多少趟
实现1：

void BubbleSort(int arr[], int n)
{
    int i, j;
 
    for (i = 0; i < n - 1; i++) {
        // 将前面无序区的最大元素不断向后移
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1])
                swap(arr, j, j + 1);
        }
    }
}

实现2：

void BubbleSort(int *arr, int n)
{
    int i, j, tag;
     
    for (i = n - 1; i > 0; i--) {
    	tag = 1;
        for (j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
            }
        }
        if (tag == 1) {
            break;
		}
    }
}

2.2 快速排序
快速排序是由冒泡排序改进而得的，它的基本思想是：在待排序的n个记录中任取一个记录(通常取第一个记录)，把该记录放入适当位置后，数据序列被此记录划分成两部分。所有关键字比该记录关键字小的记录放置在前一部分，所有比它大的记录放置在后一部分，并把该记录排在这两部分的中间(称为该记录归位)，这个过程称作一趟快速排序。算法最好时间复杂度o(nlog2n)。

// 实现1：
int partition1(int arr[], int left, int right)
{
	int pivot = arr[left];
	
	while (left < right) {
		while (left < right && arr[right] >= pivot)
			--right;
		while (left < right && arr[left] <= pivot)
			++left;
		if (left < right)
		swap(arr, left, right);
	}
	arr[left] = pivot; 

	return left;
}

// 实现2：
static int partition2(int arr[], int left, int right)
{
	int pivot = arr[left];
	
	while (left < right) {
		// 从后往前在后半部分中寻找第一个小于枢纽元素的元素
		while (left < right && arr[right] > pivot)
			--right;
        arr[left] = arr[right];
		while (left < right && arr[left] < pivot)
			++left;
		arr[right] = arr[left];
	}
	// 返回枢纽元素所在的位置 
	arr[left] = pivot; 

	return left;
}

void quickSort(int arr[], int left, int right)
{
	int n;

	if (left < right) {
		n = partition(arr, left, right);
		QuickSort(arr, left, n - 1);
		QuickSort(arr, n + 1, right);
	}
}

// 实现3：
void QuickSort(int arr[], int left, int right)
{
	int i, last;

	if (left >= right) // exit recursion
		return ;
	swap(arr, left, (left + right) / 2); // select pivot
	last = left;
	for (i = left + 1; i <= right; i++) {
		if (arr[i] < arr[left])  
			swap(arr, ++last, i);    // 当i, last相等时，自身交换
	}
	swap(arr, left, last);           // 返回枢纽元素所在的位置 
	QuickSort(arr, left, last - 1);  // recursion . recur
	QuickSort(arr, last + 1, right);
}

3.选择排序
基本思想：每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子表的最后，直到全部记录排序完毕。由于选择排序方法每一趟总是从无序区中选出全局最小(或最大)的关键字，所以适合于从大量的记录中选择一部分排序记录，如从10000个记录中选择出关键字前10位的记录，就适合使用选择排序法。
3.1 直接选择排序
直接选择排序法:第i趟排序开始时，当前有序区和无序区分别为R[0..i-1]和R[i..n-1](0≤ i≤n-1),该趟排序则是从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第一个记录R[i]交换,使得R[0..i]和R[i+1..n-1]分别为新的有序区和新的无序区
实现：

void SelectSort(int arr[], int n)
{
	int i, j, min;

	for (i = 0; i < n - 1; i++) {
		min = i;
		for (j = i + 1; j < n; j++) {
			if (arr[j] < arr[min])
				min = j;
		}
		if (min != i)
			swap(arr, min, i);
	}
}

3.2 堆排序
堆排序算法的过程如下：1）得到当前序列的最小（大）的元素 2）把这个元素和最后一个元素进行交换，这样当前的最小（大）的元素就放在了序列的最后，而原先的最后一个元素放到了序列的最前面 3）交换可能会破坏堆序列的性质（注意此时的序列是除去已经放在最后面的元素），因此需要对序列进行调整，使之满足于上面堆的性质。重复上面的过程，直到序列调整完毕为止。
实现：

void HeapAdjust(int arr[], int i, int len)
{
	int child, tmp;
    // 使用下滤（percolate down）的策略
	for (tmp = arr[i]; 2 * i + 1 < len; i = child) {
		child = 2 * i + 1;  // left child
		// 得到子结点中较大的结点，建立大顶堆
		if (child != len - 1 && arr[child + 1] > arr[child])
			++child;        // right child
		// 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点  
		if (tmp < arr[child])
			arr[i] = arr[child];
		else
			break;
	}
	// 最后把需要调整的元素值放到合适的位置  
	arr[i] = tmp;
}

void HeapSort(int arr[], int len)
{
	int i, j;
	// 建立大顶堆
	for (i = len / 2 - 1; i >= 0; --i)  
		HeapAdjust(arr, i, len);
	// 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素 
	for (j = len - 1; j > 0; --j) {
		swap(arr, 0, j);
		HeapAdjust(arr, 0, j);
	}
}