深入浅出经典排序算法

雨点打透心脏的1/2处 2023-06-26 08:10 34阅读 0赞

##### 前言 #####

博主最近在恶补基础知识，算法必然是必不可少的，那么就从经典排序算法开始吧！（*图源网络，侵删*）,没有列出全部，因为在期末考试囧  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70]

#### 代码太多，就只显示了最关键的部分 ####

**1. 冒泡排序**  
实现思路：  
（1）比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。  
（2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第 N-1个位置。  
（3）N=N-1，如果N不为 0就重复前面二步，否则排序完成。  
这也是博主接触到的第一个排序算法

public static void bubbleSort1(){ 
        int i, j; 
        for(i=0; i<n; i++){//表示 n次排序过程。 
            for(j=1; j<n-i; j++){ 
                if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换 
                    //交换a[j-1]和a[j] 
                    int temp; 
                    temp = a[j-1]; 
                    a[j-1] = a[j]; 
                    a[j]=temp; 
                } 
            } 
        } 
    }

图示：  
![在这里插入图片描述][20191230201710975.gif]

**2. 插入排序算法**  
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入。如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函 数。如果输入数组是逆序排列的，将出现最坏情况。平均情况与最坏情况一样，其时间代价是(n2)。

public void sort() 
            { 
                for(int i =1; i<arr.length;i++) 
                { 
                    //插入的数 
                    int insertVal = arr[i]; 
                    //被插入的位置(准备和前一个数比较) 
                    int index = i-1; 
                            //如果插入的数比被插入的数小 
                            while(index>=0&&insertVal<arr[index]) 
                            { 
                                //将把arr[index] 向后移动 
                                arr[index+1]=arr[index]; 
                                //让index向前移动 
                                index--; 
                            } 
                            //把插入的数放入合适位置 
                    arr[index+1]=insertVal; 
                } 
      }

图示：  
![在这里插入图片描述][20191230201954766.gif]  
**3. 快速排序算法**  
快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的）， 比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。

public void sort(){ 
             int start = low; 
             int end = high; 
             int key = a[low];       
               while(end>start){ 
                 //从后往前比较 
                 while(end>start&&a[end]>=key)  
     //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较 
                     end--; 
                 if(a[end]<=key){ 
                     int temp = a[end]; 
                     a[end] = a[start]; 
                     a[start] = temp; 
                 } 
                 //从前往后比较 
                 while(end>start&&a[start]<=key) 
    //如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置 
                    start++; 
                 if(a[start]>=key){ 
                     int temp = a[start]; 
                     a[start] = a[end]; 
                     a[end] = temp; 
                 } 
             //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的 值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用 
             } 
             //递归 
             if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1 
             if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个 
         } 
       }

图示：  
![在这里插入图片描述][20191230202446767.gif]  
**4. 希尔排序**  
基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列 中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

*  选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
 *  按增量序列个数k，对序列进行k 趟排序；
 *  每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进 行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

private void shellSort() { 
       int dk = a.length/2;  
       while( dk >= 1  ){   
                    ShellInsertSort(a, dk);   
                     dk = dk/2; 
       } 
     } 
     private void ShellInsertSort(int[] a, int dk) { 
    //类似插入排序，只是插入排序增量是1，这里增量是dk,把1换成dk就可以了 
      for(int i=dk;i<a.length;i++){ 
       if(a[i]<a[i-dk]){ 
        int j; 
        int x=a[i];//x为待插入元素 
        a[i]=a[i-dk]; 
        for(j=i-dk;  j>=0 && x<a[j];j=j-dk){ 
    //通过循环，逐个后移一位找到要插入的位置。 
         a[j+dk]=a[j]; 
        } 
        a[j+dk]=x;//插入 
       } 
      } 
     }

图示：  
![希尔排序][2019123020284167.gif]  
**5. 归并排序算法**  
归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列 分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列

