排序算法

内部排序算法

1.通过交换进行排序

快速排序

核心思想：在数组中选一个中轴元素（比如数组首元素），将余下的元素和中轴元素做比较，小的在左边，大的在右边，然后以中轴元素为界，用递归的方式对左右部分的元素分别重复上述操作。

快排中最重要的操作就是把小于中轴元素的放左边，否则放右边，通常有三种方式：从两端扫描交换、两端扫描填坑，单端扫描，下面的代码用了单端扫描的方式。jdk7还增加了双轴快速排序的方式DualPivotQuicksort。

/**
 * 单端扫描
 *
 * @author xuanliang
 * @created 2018年3月9日
 */
public class QuickSort {

    public static void main(String[] args) {
        int[] a = { 5, 4, 8, 1, 2, 9, 6, 7, 0, 3, 3 };
        quickSort(a, 0, 10);
        for (int i = 0; i < 11; i++) {
            System.out.println(a[i]);
        }
    }

    public static void swap(int a[], int x, int y) {
        int i = a[x];
        a[x] = a[y];
        a[y] = i;
    }

    public static void quickSort(int a[], int left, int right) {
        if (left >= right)
            return;
        int last = left;
        for (int i = left + 1; i <= right; i++) {
            if (a[i] < a[left]) {
                if (i != last) {
                    swap(a, ++last, i);
                }
            }
        }

        swap(a, left, last);

        quickSort(a, left, last - 1);

        quickSort(a, last + 1, right);
    }
}

从两端扫描：要注意临界点i == j时，也要和轴元素比较

public static void quickSort(int a[], int left, int right) {
    if (left >= right)
        return;
    int pivot = a[left];
    int i = left + 1;
    int j = right;
    while (i <= j) {

        while (i <= j && pivot >= a[i]) {
            i++;
        }

        while (i <= j && pivot < a[j]) {
            j--;
        }

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

    swap(a, left, j);

    quickSort(a, left, j - 1);

    quickSort(a, j + 1, right);
}

冒泡排序

核心思想：

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

2.通过插入进行排序

直接插入排序

public static void insertSort(int[] a) {
    for (int i = 1, j; i < a.length; i++) {
        int index = a[i];
        for (j = i; j > 0 && index < a[j - 1]; j--) {
            a[j] = a[j - 1];
        }
        a[j] = index;
    }
}

希尔排序

核心思想：分组插入排序，又称缩小增量排序

3.通过选择进行排序

选择排序

public static void selectSort(int[] a) {
    for (int i = 0; i < a.length - 1; i++) {
        int min = i;
        for (int j = i + 1; j < a.length; j++) {
            if (a[min] > a[j]) {
                min = j;
            }
        }
        swap(a, i, min);
    }
}

堆排序

核心思想：通过构建大顶堆来寻找一个最大值（或者构建小顶堆寻找最小值），然后将最大值（或最小值）和堆末元素交换，对剩下的n-1个节点进行重复操作，就得到了一个有序队列

4.通过合并进行排序

归并排序

public class MergeSort {

    public static void main(String[] args) {
        int[] a = { 5, 4, 8, 1, 2, 9, 6, 7, 0, 3, 10 };
        int[] temp = new int[a.length];
        mergeSort(a, 0, a.length - 1, temp);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

    public static void mergeSortArray(int[] a, int first, int mid, int last, int[] temp) {
        int i = first;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= last) {
            if (a[i] <= a[j]) {
                temp[k++] = a[i++];
            }

            else {
                temp[k++] = a[j++];
            }
        }

        while (i <= mid) {
            temp[k++] = a[i++];
        }

        while (j <= last) {
            temp[k++] = a[j++];
        }

        for (i = 0; i < k; i++)
            a[first + i] = temp[i];
    }

    public static void mergeSort(int[] a, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(a, left, mid, temp);
            mergeSort(a, mid + 1, right, temp);
            mergeSortArray(a, left, mid, right, temp);
        }
    }
}