Java八种排序算法

import java.util.Arrays;

public class SecondSort {

    // 插入排序
    public void insertSort(int[] a) {
        if (null == a || a.length <= 1) {
            return;
        }

        int length = a.length;

        for (int i = 1; i < length; i++) {
            int key = a[i];
            int j = i - 1;

            while (j >= 0 && a[j] > key) {
                a[j + 1] = a[j];
                --j;
            }

            a[j + 1] = key;
        }
    }

    // 冒泡排序
    public  void bubbleSort(int[] a) {
        if (null == a || a.length <= 1) {
            return;
        }

        int length = a.length;

        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length - i - 1; j++) {
                if (a[j] > a[j + 1]) {
                    swap(a, j, j + 1);
                }
            }
        }
    }

    // 选择排序
    public void selectSort(int[] a) {
        if (null == a || a.length <= 1) {
            return;
        }

        int length = a.length;

        for (int i = 0; i < length; i++) {
            int min = a[i];
            int position = i;
            for (int j = i + 1; j < length; j++) {
                if (a[j] < min) {
                    min = a[j];
                    position = j;
                }
            }
            a[position] = a[i];
            a[i] = min;
        }
    }

    // 希尔排序
    public void shellSort(int[] a) {
        if (null == a || a.length <= 1) {
            return;
        }

        int length = a.length;

        for (int gap = length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < length; i++) {
                int key = a[i];
                int j = i - gap;

                while (j >= 0 && a[j] > key) {
                    a[j + gap] = a[j];
                    j -= gap;
                }

                a[j + gap] = key;
            }
        }
    }

    // 快速排序
    public void quickSort(int[] a, int low, int high) {
        if (low < high) {
            int i = low;
            int j = high;
            int key = a[low];

            while (i < j) {
                // 从右到左
                while (i < j && a[j] >= key) {
                    j--;
                }

                //从左到右
                while (i < j && a[i] <= key) {
                    i++;
                }

                if (i < j) {
                    swap(a, i, j);
                }
            }

            swap(a, i, low);
            quickSort(a, low, i - 1);
            quickSort(a, i + 1, high);
        }
    }

    // 归并排序
    public void mergeSort(int[] a, int low, int high) {
        if (low < high) {
            int mid = (low + high) >> 1;
            mergeSort(a, low, mid);
            mergeSort(a, mid + 1, high);

            mergeArray(a, low, mid, high);
        }
    }

    public void mergeArray(int[] a, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];

        int k = 0;
        int i = low;
        int j = mid + 1;

        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++];
        }

        for (int x = 0; x < temp.length; x++) {
            a[low + x] = temp[x];
        }
    }

    // 基数排序
    public void baseSort(int[] a) {
        if (null == a || a.length <= 1) {
            return;
        }

        int length = a.length;

        int max = a[0];

        for (int i = 1; i < length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }

        int digits = 0;

        while (max > 0) {
            max /= 10;
            ++digits;
        }

        int[] res = new int[length];
        int[] c = new int[10];
        int divide = 1;

        for (int i = 0; i < digits; i++) {
            res = Arrays.copyOf(a, length);
            Arrays.fill(c, 0);

            for (int j = 0; j < length; j++) {
                c[(res[j] / divide) %10]++;
            }

            for (int j = 1; j < 10; j++) {
                c[j] = c[j] + c[j - 1];
            }

            for (int j = length - 1; j >=0; j--) {
                a[--c[((res[j] / divide) % 10)]] = res[j];
            }

            divide *= 10;
        }

    }

    public void heapSort(int[] a) {
        if (null == a || a.length <= 1) {
            return;
        }

        int length = a.length;

        // 从最后一个非叶子节点构建大顶堆最后一个非叶子节点为(length - 2) / 2
        // 构建大顶堆
        for (int i = (length - 2) >> 1; i >= 0; i --) {
            adjustMaxHeap(a, i, length);
        }

        for (int j = length - 1; j > 0; j--) {
            // 堆顶元素与末尾元素交换
            swap(a, 0, j);

            // 重新调整堆
            adjustMaxHeap(a, 0, j);
        }
    }

    // 调整大顶堆
    private void adjustMaxHeap(int[] a, int i, int length) {
        int parent = a[i];

        // parent节点的左孩子节点为 2 * i + 1，右孩子节点为 2 * i + 2
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            if (k + 1 < length && a[k + 1] > a[k]) {
                k++;
            }

            if (parent >= a[k]) {
                // 父节点已经最大，停止
                break;
            } else {
                // 调整交换
                a[i] = a[k];
                i = k;
            }
        }
        a[i] = parent;
    }

    private void swap(int[] a, int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    public static void main(String[] args) {
        int[] a = new int[]{32, 43, 23, 13, 5};
        SecondSort sort = new SecondSort();
//        sort.insertSort(a);
//        sort.bubbleSort(a);
//        sort.selectSort(a);
//        sort.shellSort(a);
//        sort.quickSort(a, 0, a.length - 1);
//        sort.mergeSort(a, 0, a.length - 1);
//        sort.baseSort(a);
        sort.heapSort(a);
        System.out.println(Arrays.toString(a));
    }
}