排序总结-常用排序算法Java实现

关注

原创最新推荐文章于 2026-05-06 15:35:33 发布 266 阅读 AI 写同款· GEO 优化 ›

Java排序算法大全：实现常用的排序算法 排序算法是计算机科学中常用的重要算法之一，它可以将一组元素按照特定的顺序进行排列。在Java编程中，我们经常需要使用排序算法对数据进行排序，以便更方便地进行查找和处理。本文将介绍几种常用的排序算法，并提供相应的Java代码实现。以上是四种常用的排序算法的Java实现。在实际应用中，根据排序数据的规模和特点，选择合适的排序算法可以提高程序的效率和性能。除了上述介绍的排序算法，还有许多其他排序算法，如归并排序、堆排序等，读者可以进一步研究和实践。希望本文对你理解和实践Java中的排序算法有所帮助！阅读详情

排序总结

稳定

sort	最差时间	最好时间	平均时间	稳定	空间复杂度
冒泡排序	O(n^2)	O(n)	O(n^2)	稳定	O(1)
插入排序	O(n^2)	O(n)	O(n^2)	稳定	O(1)
二叉树排序	O(n^2)	O(nlogn)	O(nlogn)	稳定	O(n)
归并排序l	O(nlogn)	O(nlogn)	O(nlogn)	稳定	O(n)

不稳定

sort	最差时间	最好时间	平均时间	稳定	空间复杂度
选择排序	O(n^2)	O(n^2)	O(n^2)	不稳定	O(1)
快排	O(n^2)	O(nlogn)	O(nlogn)	不稳定	O(logn~ O(n))
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	不稳定	O(1)
希尔排序	O(n^2)			不稳定	O(1)

冒泡排序(Bubble Sort)

它是一种较简单的排序算法。它会遍历若干次要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列的末尾！采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此操作，直到整个数列都有序为止！
在这里插入图片描述

/*
 * a -- 待排序的数组
 * n -- 数组的长度
 */
public static void bubbleSort(int[] a, int n) {
    int i,
    j;
    for (i = n - 1; i > 0; i--) {
        // 将a[0...i]中最大的数据放在末尾
        for (j = 0; j < i; j++) {
            if (a[j] > a[j + 1]) {
                // 交换a[j]和a[j+1]
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
            }
        }
    }
}


运行：
int[] a = {20,40,30,10,60,50,70};
String aa = "冒泡排序";
bubbleSort(a, a.length);
System.out.print(aa);
for (int d: a) {
    System.out.print(d + ",");
}

选择排序和插入排序都是在冒泡基础上的演进：
选择排序：选出最小的值放入列表，选完即可
直接插入排序：左侧为有序队列，从右侧遍历的数字在放入左侧有序队列时排序插入。

直接插入排序(Straight Insertion Sort)

/**
 * @param 
 * a -- 待排序的数组
 * n -- 数组的长度
 */
public static void insertSort(int[] a, int n) {
    int i,j,k;
    for (i = 1; i < n; i++) {
    	//a[i]为右侧遍历出的待插数据
        //在有序队列a[0,i]中为a[i]在前面的a[0...i-1]有序区间中找一个合适的位置
        for (j = i - 1; j >= 0; j--) if (a[j] < a[i]) break;//从大到小找到比i小的值j即可终止
        //如找到了一个合适的位置, 把整个数组下标大于j的值都往后移动一个空位给i使用
        if (j != i - 1) {
            //将比a[i]大的数据向后移
            int temp = a[i];
            for (k = i - 1; k > j; k--) a[k + 1] = a[k];
            //将a[i]放到正确位置上
            a[k + 1] = temp;
        }
    }
}

和冒泡的规则相同，双重for循环找到最最小值

快速排序(Quick Sort)

使用分治法策略
它的基本思想是：选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

快速排序流程：
1.从数列中挑出一个基准值放入x。
2.将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)；在这个分区退出之后，该基准就处于数列的中间位置（把x赋值给中间值，完成一轮互换）。
3.递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。

图文介绍
在这里插入图片描述

/**
 *
 * 参数说明：
 * a -- 待排序的数组
 * l -- 数组的左边界(例如，从起始位置开始排序，则l=0)
 * r -- 数组的右边界(例如，排序截至到数组末尾，则r=a.length-1)
 */
