JAVA排序算法（1）

冒泡排序

public void bubbleSort(int[] arr) {
        // 增加表标识位来优化冒泡排序 如果当前这一轮没有发生交换 那么就证明数组已经有序
        boolean swapped = true;
        for (int i = 0; i < arr.length - 1 && swapped; i++) {
            swapped = false;
            // 每一轮将最大的数冒泡到最后
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 如果当前元素大于下一个元素 那么交换它们的位置
                if (arr[j] > arr[j + 1]) {
                    swapped = true;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

快速排序

public void quickSort(int[] arr, int l, int r) {
        while (l < r) {
            int pivot = partition(arr, l, r);
            //尾递归优化空间复杂度 每次只排序左半边和右半边中元素少的那一边
            if (pivot - l < r - pivot) {
                quickSort(arr, l, pivot - 1);
                l = pivot + 1;
            } else {
                quickSort(arr, pivot + 1, r);
                r = pivot - 1;
            }
        }
    }

    public int partition(int[] arr, int l, int r) {
    	int random = (int) (Math.random() * (r - l + 1) + l);
        swap(arr, random, l);
        //由于每次都选取最左或者最右作为基准点的话，数组完全有序和万全倒序的事件复杂度相差很大
        //所以采用随机基准点的方式，来尽可能的避免算法出现最坏情况 O（N²）
        int i = l, j = r;
        while (i < j) {
            //选择最左侧元素作为基准点 右边保留大于基准点的元素 左边保留小于基准点的元素
            //从右向左找第一个小于基准点的元素
            while (i < j && arr[j] >= arr[l]) j--;
            //从左向右找第一个大于基准点的元素
            while (i < j && arr[i] <= arr[l]) i++;
            //交换这俩元素
            swap(arr, i, j);
        }
        //结束后将基准点和最左侧元素交换
        swap(arr, l, i);
        return i;
    }
    
    public void swap(int[] arr, int j, int k) {
        int temp = arr[j];
        arr[j] = arr[k];
        arr[k] = temp;
    }

归并排序

public void mergeSort(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int mid = l + (r - l) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        //开始合并 创建一个临时数组
        int[] temp = new int[r - l + 1];
        //将l - r这个区间的元素先写入临时数组
        if (r + 1 - l >= 0) {
            System.arraycopy(arr, l, temp, 0, r + 1 - l);
        }
        // 两个指针分别指向左右两个子数组的首元素
        int i = 0, j = mid + 1 - l;
        //合并两个数组
        for (int k = l; k <= r; k++) {
            if (i == mid - l + 1) {
                arr[k] = temp[j++];
            } else if (j == r - l + 1 || temp[i] <= temp[j]) {
                arr[k] = temp[i++];
            } else {
                arr[k] = temp[j++];
            }
        }
    }

插入排序

public void insertedSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (arr[j] >= temp) {
                    arr[j + 1] = arr[j];
                } else {
                    break;
                }
                arr[j] = temp;
            }
        }
    }