2. 選擇排序
3. 插入排序
4. 歸併排序
5. 基數排序
最快平均
最慢空間複雜度
穩定性複雜性
o(n)
o(n2)
o(n2)
o(1)
穩定簡單
氣泡排序是一種用時間換空間的排序方法
最壞情況是把順序的排列變成逆序，或者把逆序的數列變成順序，最差時間複雜度o(n^2)只是表示其操作次數的數量級。
最好的情況是資料本來就有序，複雜度為o(n)
#include #include #include #include#define num 10000
using t = int;
void print(t arr, int nnum);
void swap(t *a, t *b);
long getsystemtime();
void bubblesort(t arr, int nnum)
}int main()
; long t_start = 0, t_end = 0;
srand((unsigned int)time(null));
for (int i = 0; i < num; ++i)
//print(arr,num);
t_start = getsystemtime();
bubblesort(arr,num);
t_end = getsystemtime();
//print(arr, num);
std::cout << "time:" << t_end - t_start << std::endl;
return 0;
}void swap(t *a, t *b)
void print(t arr, int nnum)
std::cout << "\b\n" << std::endl;
}long getsystemtime()
最快平均
最慢空間複雜度
穩定性複雜性
o(n*log2n)
o(n*log2n)
o(n2)
o(log2n)-o(n)
不穩定複雜
快速排序以空間換時間，但卻是效率高不穩定的排序演算法。元素越多優勢越明顯。
劃分之後一邊是乙個，一邊是n-1個，這種極端情況的時間複雜度就是o(n^2)
最好的情況是每次都能均勻的劃分序列，o(n*log2n)
void quicksort(t arr, int start, int end)
// search >base from left
while (left < right && arr[left] < base) ++left;
if (left < right)
}arr[left] = base;
quicksort(arr, 0, left - 1);
quicksort(arr, left + 1, end);
}}
平均最慢
空間複雜度
穩定性複雜性
o(n)
o(n2)
o(n2)
o(1)
不穩定簡單
比冒泡快，因為交換少。
void selectsort(t arr, int nnum)
} if (min != i)
}}
堆是一種完全二叉樹：
步驟：將序列構建稱為大頂堆；
取出根節點，與末尾元素交換；
對交換後的n-1個序列元素進行調整，使其滿足大頂堆的性質，然後交換；
總之就是建堆和交換，不斷重複。
#include #include using namespace std;
using t = int;
void print(t arr, int nnum)
; short x = 40, y = 0;
int rownum = 1;
pos.x = x;
pos.y = y;
setconsolecursorposition(hout, pos);
printf("%2d",arr[0]);
for (int i = 1; i < nnum; i += rownum) }
system("pause");
system("cls");
}void heapadjust(t arr, int index, int nlen)
if (rchild < nlen && arr[rchild] > arr[max])
if (max != index) }
void heapsort(t arr, int nlen)
// 2. swap
for (int i = nlen - 1; i >= 0; --i) }
int main() ;
print(arr, _countof(arr));
heapsort(arr, _countof(arr));
print(arr, _countof(arr));
system("pause");
return 0;
}
兩種情況下效率高: 最快
平均最慢
空間複雜度
穩定性複雜性
o(n)
o(n2)
o(n2)
o(1)
穩定簡單
void insertsort(t arr, int nnum)
arr[j + 1] = min;
} }}
平均最慢
空間複雜度
穩定性複雜性
o(n)
o(n^(1.3))
o(n2)
o(1)
不穩定複雜
實質上是一種分組插入方法，又稱縮小增量排序，是插入排序的高效版本。
數列有n個元素，取乙個小於n的整數gap，將待排序元素分成若干個組子串行，所有距離為gap的倍數的記錄放在同乙個組中；然後，對各組內的元素進行直接插入排序。 這一趟排序完成之後，每乙個組的元素都是有序的。然後減小gap的值，並重複執行上述的分組和排序。重複這樣的操作，當gap=1時，整個數列就是有序的。
步長遞減：gap = gap / 3 + 1;
void shellsort(t arr, int nnum)
arr[k + increasement] = min;}}
} } while (increasement > 1);
}
數量達到一定級別後，必須利用多執行緒，計算後合併。
void merge(t arr, int start, int end, int mid)
; while (i_start <= i_end && j_start <= j_end)
else
}while (i_start <= i_end)
while (j_start <= j_end)
for (int i = 0; i < nlen; ++i) }
// inte***ce
void mergesort(t arr, int start, int end)
空間複雜度：o(n+k)
k為常數
穩定，複雜（**還沒看懂）。
演算法：按位（個位、十位、百位。。。）排序，
基數排序不是比較排序，而是通過分配和收集的過程來實現排序初始化10個桶(固定的)，桶下標為0-9
根據待排序數字的對應位的數字，把這個數字對應的item放到對應的桶中
兩種排序方式：lsd和msd，最小位優先(從右邊開始)和最大位優先(從左邊開始)
#include int maxbit(int arr, int nlen)
} return max;
}void radixsort(int arr, int nlen) //基數排序
for (j = 1; j < 10; ++j)
count[j] += count[j - 1]; //將tmp中的位置依次分配給每個桶
for (j = nlen - 1; j >= 0; --j) //將所有桶中記錄依次收集到tmp中
for (j = 0; j < nlen; ++j) //將臨時陣列的內容複製到arr中
arr[j] = tmp[j];
radix = radix * 10;
} delete tmp;
}int main()
; radixsort(arr,10);
for (int i = 0; i < 10; ++i)
return 0;
}
8大排序總結
include includeusing namespace std void select sort vector a 選擇排序 非穩定 void bubble sort vector a 氣泡排序 void insert sort vector a 插入排序 有序最快 void shell so...
8大排序演算法
一 各個排序演算法的過程 1 直插入排序 乙個個的進行插入，直到有序序列。穩定的。要點 設立哨兵，作為臨時儲存和判斷陣列邊界之用。具體實現 如下 時間複雜度 o n 2 void insertsort int a,int n 3 選擇排序 按大小順序一次選出，進行公升降排列。在要排序的一組數中，選出...
8大排序3大查詢（二）
6 快速排序 1 基本思想 選擇乙個基準元素 通常選擇第乙個元素或者最後乙個元素 通過一趟掃瞄，將待排序列分成兩部分 一部分比基準元素小 一部分大於等於基準元素 此時基準元素在其排好序後的正確位置 然後再用同樣的方法遞迴地排序劃分的兩部分。2 例項 上圖中將待排序列分成兩部分,一部分比基準元素小,一...