public static void quickSort(int[] a, int l, int r) {
    if (l < r) {
        int i,j, x;
        i = l;
        j = r;
        x = a[i];
        while (i < j) {
            while (i < j && a[j] > x) j--; // 从右向左找第一个小于x的数
            if (i < j) a[i++] = a[j];
            while (i < j && a[i] < x) i++; // 从左向右找第一个大于x的数
            if (i < j) a[j--] = a[i];
        }
        a[i] = x;//最后把基准值赋值给中间值，完成一轮替换
         /* 递归调用 */
        quickSort(a, l, i - 1);//把中间值左侧数据排序
        quickSort(a, i + 1, r);//右侧数据排序
        /* 递归调用 */
    }
}


//运行
 String aa = "快速排序";
 quickSort(a,0,a.length-1);
 System.out.print(aa);
 for (int d : a) {
 System.out.print(d+",");
 }

希尔排序shell sort

希尔(Shell)排序又称为缩小增量排序，它是一种插入排序。它是直接插入排序算法的一种威力加强版。该方法因DL．Shell于1959年提出而得名。

希尔排序的基本思想是：
1.把记录按步长 gap 分组，对每组记录采用直接插入排序方法进行排序。
2.随着步长逐渐减小，所分成的组包含的记录越来越多，当步长的值减小到 1 时，整个数据合成为一组，构成一组有序记录，则完成排序。

看图配合步骤讲解，第一次gap=5,每隔gap个元素为一组比大小；gap不断对折，直到gap=1完成排序。
在这里插入图片描述
初始时，有一个大小为 10 的无序序列。

在第一趟排序中，我们不妨设 gap1 = N / 2 = 5，即相隔距离为 5 的元素组成一组，可以分为 5 组。接下来，按照直接插入排序的方法对每个组进行排序。

在第二趟排序中，我们把上次的 gap 缩小一半，即 gap2 = gap1 / 2 = 2 (取整数)。这样每相隔距离为 2 的元素组成一组，可以分为 2 组。按照直接插入排序的方法对每个组进行排序。

在第三趟排序中，再次把 gap 缩小一半，即gap3 = gap2 / 2 = 1。这样相隔距离为 1 的元素组成一组，即只有一组。按照直接插入排序的方法对每个组进行排序。此时，排序已经结束。

需要注意一下的是，图中有两个相等数值的元素 5 和 5 。我们可以清楚的看到，在排序过程中，两个元素位置交换了。

所以，希尔排序是不稳定的算法。

/**
 * 希尔排序
 * @param list
 */
 public static void shellSort(int[] a) {
	 int gap = a.length / 2; //初始对折=步长
	 while (1 <= gap) {
		 // 把距离为 gap 的元素编为一个组，扫描所有组
		 for (int i = gap; i < a.length; i++) {
			 int j = 0;
			 int temp = a[i];
			 // 对距离为 gap 的元素组进行排序,每隔gap个为一组对比大小
			 for (j = i - gap; j >= 0 && temp < a[j]; j = j - gap) {
			 	a[j + gap] = a[j];
			 }
			 a[j + gap] = temp;
		 }
		 System.out.format("gap = %d:\t", gap);
		 printAll(a);
		 gap = gap / 2; // 减小增量
	 }
}
	 // 打印完整序列
 public static void printAll(int[] a) {
	 for (int value : a) {
	 System.out.print(value + "\t");
	 }
	 System.out.println();
 }

归并排序

基本思想
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

分而治之
在这里插入图片描述
和希尔排序的思想视乎有些相似，都是对折分组
可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。

每个小组最后都要面对的一步：合并相邻有序子序列
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
在这里插入图片描述
思路：创建一个两个数组长度之和的临时数组temp，两个数组对比，谁小就放入temp中。对比完成

public class MergeSort {
 public static void main(String []args){
	 int []arr = {9,8,7,6,5,4,3,2,1};
	 sort(arr);
	 System.out.println(Arrays.toString(arr));
 }

 public static void sort(int []arr){
	 int []temp = new int[arr.length];
	 //在排序前，先建好一个长度等于原数组长度的临时数组，
	 //避免递归中频繁开辟空间
	 sort(arr,0,arr.length-1,temp);
 }
 
