總結各類排序算法【Java實現】
1、插入類排序java
1.直接插入排序數組
思想：將第i個插入到前i-1箇中的適當位置dom
時間複雜度：T(n) = O(n²)。spa
空間複雜度：S(n) = O(1)。指針
穩定性：穩定排序。code
若是遇見一個和插入元素相等的，那麼插入元素把想插入的元素放在相等元素的後面。orm
因此，相等元素的先後順序沒有改變，從原無序序列出去的順序就是排好序後的順序，因此插入排序是穩定blog
哨兵有兩個做用： ① 進人查找(插入位置)循環以前，它保存了R[i]的副本，使不致於因記錄後移而丟失R[i]的內容； ② 它的主要做用是：在查找循環中"監視"下標變量j是否越界。一旦越界(即j=0)，由於R[0].能夠和本身比較，循環斷定條件不成立使得查找循環結束，從而避免了在該循環內的每一次均要檢測j是否越界(即省略了循環斷定條件"j>=1")
public void insertSort(int[] array){
for(int i=1;i<array.length;i++)//第0位獨自做爲有序數列，從第1位開始向後遍歷
{
if(array[i]<array[i-1])//0~i-1位爲有序，若第i位小於i-1位，繼續尋位並插入，不然認爲0~i位也是有序的，忽略這次循環，至關於continue
{
int temp=array[i];//保存第i位的值
int k = i - 1;
for(int j=k;j>=0 && temp<array[j];j--)//從第i-1位向前遍歷並移位，直至找到小於第i位值中止
{
array[j+1]=array[j];
k--;
}
array[k+1]=temp;//插入第i位的值
}
}
}
2.折半插入排序排序
思想：將數據插入到已經排好序的序列中，經過不斷與中間點比較大小來肯定位置遞歸
時間複雜度：比較時的時間減爲O(n㏒n)，可是移動元素的時間耗費未變，因此老是得時間複雜度仍是O(n²)。
空間複雜度：S(n) = O(1)。
穩定性：穩定排序。
3.希爾排序
思想：又稱縮小增量排序法。把待排序序列分紅若干較小的子序列，而後逐個使用直接插入排序法排序，最後再對一個較爲有序的序列進行一次排序，主要是爲了減小移動的次數，提升效率。原理應該就是從無序到漸漸有序，要比直接從無序到有序移動的次數會少一些。
時間複雜度：O(n的1.5次方)
空間複雜度：O(1)
穩定性：不穩定排序。{2,4,1,2}，2和1一組4和2一組，進行希爾排序，第一個2和最後一個2會發生位置上的變化。
public static void main(String [] args)
{
int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
System.out.println("排序以前：");
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
//希爾排序
int d=a.length;
while(true)
{
d=d/2;
for(int x=0;x<d;x++)
{
for(int i=x+d;i<a.length;i=i+d)
{
int temp=a[i];
int j;
for(j=i-d;j>=0&&a[j]>temp;j=j-d)
{
a[j+d]=a[j];
}
a[j+d]=temp;
}
}
if(d==1)
{
break;
}
}
System.out.println();
System.out.println("排序以後：");
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
}
2、交換類排序
1.冒泡排序
時間複雜度：T(n) = O(n²)。
空間複雜度：S(n) = O(1)。
穩定性：穩定排序。
public class BubbleSort
{
public void sort(int[] a)
{
int temp = 0;
for (int i = a.length - 1; i > 0; --i)
{
for (int j = 0; j < i; ++j)
{
if (a[j + 1] < a[j])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
}
2.快速排序
思想：對冒泡排序的改進，經過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的全部數據都比另一部分的全部數據都要小，而後再按此方法對這兩部分數據分別進行快速排序，整個排序過程能夠遞歸進行，以此達到整個數據變成有序序列。
時間複雜度：平均T(n) = O(n㏒n)，最壞O(n²)。
空間複雜度：S(n) = O(㏒n)。
穩定性：不穩定排序
首先把數組的第一個數拿出來作爲一個key，在先後分別設置一個i,j作爲標識，而後拿這個key對這個數組從後面往前遍歷，及j--，直到找到第一個小於這個key的那個數，而後交換這兩個值，交換完成後，咱們拿着這個key要從i日後遍歷了，及i++;一直循環到i=j結束，當這裏結束後，咱們會發現大於這個key的值都會跑到這個key的後面
3、選擇類排序
1.簡單選擇排序
時間複雜度：T(n) = O(n²)。
空間複雜度：S(n) = O(1)。
穩定性：不穩定排序
思路：
1）從待排序的序列中，找到關鍵字最小的元素
2）若是最小的元素不在第一位，就和第一個元素互換位置
3）從餘下的N-1個元素中，找到關鍵字最小的元素，重複 1）、2）步
public class SelectionSort {
public void selectionSort(int[] list) {
// 須要遍歷得到最小值的次數
// 要注意一點，當要排序 N 個數，已經通過 N-1 次遍歷後，已是有序數列
for (int i = 0; i < list.length - 1; i++) {
int temp = 0;
int index = i; // 用來保存最小值得索引
// 尋找第i個小的數值
for (int j = i + 1; j < list.length; j++) {
if (list[index] > list[j]) {
index = j;
}
}
// 將找到的第i個小的數值放在第i個位置上
temp = list[index];
list[index] = list[i];
list[i] = temp;
System.out.format("第 %d 趟:\t", i + 1);
printAll(list);
}
}
// 打印完整序列
public void printAll(int[] list) {
for (int value : list) {
System.out.print(value + "\t");
}
System.out.println();
}
public static void main(String[] args) {
// 初始化一個隨機序列
final int MAX_SIZE = 10;
int[] array = new int[MAX_SIZE];
Random random = new Random();
for (int i = 0; i < MAX_SIZE; i++) {
array[i] = random.nextInt(MAX_SIZE);
}
// 調用排序方法
SelectionSort selection = new SelectionSort();
System.out.print("排序前:\t");
selection.printAll(array);
selection.selectionSort(array);
System.out.print("排序後:\t");
selection.printAll(array);
}
}
2.樹形選擇排序
思想：爲了減小比較次數，兩兩進行比較，得出的較小的值再兩兩比較，直至得出最小的輸出，而後在原來位置上置爲∞，再進行比較。直至全部都輸出。
時間複雜度：T(n) = O(n㏒n)。
空間複雜度：較簡單選擇排序，增長了n-1個額外的存儲空間存放中間比較結果，就是樹形結構的全部根節點。S(n) = O(n)。
穩定性：穩定排序。
3.堆排序
【待】
四.、歸併排序
歸併排序：
思想：假設初始序列有n個記錄，首先將這n個記錄當作n個有序的子序列，每一個子序列的長度爲1，而後兩兩歸併，獲得n/2向上取整個長度爲2（n爲奇數時，最後一個序列的長度爲1）的有序子序列
在此基礎上，在對長度爲2的有序子序列進行兩兩歸併，獲得若干個長度爲4的有序子序列
· 如此重複，直至獲得一個長度爲n的有序序列爲止。
時間複雜度：T(n) = O(n㏒n)
空間複雜度：S(n) = O(n)
穩定性：穩定排序
public class MergeSort {
public static void merge(int[] a, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;// 左指針
int j = mid + 1;// 右指針
int k = 0;
// 把較小的數先移到新數組中
while (i <= mid && j <= high) {
if (a[i] < a[j]) {
temp[k++] = a[i++];
} else {
temp[k++] = a[j++];
}
}
// 把左邊剩餘的數移入數組
while (i <= mid) {
temp[k++] = a[i++];
}
// 把右邊邊剩餘的數移入數組
while (j <= high) {
temp[k++] = a[j++];
}
// 把新數組中的數覆蓋nums數組
for (int k2 = 0; k2 < temp.length; k2++) {
a[k2 + low] = temp[k2];
}
}
public static void mergeSort(int[] a, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
// 左邊
mergeSort(a, low, mid);
// 右邊
mergeSort(a, mid + 1, high);
// 左右歸併
merge(a, low, mid, high);
System.out.println(Arrays.toString(a));
}
}
public static void main(String[] args) {
int a[] = { 51, 46, 20, 18, 65, 97, 82, 30, 77, 50 };
mergeSort(a, 0, a.length - 1);
System.out.println("排序結果：" + Arrays.toString(a));
}
}
5、分配類排序
1.多關鍵字排序：
【待】
2.鏈式基數排序：
思想：先分配，再收集，就是先按照一個次關鍵字收集一下，而後進行收集（第一個排序），而後再換一個關鍵字把新序列分配一下，而後再收集起來，又完成一次排序，這樣全部關鍵字分配收集完後，就完成了排序。
時間複雜度：T(n) = O( d ( n + rd ) )
空間複雜度：S(n) = O(rd)
穩定性：穩定排序
- 1. java各類排序算法及實現
- 2. 各類排序算法總結
- 3. 排序算法總結 java實現
- 4. 排序算法總結(Java實現)
- 5. Java基礎學習總結（28）——Java對各類排序算法的實現
- 6. Java實現各類排序
- 7. python實現各類排序算法
- 8. PHP實現各類排序算法
- 9. python 實現各類排序算法
- 10. 各類排序算法的js實現
- 更多相關文章...
- • ADO 排序 - ADO 教程
- • PHP 數組排序 - PHP教程
- • 算法總結-歸併排序
- • 算法總結-回溯法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. java各類排序算法及實現
- 2. 各類排序算法總結
- 3. 排序算法總結 java實現
- 4. 排序算法總結(Java實現)
- 5. Java基礎學習總結（28）——Java對各類排序算法的實現
- 6. Java實現各類排序
- 7. python實現各類排序算法
- 8. PHP實現各類排序算法
- 9. python 實現各類排序算法
- 10. 各類排序算法的js實現