常见的排序算法（上）

常见的几个排序算法：
1.冒泡排序
2.选择排序
3.插入排序
4.希尔排序
5.快速排序
当然除了这几个排序算法还有很多排序算法，今天就着重了解这些算法

冒泡排序

冒泡排序是一种比较简单的排序，通过两个元素对比，元素顺序错了就把位置调换过来，直到不再交换位置，排序完成

 private static String bubbleSort(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {//前一位大于后一位
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return Arrays.toString(arr);
    }

选择排序

选择排序是一种比较好理解的算法，他的思想就是在遍历的过程当中，找到最小的值，放到起始的位置，然后继续在剩余的元素里找到最小的值，元素交换，直到结束

    private static String selectSort(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            int index = i;
            for (int j = i + 1; j < length; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            // 最小元素与当前的i互换
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        return Arrays.toString(arr);
    }

插入排序

插入排序是一种比较稳定的排序算法，这个算法的思想就是每一步将待排序的元素记录，然后插入到前面的有序的序列中，直到插完所有的元素为止

    private static String insertSort(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            //定义待插元素
            int value = arr[i+1];
            int j = i;
            for (;j>=0 && arr[j] > value;j--){
                arr[j+1] = arr[j];
            }
            arr[j+1] = value;
        }
        return Arrays.toString(arr);
    }

首先定义一个待插元素，然后与他的前一位进行比较，如果前一位大于后一位，那么就那么就将前一位后移，再把待插元素放到前一位，然后继续重复该步骤，直到结束

希尔排序

希尔排序采用了分治法的思想，首先定义一个增量，将所有元素按照增量分组，然后每组使用插入排序进行排序，接着缩小增量，每组再继续使用插入排序进行排序，直到增量变为1，整个元素也就变成了一组元素。

    private static String shellSort(int[] arr) {
        int length = arr.length;
        for (int gap = length / 2; gap > 0; gap /= 2) {//gap = gap / 2
            for (int i = gap; i < length; i++) {
                for (int j = i - gap; j >= 0 && arr[j] > arr[j + gap]; j -= gap) {//j = j - gap
                    int temp = arr[j];
                    arr[j] = arr[j + gap];
                    arr[j + gap] = temp;
                }
            }
        }
        return Arrays.toString(arr);
    }

定义增量为数组长度的二分之一，假如数组长度为10，那么增量就为5，第1位元素和第6（5+1）位元素为一组，以此类推，然后每组进行插入排序，

快速排序

快速排序的思路大致为先确定一个基准数，然后所有比他小的元素都放在他的左边，所有比他大的元素都放在他的右边，然后接着对两边的数据进行快速排序，这个过程可以递归进行，直到达到有序

    private static String quickSort(int[] arr, int left, int right) {
        int l = left;// 左
        int r = right;// 右
        int mid= arr[(left + right) / 2];// 找到中间的值
        // 将比pivot小的值放在其左边，比pivot大的值放在其右边
        while (l < r) {
            while (arr[l] < mid) {
                l += 1;// 将l右移一位
            }
            while (arr[r] > mid) {
                r -= 1;// 将r左移一位
            }
            if (l >= r) {
                break;
            }
            // 交换元素
            int temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            
            if (arr[l] == mid) {
                r -= 1;
            }
            if (arr[r] == mid) {
                l += 1;
            }
        }
        
        if (l == r) {
            l += 1;
            r -= 1;
        }
        // 向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }
        // 向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }
        return Arrays.toString(arr);
    }