 private static void sort(int[] arr,int left,int right,int []temp){
	 if(left<right){
		 int mid = (left+right)/2;
		 sort(arr,left,mid,temp);//递归调用：左边归并排序，使得左子序列有序
		 sort(arr,mid+1,right,temp);//递归调用：右边归并排序，使得右子序列有序
		 merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
	 }
 }
 private static void merge(int[] arr,int left,int mid,int right,int[] temp){
	 int i = left;//左序列指针
	 int j = mid+1;//右序列指针
	 int t = 0;//临时数组指针
	 while (i<=mid && j<=right){
		 if(arr[i]<=arr[j]){
		 	temp[t++] = arr[i++];
		 }else {
			 temp[t++] = arr[j++];
		 }
	 }
	 while(i<=mid){//将左边剩余元素填充进temp中
	 temp[t++] = arr[i++];
	 }
	 while(j<=right){//将右序列剩余元素填充进temp中
	 temp[t++] = arr[j++];
	 }
	 t = 0;
	 //将temp中的元素全部拷贝到原数组中
	 while(left <= right){
	 arr[left++] = temp[t++];
	 }
 }
}

堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。

完全二叉树：除了最后一层之外的其他每一层都被完全填充，并且所有结点都保持向左对齐。
满二叉树：除了叶子结点之外的每一个结点都有两个孩子，每一层(当然包含最后一层)都被完全填充。
完满二叉树：除了叶子结点之外的每一个结点都有两个孩子结点。

完全二叉树(Complete Binary Tree)：
在这里插入图片描述
满二叉树(Perfect Binary Tree)：

完满二叉树(Full Binary Tree)：

参考资料：
http://www.cnblogs.com/idorax/p/6441043.html

堆排序是将数据看成是完全二叉树、根据完全二叉树的特性来进行排序的一种算法
最大堆要求节点的元素都要不小于其孩子，
最小堆要求节点元素都不大于其左右孩子
处于最大堆的根节点的元素一定是这个堆中的最大值

完全二叉树有个特性：
左边子节点位置 = 当前父节点的两倍 + 1
右边子节点位置 = 当前父节点的两倍 + 2

节点的关系和节点编号和数组下标对象的下标关系：
在这里插入图片描述

排序过程
第一步：先n个元素的无序序列，构建成大顶堆
第二步：将根节点与最后一个元素交换位置，（将最大元素"沉"到数组末端）
第三步：交换过后可能不再满足大顶堆的条件，所以需要将剩下的n-1个元素重新构建成大顶堆
第四步：重复第二步、第三步直到整个数组排序完成
在这里插入图片描述

/**
     * 建堆
     *
     * @param arrays          看作是完全二叉树
     * @param currentRootNode 当前父节点位置
     * @param size            节点总数
     */
    public static void heapify(int[] arrays, int currentRootNode, int size) {

       if (currentRootNode < size) {
           //左子树和右字数的位置
           int left = 2 * currentRootNode + 1;
           int right = 2 * currentRootNode + 2;

           //把当前父节点位置看成是最大的
           int max = currentRootNode;

           if (left < size) {
               //如果比当前根元素要大，记录它的位置
               if (arrays[max] < arrays[left]) {
                   max = left;
               }
           }
           if (right < size) {
               //如果比当前根元素要大，记录它的位置
               if (arrays[max] < arrays[right]) {
                   max = right;
               }
           }
           //如果最大的不是根元素位置，那么就交换
           if (max != currentRootNode) {
               int temp = arrays[max];
               arrays[max] = arrays[currentRootNode];
               arrays[currentRootNode] = temp;

               //继续比较，直到完成一次建堆
               heapify(arrays, max, size);
           }
       }
   }



  /**
    * 完成一次建堆，最大值在堆的顶部(根节点)
    */
   public static void maxHeapify(int[] arrays, int size) {

       // 从数组的尾部开始，直到第一个元素(角标为0)
       for (int i = size - 1; i >= 0; i--) {
           heapify(arrays, i, size);
       }

   }

	//堆排序入口
public static void heapSort(int[] arrays) {
	for (int i = 0; i < arrays.length; i++) {
        //每次建堆就可以排除一个元素了
        maxHeapify(arrays, arrays.length - i);
        //把顶部最大值放到数组最后面
        int temp = arrays[0];
        arrays[0] = arrays[(arrays.length - 1) - i];
        arrays[(arrays.length - 1) - i] = temp;
    }
}