常用排序算法備忘錄

快速排序

public class QuickSort {
    public static void main(String[] args) {
        int[] array = {3, 5, 1, 4, 6, 2, 8,7};//3, 5, 1, 4, 6, 2, 8
        StringBuilder sb = new StringBuilder();
        new QuickSort().quickSort(array, 0, array.length - 1);
        for (Integer num : array) {
            sb.append(num).append(",");
        }

        System.out.println(sb.toString().substring(0, sb.toString().length() - 1));
    }

    private void quickSort(int array[], int left, int right) {
        if (left >= right) {
            return;
        }
        int mark = getMark(array, left, right);
        quickSort(array, left, mark - 1);
        quickSort(array, mark + 1, right);
    }

    private int getMark(int array[], int left, int right) {
        int mark = left;
        int basic = array[left];
        int temp;
        for (int i = left+1; i <= right; i++) {
            if (array[i] < basic) {
                mark++;
                temp = array[i];
                array[i] = array[mark];
                array[mark] = temp;
            }
        }
        temp = array[mark];
        array[mark] = basic;
        array[left] = temp;

        return mark;
    }
}

歸併排序

public class MergeSort {
    public static void main(String[] args) {
        int[] array = {3, 5, 1, 4, 6, 2, 8,7};//3, 5, 1, 4, 6, 2, 8
        StringBuilder sb = new StringBuilder();
        mergeSort(array);
        for (Integer num : array) {
            sb.append(num).append(",");
        }

        System.out.println(sb.toString().substring(0, sb.toString().length() - 1));
    }

    public static void mergeSort(int[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    public static void sort(int[] arr, int L, int R) {
        if(L == R) {
            return;
        }
        int mid = (L + R) / 2;
        sort(arr, L, mid);
        sort(arr, mid + 1, R);
        merge(arr, L, mid, R);
    }

    public static void merge(int[] arr, int L, int mid, int R) {
        int[] temp = new int[R - L + 1];
        int i = 0;
        int p1 = L;
        int p2 = mid + 1;
        // 比較左右兩部分的元素，哪個小，把那個元素填入temp中
        while(p1 <= mid && p2 <= R) {
            temp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        // 上面的循環退出後，把剩餘的元素依次填入到temp中
        // 以下兩個while只有一個會執行
        while(p1 <= mid) {
            temp[i++] = arr[p1++];
        }
        while(p2 <= R) {
            temp[i++] = arr[p2++];
        }
        // 把最終的排序的結果複製給原數組
        for(i = 0; i < temp.length; i++) {
            arr[L + i] = temp[i];
        }
    }
}

堆排序

/**
 * 堆排序思想
 * 三個方法，heapify(),buildHeap(),heapSort()
 * 1.heapify():先對（比如根節點進行）heapify操作：
 * 找到兩個子節點下標，把根節點和子節點進行比較，找到值最大的那個下標，如果這個下標不等於根節點，
 * 則交換值。進行下輪heapify(因爲替換後的節點可能也不符合最大堆定義)
 * 2.buildHeap()將一個無序數組構建爲一個最大堆，根據n，找到最後的父節點，然後各個父節點依次進行heapify操作
 * 3.heapSort(),先將無序數據調用buildHeap()，然後將根節點值與數組最後一個值進行交換，然後對0到n-2進行heapify()
 */
public class HeapSort {

    public static void main(String[] args) {
        HeapSort heapSort = new HeapSort();
//        int[] array = {4, 10, 3, 5, 1, 2};
        int[] array = {1, 2, 3};
        int n = array.length;
        heapSort.heapSort(array, n);
        for (int num : array) {
            System.out.println(num);
        }
    }

    private void heapSort(int[] array, int n) {
        buildHeap(array, n);
        for (int i = n - 1; i >= 0; i--) {
            swap(array, 0, i);
            heapify(array, i, 0);
        }
    }

    private void buildHeap(int[] array, int n) {
        int lastNode = n - 1;
        int lastParent = (lastNode - 1) / 2;
        for (int i = lastParent; i >= 0; i--) {
            heapify(array, n, i);
        }
    }

    private void heapify(int[] array, int n, int root) {
        if (root >= n) {
            return;
        }
        int left = root * 2 + 1;
        int right = root * 2 + 2;
        int max = root;
        if (left < n && array[left] > array[max]) {
            max = left;
        }
        if (right < n && array[right] > array[max]) {
            max = right;
        }

        if (max != root) {
            swap(array, root, max);
            heapify(array, n, max);//
        }
    }

    private void swap(int[] array, int root, int max) {
        int temp = array[root];
        array[root] = array[max];
        array[max] = temp;
    }
}