常用排序算法

1.冒泡排序
2.选择排序
3.插入排序
4.希尔排序
5.归并排序
6.快速排序
7.堆排序
8.计数排序
9.桶排序
10.基数排序

冒泡排序：

思路

这可能是所有程序员都最熟悉的一种排序方式，主要思想就是，从第一个元素开始，和第二个元素比较大小，如果比后面的元素小，就置换两个元素，这样依次传递，传递到最后一个元素，就是最大值，然后再从第一个元素开始，传送到倒数第二个元素，就是次最大的元素，这样比较到最后，就把数组排序完成了。

package com.darwin.algorithm.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 */
public class BubbleSort {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(bubbleSort(new int[]{7, 0, 4, 8, 2, 1})));
    }

    private static int[] bubbleSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }
}

选择排序

思路

选择排序可能是最好理解的一种排序方式，主要思想就是，比较数据里面所有的元素，选择处最小的那个，放到第一个位置，然后再从剩下的所有元素中选择出第二小的元素，放到第二个位置，依次类推，完成整个数组的排序。

package com.darwin.algorithm.sort;

import java.util.Arrays;

/**
 * 选择排序
 */
public class SelectionSort {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(selectionSort(new int[]{7, 0, 4, 8, 2, 1})));
    }

    private static int[] selectionSort(int[] arr) {
        int len = arr.length;
        for (int i = 1; i < len; i++) {
            int min = arr[i - 1];
            int index = i - 1;
            for (int j = i; j < len; j++) {
                if (arr[j] < min) {
                    index = j;
                    min = arr[j];
                }
            }
            int temp = arr[i - 1];
            arr[i - 1] = min;
            arr[index] = temp;
        }
        return arr;
    }
}

插入排序

思路

插入排序，固定第一个元素的位置，然后从第二个元素开始，依次比较和之前元素的大小，如果比之前的元素小，就把前面的元素往后移一位，直到找到当前元素应该插入的位置，将元素插入进去。

package com.darwin.algorithm.sort;

import java.util.Arrays;

/**
 * 插入排序
 */
public class InsertSort {

    public static void insertSort(int[] arr) {
        int len = arr.length;
        for (int i = 1; i < len; i++) {
            int num = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > num) {
                arr[j + 1] = arr[j--];
            }
            arr[j + 1] = num;
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[] {5,9,0,2,2,5,8,1,4};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

希尔排序

思路

希尔排序是一种优化的插入排序，这种算法的主旨是，通过某种方式，将数组中的数据调整至大致从小到大的分布，这样再使用插入排序，比较的次数就会大大的减少，一般会分成几组，最开始分成arr.length / 2组，再一次/2，保证最后能变成一大组的插入排序。

package com.darwin.algorithm.sort;

import java.util.Arrays;

/**
 * 希尔排序
 */
public class ShellSort {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(shellSort(new int[]{7, 0, 4, 8, 2, 1})));
    }

    private static int[] shellSort(int[] arr) {
        int len = arr.length;
        int num = len / 2;
        while (num > 0) {
            for (int i = 0; i < num; i++) {
                for (int j = i + num; j < len; j+=num) {
                    int poi = arr[j];
                    int pre = j - num;
                    while (pre >= 0 && arr[pre] > arr[pre + num]) {
                        int temp = arr[pre];
                        arr[pre] = arr[pre + num];
                        arr[pre + num] = temp;
                        pre -= num;
                    }
                    arr[pre + num] = poi;
                }
            }
            num /= 2;
        }
        return arr;
    }
}

归并排序

思路

归并排序主要的思想是分和和的概念，将一个数组从中间分为左右两部分，然后每一部分再分为左右两个部分，直到每一个部分只有一个元素，再将这两个元素排序，然后再递归上去和另一半排序，最后完成整个数组的排序。

package com.darwin.algorithm.sort;

import java.util.Arrays;

/**
 * 归并排序
 */
public class MergeSort {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(mergeSort(new int[]{9, 8, 7, 6, 3, 4, 5, 0})));
    }

    private static int[] mergeSort(int[] arr) {
        mergeSort(arr, 0, arr.length - 1);
        return arr;
    }

    private static void mergeSort(int[] arr, int left, int right) {
        if (left == right) {
            return;
        }
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, mid + 1, right);
    }

    private static void merge(int[] arr, int l1, int r1, int l2, int r2) {
        int i = l1;
        int[] temp = new int[r2 - l1 + 1];
        int point = 0;
        while (l1 <= r1 && l2 <= r2) {
            if (arr[l1] <= arr[l2]) {
                temp[point++] = arr[l1++];
                continue;
            }
            temp[point++] = arr[l2++];
        }
        while (l1 <= r1) {
            temp[point++] = arr[l1++];
        }
        while (l2 <= r2) {
            temp[point++] = arr[l2++];
        }
        System.arraycopy(temp, 0, arr, i, temp.length);
    }
}

快速排序

思路

快速排序的思想就是在数组中选择一个点，然后置换整个点左右两边的元素，将整个点左边的元素都变成不比整个点大的元素，右边都变成不比整个点小的元素，然后再在这个点左右两边再选取一个点，完成这个操作。

package com.darwin.algorithm.sort;

import java.util.Arrays;

/**
 * 快速排序
 */
public class QuickSort {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(quickSort(new int[]{7, 0, 4, 8, 2, 1})));
    }

    private static int[] quickSort(int[] arr) {
        quickSort(0, arr.length - 1, arr);
        return arr;
    }

    private static void quickSort(int left, int right, int[] arr) {
        if (left >= right) {
            return;
        }
        int l = left;
        int r = right;
        int mid = (left + right) / 2;
        int num = arr[mid];
        while (left < right) {
            while (left < mid && arr[left] <= num) {
                left++;
            }
            while (right > mid && arr[right] >= num) {
                right--;
            }
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            if (mid == left) {
                mid = right;
            } else if (mid == right) {
                mid = left;
            }
        }
        quickSort(l, mid - 1, arr);
        quickSort(mid + 1, r, arr);
    }
}

堆排序

思路

堆排序是将整个数组想成一个完全二叉树，然后构建成一个大堆顶（就是每一个父子节点的值都大于它的左右子节点的值），这样就保证了，最大的元素一定在二叉树的根节点，然后置换根节点和最后一个节点，最后一个位置上就是最大的值，然后用除了最后一个元素的数组确定第二大的元素，依次类推，完成数组的排序。

package com.darwin.algorithm.sort;

import java.util.Arrays;

public class HeapSort {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(heapSort(new int[]{4, 6, 8, 5, 9})));
    }

    private static int[] heapSort(int[] arr) {
        int len = arr.length;
        //  从第一个非叶子节点开始
        for (int i = len / 2 - 1; i >= 0; i--) {
            adjustHeap(i, arr, len);
        }
        for (int i = len - 1; i >= 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            adjustHeap(0, arr, i);
        }
        return arr;
    }

    private static void adjustHeap(int point, int[] arr, int length) {
        int num = arr[point];
        for (int i = point * 2 + 1; i < length; i = i * 2 + 1) {
            if (i + 1 < length && arr[i + 1] > arr[i]) {
                i++;
            }
            if (arr[i] > num) {
                arr[point] = arr[i];
                point = i;
            } else {
                break;
            }
        }
        arr[point] = num;
    }
}