排序算法算法图解+java实现

最新推荐文章于 2025-03-05 19:46:25 发布

detachment_w

最新推荐文章于 2025-03-05 19:46:25 发布

阅读量932

点赞数

文章标签：算法排序算法

本文链接：https://blog.youkuaiyun.com/aha_jasper/article/details/105154962

版权

本文详细介绍了多种排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序、计数排序、基数排序和桶排序。每种排序算法的原理、代码实现及时间复杂度分析都有涉及。文章还强调了排序算法的稳定性，指出冒泡排序、插入排序、归并排序、计数排序、基数排序和桶排序是稳定的排序算法，而选择排序、快速排序、希尔排序和堆排序则不是。此外，文章还讨论了不同场景下选择排序算法的重要性，例如在排序范围有限时，计数排序和基数排序可以提供线性时间复杂度的高效解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

排序算法算法图解+java实现

总结

下面使用的图解资源来自于 我的第一本算法书，里面的内容都比较基础简单、容易理解，下面排序算法中有提及到的，大家不理解的可以自己下载，学习学习，我觉得算法还是很重要的，但是搞得全是概念的话，会让我们学渣觉得没啥意思，学霸就不要看了，再见来不及挥手，鬼刀一开看不见走位走位，直接看算法导论去吧。
链接：https://pan.baidu.com/s/1pykWDv36c4Itux3fJjjYsQ
提取码：xsul
希尔排序、计数排序、基数排序、桶排序都来自于趣谈编程的相关博客，因为觉得讲的比较简单生动，当然有兴趣的同学可以关注他，学习更多有趣的编程知识。

下面算法中用到的交换两个元素位置的swap方法，代码如下：

private static void swap(Object[] arr, int i, int j) {
   
    Object t = arr[i];
    arr[i] = arr[j];
    arr[j] = t;
}

冒泡排序

在这里插入图片描述

代码实现：

 public static void sort(Comparable[] arr){
   
        int n = arr.length;
        boolean swapped = false;

        do{
   
            swapped = false;
            for( int i = 1 ; i < n ; i ++ ){
   
           		 if( arr[i-1].compareTo(arr[i]) > 0 ){
   
                    swap( arr , i-1 , i );
                    swapped = true;
                }
            }
            // 优化, 每一趟Bubble Sort都将最大的元素放在了最后的位置
            // 所以下一次排序, 最后的元素可以不再考虑
            n --;
        }while(swapped);
}

进一步优化：

 public static void sort(Comparable[] arr){
   
        int n = arr.length;
        int newn; // 使用newn进行优化
        do{
   
            newn = 0;
            for( int i = 1 ; i < n ; i ++ ){
   
            	if( arr[i-1].compareTo(arr[i]) > 0 ){
   
                    swap( arr , i-1 , i );
                    // 记录最后一次的交换位置,在此之后的元素在下一轮扫描中均不考虑
                    newn = i;
                }
            }
            n = newn;
        } while(newn > 0);
}

选择排序

在这里插入图片描述

代码实现：

public static void sort(Comparable[] arr){
   
        int n = arr.length;
        for( int i = 0 ; i < n ; i ++ ){
   
            // 寻找[i, n)区间里的最小值的索引
            int minIndex = i;
            for( int j = i + 1 ; j < n ; j ++ ){
   
            	// 使用compareTo方法比较两个Comparable对象的大小
                if( arr[j].compareTo( arr[minIndex] ) < 0 ){
   
                	minIndex = j;
                }  
            }
            swap( arr , i , minIndex);
        }
}

进一步优化：

public static void sort(Comparable[] arr){
   
        int left = 0, right = arr.length - 1;
        while(left < right){
   
            int minIndex = left;
            int maxIndex = right;
            // 在每一轮查找时, 要保证arr[minIndex] <= arr[maxIndex]
            if(arr[minIndex].compareTo(arr[maxIndex]) > 0){
   
            	swap(arr, minIndex, maxIndex);
            }
            for(int i = left + 1 ; i < right; i ++){
   
                if(arr[i].compareTo(arr[minIndex]) < 0){
   
                 	minIndex = i;
                } else if(arr[i].compareTo(arr[maxIndex]) > 0){
   
                 	maxIndex = i;
                }
            }
            swap(arr, left, minIndex);
            swap(arr, right, maxIndex);
            left ++;
            right --;
        }
}

插入排序

在这里插入图片描述

代码实现：

public static void sort(Comparable[] arr){
   
        int n = arr.length;
        for (int i = 0; i < n; i++) {
   
            // 寻找元素arr[i]合适的插入位置
           
            // 写法1
            for( int j = i ; j > 0 ; j -- ){
   
                if( arr[j].compareTo( arr[j-1] ) < 0 ){
   
                    swap( arr, j , j-1 );
                } else{
   
                  	break;
                }
			}
			
            // 写法2
            for( int j = i; j > 0 && arr[j].compareTo(arr[j-1]) < 0 ; j--){
   
				swap(arr, j, j-1);
			}           

            // 写法3
            Comparable e = arr[i];
            int j = i;
            for( ; j > 0 && arr[j-1].compareTo(e) > 0 ; j--)
                arr[j] = arr[j-1];
            arr[j] = e;
        }
    }

希尔排序

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。

怎样可以对插入排序算法做出优化呢？我们不妨从插入排序的两个特点入手：
1.在大多数元素已经有序的情况下，插入排序的工作量较小
这个结论很明显，如果一个数组大部分元素都有序，那么数组中的元素自然不需要频繁地进行比较和交换。
2.在元素数量较少的情况下，插入排序的工作量较小
这个结论更加显而易见，插入排序的工作量和n的平方成正比，如果n比较小，那么排序的工作量自然要小得多。

如何对原始数组进行预处理呢？聪明的科学家想到了一种分组排序的方法，以此对数组进行一定的“粗略调整”。
在这里插入图片描述
所谓分组，就是让元素两两一组，同组两个元素之间的跨度，都是数组总长度的一半，也就是跨度为4。

如图所示，元素5和元素9一组，元素8和元素2一组，元素6和元素1一组，元素3和元素7一组，一共4组。

接下来，我们让每组元素进行独立排序，排序方式用直接插入排序即可。由于每一组的元素数量很少，只有两个，所以插入排序的工作量很少。每组排序完成后的数组如下：
在这里插入图片描述
这样一来，仅仅经过几次简单的交换，数组整体的有序程度得到了显著提高，使得后续再进行直接插入排序的工作量大大减少。这种做法，可以理解为对原始数组的“粗略调整”。

但是这样还不算完，我们可以进一步缩小分组跨度，重复上述工作。把跨度缩小为原先的一半，也就是跨度为2，重新对元素进行分组：
在这里插入图片描述
如图所示，元素5，1，9，6一组，元素2，3，8，7一组，一共两组。

接下来，我们继续让每组元素进行独立排序，排序方式用直接插入排序即可。每组排序完成后的数组如下：
在这里插入图片描述
此时，数组的有序程度进一步提高，为后续将要进行的排序铺平了道路。

最后，我们把分组跨度进一步减小，让跨度为1，也就等同于做直接插入排序。经过之前的一系列粗略调整，直接插入排序的工作量减少了很多，排序结果如下：
在这里插入图片描述
让我们重新梳理一下分组排序的整个过程：

像这样逐步分组进行粗调，再进行直接插入排序的思想，就是希尔排序，根据该算法的发明者，计算机科学家Donald Shell的名字所命名。