排序总结

标签：排序总结

冒泡排序：O（N^2）。输入对结果没有影响。

插入排序：最差O（N^2），最优O(N)，平均O（N^2）。输入有影响，例如已排好序，则为O(N)。

选择排序：最差，最优，平均都是O(N^2)。输入对结果没有影响。

希尔排序：最差为o（Nlg^2N)。缩小增量排序。关键是如何选取这个增量序列。（一般，但不够好的选择是 k/2）。

堆排序：最差，最优，平均都是O(NlgN)。堆排序是所有下界排序为O(NlgN)中唯一一个稳定的排序。

归并排序：O(NlgN)。归并排序，需要一个额外的数组空间，因此是非原址排序。

快速排序：最差O(N^2)，最优和平均O(NlgN)。输入有影响。（快速排序针对输入为随机的数据性能比较好）。

外部排序：待补充。

冒泡排序算法的运作如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

void bubble_sort(int arr[], int len) <span style="color: rgb(37, 37, 37); font-family: sans-serif; font-size: 14px; line-height: 22.3999996185303px;">冒泡排序</span>
{
	int i, j, temp;
	for (i = 0; i < len - 1; i++)
		for (j = 0; j < len - 1 - i; j++)
			if (arr[j] > arr[j + 1]) {
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
}

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

void insertion_sort(int array[], int first, int last)插入排序
{
	int i, j, temp;
	for (i = first + 1; i <= last; i++){
		temp = array[i]; 
		for(j = i - 1; j >= first && array[j] > temp;j--)

			array[j + 1] = array[j];
		array[j+1] = temp; 
	}
}

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

void shell_sort(int arr[], int len) 
{
	int gap, i, j;
	int temp;
	for (gap = len >> 1; gap > 0; gap >>= 1)
		for (i = gap; i < len; i++) {
			temp = arr[i];
			for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
				arr[j + gap] = arr[j];
			arr[j + gap] = temp;
		}
}

在堆的数据结构中，堆中的最大值总是位于根节点。堆中定义以下几种操作：

• 最大堆调整（Max_Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
• 创建最大堆（Build_Max_Heap）：将堆所有数据重新排序
• 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

void Max_Heapify(int A[], int i, int heap_size)
{
    int l = left(i);
    int r = right(i);
    int largest;
    int temp;
    if(l < heap_size && A[l] > A[i])
    {
        largest = l;
    }
    else
    {
        largest = i;
    }
    if(r < heap_size && A[r] > A[largest])
    {
        largest = r;
    }
    if(largest != i)
    {
        temp = A[i];
        A[i] = A[largest];
        A[largest] = temp;
        Max_Heapify(A, largest, heap_size);
    }
}
void Build_Max_Heap(int A[],int heap_size)
{
    for(int i = (heap_size-2)/2; i >= 0; i--)
    {
        Max_Heapify(A, i, heap_size);
    }
}
void HeapSort(int A[], int heap_size)
{
    Build_Max_Heap(A, heap_size);
    int temp;
    for(int i = heap_size - 1; i >= 0; i--)
    {
        temp = A[0];
        A[0] = A[i];
        A[i] = temp;
        Max_Heapify(A, 0, i);
    }
    print(A, heap_size);
}

快速排序：http://blog.csdn.net/csdnjack_/article/details/45459283

排序总结

标签：排序总结

原文地址：http://blog.csdn.net/csdnjack_/article/details/48090799