普歌--三大基础排序，冒泡·选择·快速

---

冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

  public static void main(String[] args) {
        int arr[] = {18, 73, 54, 36, 64, 77};
        for (int i = arr.length-1; i > 0; i--) {    //6个数字，有6行，从最上面到最后一行，5 4 3  2 1 。
            for (int j = 0; j < i; j++) {  // i的个数决定了有几个数参与冒泡 // 每一行的数字参与冒泡；
                int temp;

                if(arr[j] > arr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }

            }
        }
        System.out.println(Arrays.toString(arr));
    }

选择排序

一、基本思想

• 它的基本思想是：第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，
• 第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换，
• 第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，…，
• 第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，…,
• 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

二、排序过程

原始数组：{25,103, 99, 46, 1}

第1次排序
[1, 103, 99, 46, 25]----25与1互换位置
第2次排序
[1, 25, 99, 46, 103]----25与103互换位置
第3次排序
[1, 25, 46, 99, 103]----99与46互换位置
第4次排序
[1, 25, 46, 99, 103]----已经是有序数组
————————————————

  public static void main(String[] args) {
        int arr[] = {25, 103, 99, 46, 1};
        for (int i = 0; i < arr.length-1; i++) {
            int miniIndex = i; // 定义一个索引指针
            int mini = arr[i];
            for (int j = i+1; j < arr.length; j++) { // 将arr[0]和后面的依次进行比较 j是第二个数。
                if (mini > arr[j]) { // 进行比较，小的数往前放，不小跳过
               // 对索引和arr[0]重新定义。每次拿的都是最小值。
                    miniIndex = j ;
                    mini = arr[j ]; // 较小的给了mini
                }
            }
            if (miniIndex != i) { // 当索引不相同的时候
                arr[miniIndex] = arr[i]; // 将较小的值给替换掉。
                arr[i] = mini; // 在把小值给到原来数位置
            }
            System.out.println("第"+(i+1)+"次排序");
            System.out.println(Arrays.toString(arr));
        }
    }

快速排序

• 首先设定一个分界值，通过该分界值将数组分成左右两部分
• 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值（具体看怎么分）
• 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理
• 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了

public static void main(String[] args) {
        int array[] = {2, 4, 1, 6, 3, 5};
        quickSort(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));  // 方便的输出数组，将这数组转为String类型输出。
    }

    public static void quickSort(int array[], int left, int right) {
        if (left >= right) {
            return;
        }

        int i = left; // 0
        int j = right; // 5
        int key = array[left]; // 2
        while (i < j) { // 0 5
            while (i < j && array[j] > key) { // 5 2 拿最后一个数和第一个数比较
                j--;  // 成立的话，让右指针往前移
            }
            array[i] = array[j]; // 【1，4，1，6，3，5】 1赋值代替了前面的2；
            //从后往前找到第一个比key小的数与array[i]交换；
            while (i < j && array[i] < key) { // 0 2
                i++;
            }
            array[j] = array[i];
            //从前往后找到第一个比key大的数与array[j]交换；
        }
        array[i] = key;
        //一趟快排之后已经将key的位置找到。
        quickSort(array, left, i - 1);
        //对key左边的进行排序
        quickSort(array, i + 1, right);
        //对key右边的进行排序
    }

---

欢迎大家雅正留言！