数据结构 —— 数组排序的方法

目录

一、冒泡排序

二、选择排序法

三、直接插入排序

四、希尔排序

五、快速排序

---

参考链接：https://blog.csdn.net/DallinC/article/details/84142209

一、冒泡排序

在外循环中第一次循环是i，然后在内循环中arr1[i] 和arr1[j]每一个数据进行比较，如果arr1[j] < arr1[i]，把较小的值赋给arr1[i]，使得排在前面的数据一直都是较小值，直到内层循环结束，使得arr1[i]为最小值。

        for (int i = 0; i < arr1.length; i++) {

            for (int j = i; j < arr1.length; j++) {
                if (arr1[j] < arr1[i]) {
                    int tempNum = arr1[i];
                    arr1[i] = arr1[j];
                    arr1[j] = tempNum;
                }
            }

        }

 

二、选择排序法

选择最小值的索引与外层循环中正在比较的数据交换位置

在外循环中第一次循环是i，然后在内循环中arr1[i] 和arr1[j]每一个数据进行比较，获取较小的值的索引赋给temp，（temp = j），同时使用arr1[temp]表示较小值，之后持续进行内循环，并更新temp，使得arr1[temo]的值最小。

内循环

1. 先用temp表示较小值的索引，
2. 之后比较之后，更新temp，
3. 然后用temp来索引较小值，
4. 进行第2步，继续比较。

外循环：负责较小值arr1[temp]与 arr1[i]实现数据交换。

 

 for (int i=0;i<arr1.length;i++){
            int temp = i;
            for (int j=i;j<arr1.length;j++){
                if(arr1[j]<arr1[temp]){
                    temp = j;
                }
            }
            int tempNum = arr1[i];
            arr1[i] = arr1[temp];
            arr1[temp] = tempNum;
        }

三、直接插入排序

第一个位置不用比较

从第二个位置开始，和第一个位置比较，并把较小值放在第一个位置

每次都是相邻的两个位置比较，

1. 若第三个位置小于第二个位置，则交换位置，之后继续与第一个位置比较，从而实现了这个三个数的正确排序
2. 若第三个位置大于第二个位置，则不用交换，因为前面已经排序了。
3. 依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。

    public static int [] sort(int[] arr1) {

        for (int i = 0; i < arr1.length; i++) {
            for (int j = i; j > 0 && arr1[j] < arr1[j - 1];) {
                int tempNum = arr1[j];
                arr1[j] = arr1[j - 1];
                arr1[j - 1] = tempNum;
                j--;

            }

        }
        return arr1;
    }

四、希尔排序

参考代码：https://blog.csdn.net/qq_28081081/article/details/80598960

参考思想：https://blog.csdn.net/zhou_438/article/details/83715455

根据gap分组，组内实现直接插入排序，直到gap==1，结束循环

package com.example.priorityqueue;

class Solution {
    public static int[] shellSort(int[] ins) {

        int n = ins.length;
        int gap = n / 2;
        while (gap > 0) {
            for (int i = gap; i < n; i++) {
//                这里面是一个直接插入排序的方法
                for (int j = i; j >= gap && ins[j] < ins[j - gap]; ) {
                    int temp = ins[j - gap] + ins[j];
                    ins[j - gap] = temp - ins[j - gap];
                    ins[j] = temp - ins[j - gap];
                    j -= gap;
                }
            }
            gap = gap / 2;
        }
        return ins;
    }


    public static void main(String args[]) {
        Solution solution = new Solution();
        int[] arr = new int[]{9, 71, 37, 56, 88, 96, 21, 5, 48, 43};
        shellSort(arr);
        for (int x = 0; x < arr.length; x++) {
            System.out.print(arr[x] + ",");
        }
    }
}

五、快速排序

参考代码：https://blog.csdn.net/WZL995/article/details/88365958

参考思想：https://www.cnblogs.com/dev1ce/p/10618478.html

快速排序的算法思想：

9、71、37、56、88、96、21、58、48、43   数组元素

0、1、   2、  3、  4、  5、  6、  7、  8、 9     数组下标

选取数组中某一个元素，使得元素左侧的数组元素都小于等于该元素，数组右侧的元素都大于该元素.

例如选择元素 58 ，将数组按以上规则进行第一轮排序得。

9、37、56、21、48、43、58、88、96。

第一轮排序后满足上述规则。

第二轮将58左右两侧数组再次按上述规则进行排序。（采用递归的思想，直到数组不可分）

。。。。。

根据以上思想得知：如何计算某一个元素非常重要，实际上计算这个元素的位置才是本质。这也是快速排序的核心。

快速排序的实现采用了“原址排序”。即在原数组中进行排序，与归并排序需要额外的空间相不同。

实现的思路为：将原数组分为3部分，小于等于某元素，某元素，大于某元素。

package com.example.priorityqueue;

class Solution {
    public static int getMiddle(int[] arr, int low,int high)
    {
        int temp = arr[low]; //此处把数组的第一个数作为基准值
        while(low < high)
        {
            while(low < high && arr[high] > temp)
            {
                high--;
            }
            arr[low] = arr[high];//比基准值小的数移到低端
            while(low < high && arr[low] < temp)
            {
                low++;
            }
            arr[high] = arr[low] ; //比基准值大的数移到高端
        }
        arr[low] = temp ; //基准值最后一个记录
        return low ; // 返回排一次后基准值的新位置
    }
    public static void QuickSort(int [] arr,int low,int high) {
        if(low < high)
        {
            int middle = getMiddle(arr,low,high); //将arr数组进行一分为二
            QuickSort(arr, low, middle-1);   //对低字段表进行递归排序
            QuickSort(arr, middle+1, high); //对高字段表进行递归排序
        }
    }



    public static void main(String args[]) {
        Solution solution = new Solution();
        int[] arr = new int[]{9, 71, 37, 56, 88, 96, 21, 5,48, 43};
        QuickSort(arr,0,arr.length-1);
        for(int x = 0;x < arr.length;x++){
            System.out.print(arr[x]+",");
        }


    }
}