Java實現數組快速排序算法

第一種方式：

package com.python;

import java.util.Scanner;

/**************************************************************
 * @author admin
 * 題目描述：快速排序算法，從鍵盤輸入一組整數數組，用快速排序輸出排序后的結果
 * 輸入描述：請輸入要排序的數組：
 * 48 15 24 59 64 79 97 40
 * 程序輸出： 48 15 24 59 64 79 97 40
 * 輸入的數組是：
 * 48 15 24 59 64 79 97 40
 * 排序后的數組是：
 * 15 24 40 48 59 64 79 97
 * 第二種寫法的輸出：
 * 排序后的數組是：
 * 15 24 40 48 59 64 79 97
 * 問題分析：1.從鍵盤輸入一個整數字符串，將字符串轉化為整數數組
 * 解決方法：先將字符串用str.split()轉化為字符串數組，再將字符串數組轉化為整數數組
 * 算法描述：實現快速排序算法的關鍵在於現在數組中選擇一個數字，接下來把數組中的數字分為兩部分，比選擇的數字小的數字移到數組左邊，
 * 比選擇的數字大的數字移到數組的右邊。
 *　1.設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用第一個元素）作為基准點，然后將所有比它小的數都放到它前面，
 * 所有比它大的數都放到它后面，這個過程稱為一趟快速排序，然后采用分治策略，分別以同樣的方式排序前面和后面的數據。
 *　2.一趟快速排序的算法是：
 1）設置兩個變量i、j，排序開始的時候：i=0，j=N-1；
 2）以第一個數組元素作為基准點。
 3）從j開始向前搜索，即由后開始向前搜索(j--)，找到第一個小於A[i](此時基准點)的值A[j]，將值與A[j]交換；
 4）從i開始向后搜索，即由前開始向后搜索(i++)，找到第一個大於A[j]（此時基准點）的A[i]，將A[j]與A[i]交換；
 5）循環執行第3、4步，直到i=j;
 6）到此找到基准點的下標，作為分治下標。
 7)重復1-6步驟遞歸排序前半部分
 8 )重復1-6步驟遞歸排序后半部分
 **************************************************************
 */

public class Sort {

    /**
     * 構造函數，用於輸出用戶輸入的數組
     */
    public Sort(int[] s) {
        System.out.println("構造方法-輸入的數組是：");
        for (int i = 0; i < s.length; i++) {
            System.out.print(s[i] + " ");
        }
        System.out.println();
    }

    /**
     * 排序函數，參數為要排序的數組、數組的起始，數組的末尾
     */
    public void sortFun(int[] arrays, int start, int end) {

        //判斷數組的起始和終止是否相同，相同表示已經都全部排完，返回
        if (start >= end) {
            return;
        }
        //i指向數組的起始位
        int i = start;
        //j指向數組的末位
        int j = end;
        //選取數組的第一位為關鍵字key，基准元素
        int key = arrays[i];
        //設置標志位，用於判斷是i++還是j--;這個很重要
        boolean flag = true;
        //如果i≠j，表示還沒有比較完，即即關鍵字左右兩側還不是最小與最大
        while (i != j) {
            if (flag) {
                //從后向前遍歷，找到小於key的值，
                if (key > arrays[j]) {
                    //找到小於key的值后將arrays[i]與此值交換
                    swap(arrays, i, j);
                    flag = false;
                } else {
                    //如果沒有找到的話j--，向前遍歷
                    j--;
                }
            } else {
                //從前向后遍歷，找到大於key的值
                if (key < arrays[i]) {
                    //將此值與arrays[j]進行交換
                    swap(arrays, i, j);
                    flag = true;
                } else {
                    //如果沒有找到話就將i++,向后遍歷
                    i++;
                }
            }
        }
        //打印每次排序后的數組
        sprint(arrays);
        //遞歸調用，將基准元素的前半段數組再用此方法進行排序，直到所有都排完為止。
        sortFun(arrays, start, j - 1);
        //遞歸調用，將基准元素的后半段數組再用此方法進行排序，直到所有都排完為止。
        sortFun(arrays, i + 1, end);
    }

    /**
     * 交換函數，用於交換數組中的兩個值，easy,
     */
    public void swap(int[] array, int i, int j) {
        int temp;
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    /**
     * sprint()函數用於打印每次排序后的結果，非必須，但可以顯示每次排序情況
     */
    public void sprint(int[] arrays) {
        System.out.println("排序后的數組是：");
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
        System.out.println();
    }

    public static void main(String args[]) {
        //從鍵盤輸入數組
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入要排序的數組：");
        //將鍵盤輸入轉化為字符串
        String str = sc.nextLine();
        //將字符串用“ ”分開轉化為字符串數組
        String[] temp = str.split(" ");
        //定義一個整型數組s
        int[] s = new int[temp.length];
        //將字符串數組強制轉化為整型數組
        for (int i = 0; i < temp.length; i++) {
            //這種方法非常巧妙
            s[i] = Integer.parseInt(temp[i]);
        }
        //創建對象，並傳入數組s
        Sort sort_array = new Sort(s);
        //調用類的方法，用於排序數組
        sort_array.sortFun(s, 0, s.length - 1);
    }
}

第二種方式：

package com.python;

/**
 * @author relax
 * @version 1.0
 * @功能描述：
 * @date 2021/9/15 14:00
 */
public class SortX {


    /**
     * 構造函數，用於輸出用戶輸入的數組
     */
    public SortX(int[] s) {
        System.out.println("輸入的數組是：");
        for (int i = 0; i < s.length; i++) {
            System.out.print(s[i] + " ");
        }
        System.out.println();
    }

    /**
     * 第二種寫法：
     */
    private int getMiddle(int[] sortArray, int low, int high) {
        int key = sortArray[low];
        while (low < high) {
            while (low < high && sortArray[high] >= key) {
                high--;
            }
            sortArray[low] = sortArray[high];
            while (low < high && sortArray[low] <= key) {
                low++;
            }
            sortArray[high] = sortArray[low];
        }
        sortArray[low] = key;
        return low;
    }

    public void quicksort(int[] sortArray, int low, int high) {
        if (low < high) {
            int middle = getMiddle(sortArray, low, high);
            quicksort(sortArray, low, middle - 1);
            quicksort(sortArray, middle + 1, high);
        }
        System.out.println("第二種寫法的輸出：");
        sprint(sortArray);
    }

    /**
     * sprint()函數用於打印每次排序后的結果，非必須，但可以顯示每次排序情況
     */
    public void sprint(int[] arrays) {
        System.out.println("排序后的數組是：");
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        String str = "48 15 24 59 64 79 97 40";
        //將字符串用“ ”分開轉化為字符串數組
        String[] temp = str.split(" ");
        //定義一個整型數組s
        int[] s = new int[temp.length];
        //將字符串數組強制轉化為整型數組
        for (int i = 0; i < temp.length; i++) {
            //這種方法非常巧妙
            s[i] = Integer.parseInt(temp[i]);
        }
        //創建對象，並傳入數組s
        SortX quickSort = new SortX(s);
        quickSort.quicksort(s, 0, s.length - 1);
    }
}

參考：Java實現數組的快速排序（快速排序算法）