1.氣泡排序:

思想:以小到大排序為例,對無序的資料兩兩進行比較,大的放在右面,小的放在左面.

(1,2),(1,3)...(2,3),(2,4)...(n-1,n-1),(n-1,n)

時間複雜度: O(n) ~ O(n2)O(n2~

Java程式碼實現:

public class MaopaoSort {

public static void main(String[] args) {
int arr[] = {43,32,12,64,14,-1,37};
int temp;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
if(arr[i]<arr[j]){
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

}

                //遍歷排序後的陣列

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}

}

2.選擇排序:

思想: 以從小到大為例:從無序陣列取第一個元素,然後與其他元素進行比較,若找到比他小的,就進行交換,遍歷完之後就確定了第一個元素,然後再取第二個元素,也是進行一組遍歷,找到第二個最小數.遍歷完之後就確定了第一個元素,然後再取第二個元素,也是進行一組遍歷,找到第二個最小數.

時間複雜度:O(n2)

Java程式碼實現:

public class selectSort {

//選擇排序
public static void main(String[] args) {
int arr[] = {43,32,12,64,14,-1,37};
int temp,min;
for (int i = 0; i < arr.length; i++) {
min = arr[i];
//遍歷一輪,找到最小的,放到第一個位置
for (int j = 0; j < arr.length; j++) {
if(arr[j]>min){
temp = min;
min = arr[j];
arr[j] = temp;
}
}
arr[i] = min;

}

                //遍歷排序後的陣列

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}


}

3.插入排序:

思想:以從小到大為例:以第一個元素為基準,第二個元素與第一個進行比較,如果二比一小,則一二位置互換.第三個元素與前面一二進行比較,如果比二小,就二三互換,互換後三再與一比較,比一小就一三互換.交換完後三就確定好了,繼續判斷四,以此類推...

時間複雜度:O(n2)

Java程式碼實現:

public class directSelectSort {

public static void main(String[] args) {
int src[] = { 43, 32, 12, 64, 14, -1, 37 };
int len = src.length;
// 從第二個元素開始比
for (int i = 1; i < len; i++) {
int j;
int temp = src[i];
// 從後往前逐一判斷比前面是否有比它小的元素,有就交換位置
for (j = i; j > 0; j--) {
if (src[j - 1] > temp) {
src[j] = src[j - 1];


} else// 如果當前的數，不小前面的數，那就說明不小於前面所有的數，
break;// 因為前面已經是排好了序的，所以直接退出當前一輪的比較
}
src[j] = temp;
for (int k = 0; k < src.length; k++) {
System.out.println(src[k]);
}
}
for (int k = 0; k < src.length; k++) {
System.out.println(src[k]);
}
}

}

4.快速排序(特點:速度快,省空間):

原理: 以第一個元素作為基準元素,判斷其他元素比它大還是小,大的放到元素右側,小的放到元素左側.確定左側都是比第一個元素小的元素,右側都是比它大的元素.然後遞迴判斷左側和右側的元素們,用同樣的方法進行分割,直到分割到一個元素,就將全部元素排成有序的序列了.

時間複雜度: O(nlog2n) ~ O(n2)  ~~O(n2)O(nlog2n

Java程式碼實現:

public class QuickSort {

public static void quickSort(int[] arr, int low, int high) {
int i, j, num, temp;
if (low > high) {
return;
}
i = low;
j = high;
// num就是基準位,取得第一個元素
num = arr[low];
// 最外層迴圈限定下標的位置,當左右比較到中點時停止
//比較一遍會把第一個數的左右排好,左邊都比它小,右邊都比它大
while (i < j) {
//第一個元素從右側找一個比它大的.找到退出
while (num <= arr[j] && i < j) {
j--;
}
//第一個元素從左側找一個比它小的,找到退出,
while (num >= arr[i] && i < j) {
i++;
}
// 如果滿足條件則交換(再次確保左右比較時沒有過界)
if (i < j) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
// 最後將基準為與i和j相等位置的數字交換
arr[low] = arr[i];
arr[i] = num;
// 遞迴呼叫左半陣列
quickSort(arr, low, j - 1);
// 遞迴呼叫右半陣列
quickSort(arr, j + 1, high);
}

public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        //輸出排序後的陣列
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

5.歸併排序(特點:比較穩定):

思想: 將要排序序列分成多個子序列,然後將子序列兩兩合併.使其有序.其中用到了遞迴的思想.通過遞迴層層合併.也就是歸併的含義.

時間複雜度:O(nlog2n)

Java程式碼實現:

public class MergeSort
{
    public static int[] sort(int[] nums, int low, int high)
    {
        int mid = (low + high) / 2;
        if (low < high)
        {
            // 左邊
            sort(nums, low, mid);
            // 右邊
            sort(nums, mid + 1, high);
            // 左右歸併
            merge(nums, low, mid, high);
        }
        return nums;
    }
    public static void merge(int[] nums, 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 (nums[i] < nums[j])
            {
                temp[k++] = nums[i++];
            }
            else
            {
                temp[k++] = nums[j++];
            }
        }
        // 把左邊剩餘的數移入陣列
        while (i <= mid)
        {
            temp[k++] = nums[i++];
        }
        // 把右邊邊剩餘的數移入陣列
        while (j <= high)
        {
            temp[k++] = nums[j++];
        }
        // 把新陣列中的數覆蓋nums陣列
        for (int k2 = 0; k2 < temp.length; k2++)
        {
            nums[k2 + low] = temp[k2];
        }
    }
    // 歸併排序的實現
    public static void main(String[] args)
    {
        int[] nums = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };
        MergeSort.sort(nums, 0, nums.length - 1);
        System.out.println(Arrays.toString(nums));
    }

}

6.桶排序(特點:速度最快,佔用空間最大):

思想:我們需要知道該序列中最大的一個數,然後申請一塊空間(桶群),能容下從0到該數的所有數,然後判斷序列中的元素在桶群中那個桶中,以及出現的次數.判斷完成後對桶群進行遍歷.輸出有序的序列.

時間複雜度:O(N+C)

Java程式碼實現:

import java.util.ArrayList;
import java.util.Collections;
public class bucketSort {
public static void bucketSort(int[] arr) {
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for (int i = 0; i < arr.length; i++) {
max = Math.max(max, arr[i]);
min = Math.min(min, arr[i]);
}
// 桶數
int bucketNum = (max - min) / arr.length + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
for (int i = 0; i < bucketNum; i++) {
bucketArr.add(new ArrayList<Integer>());
}
// 將每個元素放入桶
for (int i = 0; i < arr.length; i++) {
int num = (arr[i] - min) / (arr.length);
bucketArr.get(num).add(arr[i]);
}
// 對每個桶進行排序
for (int i = 0; i < bucketArr.size(); i++) {
Collections.sort(bucketArr.get(i));
}
System.out.println(bucketArr.toString());
}
public static void main(String[] args) {
int[] nums = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };
bucketSort(nums);
}

}

覺得對你有幫助或者喜歡的可以點個贊哦~~