public class MergeSortTest (){   
         public static void main(String[] args) {   
            int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };   
            print(data);   
            mergeSort(data);   
            System.out.println("排序后的数组：");   
            print(data);   
        }   
         public static void mergeSort(int[] data) {   
            sort(data, 0, data.length - 1);   
        }   
          public static void sort(int[] data, int left, int right) {   
            if (left >= right)   
                return;   
            // 找出中间索引   
            int center = (left + right) / 2;   
            // 对左边数组进行递归   
            sort(data, left, center);   
            // 对右边数组进行递归   
            sort(data, center + 1, right);   
            // 合并   
            merge(data, left, center, right);   
            print(data);   
        }   
          /**  
         * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序  
         *   
         * @param data  
         *            数组对象  
         * @param left  
         *            左数组的第一个元素的索引  
         * @param center  
         *            左数组的最后一个元素的索引，center+1是右数组第一个元素的索引  
         * @param right  
         *            右数组最后一个元素的索引  
         */   
        public static void merge() {   
            // 临时数组   
            int[] tmpArr = new int[data.length];   
            // 右数组第一个元素索引   
            int mid = center + 1;   
            // third 记录临时数组的索引   
            int third = left;   
            // 缓存左数组第一个元素的索引   
            int tmp = left;   
            while (left <= center && mid <= right) {   
                // 从两个数组中取出最小的放入临时数组   
                if (data[left] <= data[mid]) {   
                    tmpArr[third++] = data[left++];   
                } else {   
                    tmpArr[third++] = data[mid++];   
                }   
            }   
            // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）   
            while (mid <= right) {   
                tmpArr[third++] = data[mid++];   
            }   
            while (left <= center) {   
                tmpArr[third++] = data[left++];   
            }   
            // 将临时数组中的内容拷贝回原数组中   
            // （原left-right范围的内容被复制回原数组）   
            while (tmp <= right) {   
                data[tmp] = tmpArr[tmp++];   
            }   
        }   
        public static void print(int[] data) {   
            for (int i = 0; i < data.length; i++) {   
                System.out.print(data[i] + "\t");   
            }   
            System.out.println();   
        }   
      }

图示：  
![在这里插入图片描述][20200101201628490.gif]  
**6. 桶排序算法**  
桶排序的基本思想是： 把数组 arr 划分为 n 个大小相同子区间（桶），每个子区间各自排序，最 后合并 。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

*  找出待排序数组中的最大值max、最小值min
 *  我们使用 动态数组 ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(maxmin)/arr.length+1
 *  遍历数组 arr，计算每个元素 arr\[i\] 放的桶
 *  每个桶各自排序

public static void bucketSort(){       
    		int max = Integer.MIN_VALUE;   
    		int min = Integer.MAX_VALUE;   
    		for(int i = 0; i < arr.length; i++){ 
    		     max = Math.max(max, arr[i]);     
    		     min = Math.min(min, arr[i]);   
    		 }    
    	//创建桶  
    	int bucketNum = (max - min) / arr.length + 1;   
    	ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);   
    	for(int i = 0; i < bucketNum; i++){     
    		bucketArr.add(new ArrayList<Integer>());   
    		}      //将每个元素放入桶   
    	for(int i = 0; i < arr.length; i++){    
    		int num = (arr[i] - min) / (arr.length);     
    		bucketArr.get(num).add(arr[i]);   }      
    	//对每个桶进行排序  
    	for(int i = 0; i < bucketArr.size(); i++){     
    		Collections.sort(bucketArr.get(i));   
    		}  
    	} 
    	}

图示：  
![在这里插入图片描述][20200101201825451.gif]

#### 复习去了…以后有机会再补上(\#.\#) ####

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019123020130210.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70
[20191230201710975.gif]: https://img-blog.csdnimg.cn/20191230201710975.gif
[20191230201954766.gif]: https://img-blog.csdnimg.cn/20191230201954766.gif
[20191230202446767.gif]: https://img-blog.csdnimg.cn/20191230202446767.gif
[2019123020284167.gif]: https://img-blog.csdnimg.cn/2019123020284167.gif
[20200101201628490.gif]: https://img-blog.csdnimg.cn/20200101201628490.gif
[20200101201825451.gif]: https://img-blog.csdnimg.cn/20200101201825451.gif