排序——八大排序小结

**

一、排序

**
排序：排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
排序的稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排
序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

二、算法实现

1.插入排序：

基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
算法实现：

 void insertSort(int a[], int size) {
	for (int i = 0; i < size; i++) {
		int k = a[i];
		int j;
		for (j = i - 1; j >= 0 && a[j] < k; j--) {
			a[j + 1] = a[j];
		}

		a[j + 1] = k;
	}
}

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定
应用场景：文件初始状态基本有序时

2.希尔排序

基本思想：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
算法实现：

void shellSort(int a[], int size) {
	int gap = size;

	while (1) {
		gap = gap / 3 + 1;

		for (int i = 0; i < size; i++) {
			int k = a[i];
			int j;
			for (j = i - gap; j >= 0 && a[j] < k; j -= gap) {
				a[j + gap] = a[j];
			}
			a[j + gap] = k;
		}

		if (gap == 1) {
			break;
		}
	}
}

时间复杂度：O(N^1.3~N2)
稳定性：不稳定

3.选择排序

基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
算法实现：

 void selectSort(int a[], int size) {
	int left = 0;
	int right = size - 1;
	while (left < right) {
		int min = left;
		int max = left;
		for (int i = left + 1; i <= right; i++) {
			if (a[i] < a[min]) {
				min = i;
			}
			if (a[i] > a[max]) {
				max = i;
			}
		}
		swap(&a[min], &a[left]);
		if (max == left) {
			max = min;
		}
		swap(a + max, a + right);
		left++;
		right--;
	}
}

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定

4.堆排序

基本思想：通过堆来进行选择数据。排升序要建大堆，排降序建小堆。
算法实现：

   void heapify(int a[], int size, int index) {
	int left = 2 * index + 1;
	int right = 2 * index + 2;
	if (left >= size) {
		return;
	}

	int max = left;
	if (right < size && a[right] > a[left]) {
		max = right;
	}

	if (a[index] >= a[max]) {
		return;
	}

	swap(a + index, a + max);
	heapify(a, size, max);
}

void createHeap(int a[], int size) {
	for (int i = (size - 2) / 2; i >= 0; i--) {
		heapify(a, size, i);
	}
}

void heapSort(int a[], int size) {
	createHeap(a, size);

	for (int i = 0; i < size; i++) {
		// 无序 [0, size - i)
		swap(a, a + size - i - 1);
		// 无序 [0, size - i - 1)
		heapify(a, size - i - 1, 0);
	}
}

时间复杂度：O(N*log N)
空间复杂度：O(1)
稳定性：不稳定

5.冒泡排序

基本思想:根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
算法实现：

    void bubbleSort(int a[], int size) {
	for (int i = 0; i < size; i++) {
		int sorted = 1;
		for (int j = 0; j < size - i - 1; j++) {
			if (a[j] > a[j + 1]) {
				swap(a + j, a + j + 1);
				sorted = 0;
			}
		}

		if (sorted == 1) {
			break;
		}
	}
}

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

6.快速排序

基本思想：任取待排序队列中的某元素作为基准值，按照该排序码将待排序集合分割成两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：

1. hoare版本
2. 挖坑法
3. 前后指针版本

算法实现：

 //hoare版本
      int partition1(int a[], int left, int right) {
	int begin = left;
	int end = right;
	int pivot = a[right];
	while (begin < end) {
		while (begin < end && a[begin] <= pivot) {
			begin++;
		}

		while (begin < end && a[end] >= pivot) {
			end--;
		}

		swap(a + begin, a + end);
		}
		swap(a + begin, a + right);
	return begin;
}
//挖坑法
int partition2(int a[], int left, int right) {
	int begin = left;
	int end = right;
	int pivot = a[right];
	while (begin < end) {
		while (begin < end && a[begin] <= pivot) {
			begin++;
		}

		a[end] = a[begin];

		while (begin < end && a[end] >= pivot) {
			end--;
		}

		a[begin] = a[end];
	}

	a[begin] = pivot;
	return begin;
}
//前后指针方法
int partition3(int a[], int left, int right) {
	int div = left;
	int i = left;
	for (; i < right; i++) {
		if (a[i] < a[right]) {
			swap(a + i, a + div);
			div++;
		}
	}

	swap(a + div, a + right);

	return div;
}

时间复杂度：O(N*log N)
空间复杂度：O(1)
稳定性：不稳定

7.归并排序

基本思想：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
算法实现：

 void mergeSortInternal(int a[], int low, int high) {
	if (low >= high - 1) {
		return;
	}

	int mid = (low + high) / 2;
	mergeSortInternal(a, low, mid);
	mergeSortInternal(a, mid, high);
	merge(a, low, mid, high);
}

void mergeSort(int a[], int size) {

}

void test() {
	int a[] = { 9, 3, 5, 4, 9, 2, 7, 9, 3, 6, 8, 8 };
	int size = sizeof(a) / sizeof(int);

	quickSort(a, size);

	printArray(a, size);
}

时间复杂度：O(N*logN)
空间复杂度：O(N)
稳定性：稳定

8.计数排序

基本思想：对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。
算法实现：

   void count_sort(int *arr, int *sorted_arr, int n)  
{  
    int *count_arr = (int *)malloc(sizeof(int) * 100);  
    int i;   
    for(i = 0; i<100; i++)  
        count_arr[i] = 0;  
    for(i = 0;i<n;i++)  
        count_arr[arr[i]]++;   
    for(i = 1; i<100; i++)  
        count_arr[i] += count_arr[i-1];   
    for(i = n; i>0; i--)  
    {  
        sorted_arr[count_arr[arr[i-1]]-1] = arr[i-1];  
        count_arr[arr[i-1]]--;    
    }   
    free(count_arr);  
}  

时间复杂度：O(MAX(N,范围))
空间复杂度：O(范围)
稳定性：稳定