java 常用排序算法

數據結構有必要複習下了


以下是我寫的一些算法的實現，請多指教：

import java.util.Arrays;

public class 常用算法實現 {
    /**
     * 數據交換的方法
     * @param v
     * @param i
     * @param j
     */
    public static void swap(int[] v, int i, int j) {
        int temp = v[i];
        v[i] = v[j];
        v[j] = temp;
    }
   
   
    /**
     * 冒泡排序
     *
     * 使用場景：對已經經過初步排序的數據使用比較好
     *
     * 原理：掃描數據交換數據位置 對當前還未排好序的範圍內的全部結點， 自上而下對相鄰的兩個結點依次進行比較和調整，
     * 讓鍵值大的結點往下沉，鍵值小的結點往上冒。 即，每當兩相鄰比較後發現它們的排列順序與排序要求相反時，就將它們互換。
     *
     * 時間複雜度：n的平方 空間複雜度：1
     *
     * 在冒泡排序中的核心部分是 for(i=0;i<n-1;i++) for(j=0;j<n-1-i;j++) if(a[j+1]<a[j])
     * swap(a[j],a[j+1]);
     */
    public static void bubbleUp(int list[]) {
        System.out.println("初始字符串:" + Arrays.toString(list));
        for (int i = 0; i < list.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < list.length - i - 1; j++) {
                if (list[j] < list[j + 1]) {
                    swap(list,j,j+1);
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
            System.out.println("第" + (i + 1) + "次排列:" + Arrays.toString(list));
        }
        System.out.println("最終排列結果:" + Arrays.toString(list));
    }

    /**
     * 選擇排序算法
     *
     * 試用場景：數據量比較少的情況下可以使用
     *
     * 原理：這是一個比較簡單的算法，他的原理是，首先找到最小的數據 和第一個數據交換，然後再 找到次小的數據和第二個交換，以此類推.直到將數據排列好爲止
     *
     * 時間複雜度： 2的n次方
     *
     * 空間複雜度:1
     *
     * @param args
     */
    public static void selectSort(int list[]) {
        System.out.println("初始字符串:" + Arrays.toString(list));
        for (int i = 0; i < list.length - 1; i++) {
            int min = list[i];
            for (int j = i + 1; j < list.length; j++) {
                if (min > list[j]) {
                    min = list[j];
                    swap(list,j,i);

                }
            }
            System.out.println("第" + (i + 1) + "次排列:" + Arrays.toString(list));
        }
        System.out.println("最終排列結果:" + Arrays.toString(list));
    }

    /**
     * 插入排序法 試用場景：數據量比較少的情況下 原理：是一種簡單直觀的排序算法; 從後到前在已排序數據中找到合適的位置插入進去
     * 初始可認爲第一個數據已排序
     *
     * 時間複雜度：n的平方 空間複雜度: n
     *
     * @param args
     */
    public static void insertSort(int list[]) {
        System.out.println("初始字符串:" + Arrays.toString(list));
        // 注意：我們可認爲第一個數據已排序，所以i是從1開始的
        for (int i = 1; i < list.length; i++) {
            int temp = list[i];
            int j = i;
            while (j > 0 && list[j] < list[j - 1]) {
                list[j] = list[j - 1];
                j--;
            }
            list[j] = temp;
            System.out.println("第" + i + "次排列:" + Arrays.toString(list));
        }
        System.out.println("最終排列結果:" + Arrays.toString(list));
    }

    /**
     * 快速排序算法
     *
     * 試用場景：數據量比較大的地方,如果有大量重複數據就比較麻煩
     *
     * 原理：首先檢查待排序數組，如果<2個 直接推出程序，如果有超過 兩個的數據，就選擇一個分割點，將數據分成兩個部分，小於分割點的分
     * 到一組，大於分割點的放到一組，然後對兩組數據進行排序
     *
     * 時間複雜度：快速排序 O(n log n) 空間複雜度：1 splitIndex 劃分數據的界限 items 最後字符的位置
     *
     * @param args
     */
    public static void quickSort(int list[], int startIndex, int items) {
        int j, last;
        /* 若數組包含的元素個數少於兩個 */
        if (startIndex >= items)
        return;
        swap(list, startIndex, (startIndex + items) / 2); /* 將劃分子集的元素移動到V[0] */
        last = startIndex; /* 用last記錄中比關鍵字小間的最右位置 */
        for (j = startIndex + 1; j <= items; j++) /* 劃分子集 */
        {
            if (list[j] < list[startIndex]) {
                swap(list, ++last, j);
            }
        }
        quickSort(list, startIndex, items - 1);
        quickSort(list, startIndex + 1, items);
    }

    public static void main(String args[]) {
        int list[] = { 800, 20, 70, 90, 50, 500, 400, 100, 850, 999, 1000, 0,-400 };
         bubbleUp(list);
         selectSort(list);
         insertSort(list);

    }
}