常见排序算法

冒泡排序

算法步骤

1. 相邻两个元素进行比较，大的放右边，小的放左边；
2. 第一轮比较结束后，就可以找到最大值，第二轮比第一次循环少一次
3. 若有n个数据参与排序，只需要进行n-1次循环即可得到最终的排序结果
   
   具体代码实现

public class Bubble {
    public static void main(String[] args) {
        // 需要排序的数组
        int[] arr = {3, 2, 4, 6, 5, 1, 8, 7};
        // 外循环表示需要进行n-1次循环
        for (int i = 0; i < arr.length - 1; i++) {
            // 内循环找每一轮的最大值
            // 如果是第一轮: 需要进行n-1轮比较才能找到最大值, 下一轮就不需要管最后一个元素了
            // 如果是第i轮: 需要进行n-1-i轮比较, 这一轮进行后i个元素已经完成排序
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }
}

选择排序

1. 从0索引开始，与后面的元素进行逐步比较，小的放左面，大的放右边
2. 第一轮比较结束后，就可以找到最小值，第二轮比第一次循环少一次
3. 若有n个数据参与排序，只需要进行n-1次循环即可得到最终的排序结果
   
   具体代码实现：

public class Selection {
    public static void main(String[] args) {
        // 需要排序的数组
        int[] arr = {3, 2, 4, 6, 5, 1, 8, 7};
        // 外循环表示需要进行n-1次循环
        for (int i = 0; i < arr.length - 1; i++) {
            // 内循环找每一轮的最小值
            // 如果是第一轮: 需要第一个数据和后面全部数据进行逐一比较, 共进行n-1次, 确定最小值
            // 如果是第i轮: 需要第i值与后面的数据进行比较, 此轮循环确定前面i个数据
            for (int j = i+1 ; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }
}

插入排序

1. 将索引0-N的看做是有序的，将索引N+1之后的数据看做是无序的
2. 遍历无序的数据，将无序的数据插入到有序的数据的适当位置中，小的放左边，大和相等的放右边
   
   具体代码实现：

public class Insert {
    public static void main(String[] args) {
        // 需要排序的数组
        int[] arr = {1, 2, 5, 3, 4, 2, 8, 7};

        // 首先来找无序索引
        int startIndex = -1; // 一般索引不存在的话均设置为-1
        for (int i = 0; i < arr.length; i++) {
            if(arr[i+1] < arr[i]) { //判断无序就是后面的比前面的小
                startIndex = i+ 1;
                break;
            }
        }
        // 开始遍历无序数据
        for (int i = startIndex; i < arr.length; i++) {
            //需要记录当前的index, 用以插入数据
            int index = i;
            while (index > 0 && arr[index-1] > arr[index]) {
                // 前面的数据大,就要交换
                int temp = arr[index-1];
                arr[index-1] = arr[index];
                arr[index] = temp;
                index--;
            }

        }
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }
}

快速排序

1. 从数据中选择一个元素作为“基准数”，一般是走边的第一个数据
2. 利用两个指针，一个从前往后，一个从后往前
3. 先从后往前，寻找比基准数小的数据
4. 再从前往后，寻找比基准数大的数据
5. 交换找到的两个数据
6. 直到两个数据相遇
7. 将当前指针的数据与基准数进行交换位置，进行基准数归位
8. 第一轮结束后，基准数左边都是基准数小的数据，右边是比基准数大的数据
9. 将基准数左边看做一个序列，右边也看做一个序列，按照上面的规则进行递归排序。
   
   具体代码实现：

public class Quick {
    public static void main(String[] args) {
        // 需要排序的数组
        int[] arr = {11, 22, 17, 5, 13, 4, 12, 18, 7};
        quickSort(arr, 0, arr.length - 1);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static void quickSort(int[] arr, int left, int right) {
        int start = left;
        int end = right;
        // 递归的出口
        if (start > end) {
            return;
        }

        int baiseData = arr[start];

        // 两个指针还没有遇到
        while (start != end) {
            //从后往前遍历
            while (true) {
                if (end <= start || arr[end] < baiseData) {
                    break;
                }
                end--;
            }
            // 从前往后遍历
            while (true) {
                if (end <= start || arr[start] > baiseData) {
                    break;
                }
                start++;
            }
            // 交换数据
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        // 两个指针遇到
        int temp = arr[left];
        arr[left] = arr[start];
        arr[start] = temp;
        // 左边新的序列
        quickSort(arr, left, start - 1);
        // 右边新的序列
        quickSort(arr, start + 1, right);


    }
}