排序總結

排序總結

原創

csdnJACK_

2020-02-22 02:43

冒泡排序：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)。輸入有影響。（快速排序針對輸入爲隨機的數據性能比較好）。

外部排序：待補充。

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

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
針對所有的元素重複以上的步驟，除了最後一個。
持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

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在數組上實現。具體算法描述如下：

從第一個元素開始，該元素可以認爲已經被排序
取出下一個元素，在已經排序的元素序列中從後向前掃描
如果該元素（已排序）大於新元素，將該元素移到下一位置
重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
將新元素插入到該位置後
重複步驟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; 
	}
}

選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

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;
		}
}

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

在堆的數據結構中，堆中的最大值總是位於根節點。堆中定義以下幾種操作：

最大堆調整（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/45285701

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