Java实现排序算法：插入排序，交换排序，归并排序，基数排序

最新推荐文章于 2022-10-10 17:40:13 发布

微风星雨

最新推荐文章于 2022-10-10 17:40:13 发布

阅读量266

点赞数

文章标签： Java 算法排序

本文链接：https://blog.csdn.net/baidu_38290612/article/details/79763955

版权

提要

简要介绍四种排序算法：交换排序（含快速排序，冒泡排序），插入排序（含直接插入排序，希尔排序），归并排序，基数排序

※常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log₂n)＜Ο(n)＜Ο(nlog₂n)＜Ο(n²)＜Ο(n³)＜…＜Ο(2ⁿ)＜Ο(n!)

一、交换排序

（1）快速排序（Quick Sort）

背景：

由C.A. R. Hoare（东尼霍尔，Charles Antony Richard Hoare）在1962年提出。他是英国计算机科学家，图灵奖得主。他设计出了快速排序算法、霍尔逻辑、交谈循序程式。

定义：

从待排序的数据序列中任取一个数据(如第一个数据)作为分界值，所有比它小的数据元素放到左边，所有比它大的数据元素放到它的右边。

接下来，对左右两个子序列按照上述方法进行递归排序，直到排序完成。

复杂度分析：

平均时间：O(nlog₂n) 最坏时间：O(n²)

排序方法	时间复杂度			空间复杂度	稳定性	复杂性
	平均情况	最坏情况	最好情况
快速排序	O(nlog₂n)	O(n²)	O(nlog₂n)	O(log₂n)	不稳定	较复杂

选取基准p的时候，每次选取的都是当前数组中最小的一个元素，那么每次划分都只是让数组中的元素少1（被筛选出来的那个元素当然有序），这样一来就需要反复遍历数组导致复杂度变成了O(n²)。

选取基准p的时候，每次选取的都是当前数组中最中间的一个元素（是中位数，而不是元素位置上的中间），那么每次划分都把当前数组划分成了长度相等的两个子数组，这样一来复杂度变成了O(nlog₂n)。

Java代码实现：

package sort;

public class QuickSort {

	public static void main(String[] args) {
		int[] a = { 22, 55, 11, 66, 88, 77, 44, 99, 33 };
		quickSort(a, 0, a.length - 1);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "  ");
		}
	}

	public static void quickSort(int[] array, int start, int end) {
		if (start >= end) {
			return; // 结束方法
		}
		int data = array[start]; // 将起始索引执行的值作为“分界值”
		int i = start + 1; // 记录向右移动的位置（“红军”）
		int j = end; // 记录向左移动的位置("蓝军")
		while (true) {
			while (i <= end && array[i] < data) {
				i++; // 索引右移
			}
			while (j >= start + 1 && array[j] > data) {
				j--; // 索引左移
			}
			if (j > i) {
				int temp = array[i];
				array[i] = array[j];
				array[j] = temp;
			} else {
				break;
			}
		}
		// “蓝军”与“分界值”交换位置
		array[start] = array[j];
		array[j] = data;
		quickSort(array, start, j - 1); // 递归调用完成“分界值”左边的排序
		quickSort(array, j + 1, end); // 递归调用完成“分界值”右边的排序
	}

}

（2）冒泡排序（Bubble Sort）

定义：

共有n个数据，则需要进行n-1趟排序(可优化)，每一趟排序都会通过“两两交换”的方式对数据进行比较，每一趟排序后都会将本趟排序的最大值“冒”到后面。

复杂度分析：

从简单选择排序的过程来看，它最大的特点是交换移动数据次数相当少，这样就节约了相应的时间。分析它的时间复杂度发现，无论是最好最差情况，其比较次数都是一样多，第 i 趟排序需要进行 n-i 次关键字比较，此时需要比较次，对于交换次数而言，当最好的时候，交换0次，最差的时候，也就是初始降时，交换次数为 n-1 次，基于最终的时间排序与交换次数总和，因此，总的时间复杂度依然为。

尽管与冒泡排序同为，但简单选择排序的性能要优于冒泡排序。

Java代码实现：

package sort;

public class BubbleSort {

	public static void main(String[] args) {
		int[] a = { 22, 55, 11, 66, 88, 77, 44, 99, 33 };
		bubbleSort(a);
	}

	public static void bubbleSort(int[] a) {
		for (int i = 1; i <= a.length - 1; i++) { // 外层循环控制比较的“趟数”
			// 开始第i趟排序
			boolean flag = true;

			for (int j = 0; j < a.length - i; j++) { // j变量是数组的索引(下标)，j也控制着当前趟的“两两比较”的次数
				if (a[j] > a[j + 1]) {
					int temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
					flag = false;
				}
			}
			// 第i趟结束
			if (flag) { // 如果当前“趟”已经排号序，则不必进行下一趟的排序，直接跳出外层循环
				break;
			}
			/**
			 * //第i趟排序结果如下 for(int x:a){ System.out.print(x+"  "); }
			 **/
		}
	}

}

二、插入排序(Insertion Sort)

（1）直接插入排序(Straight Insertion Sort)

定义：

对一个有n个元素的数据序列，排序需要进行n-1趟插入操作(可优化)。

第一趟插入将第2个元素插入前面的有序子序列(此时前面只有一个元素)。

第二趟插入将第3个元素插入前面的有序子序列，前面两个元素是有序的。

第n-1趟插入将第n个元素插入前面的有序子序列，前面n-1个元素是有序的。

复杂度分析：

当问题规模为n时。

最好情况（原本就是有序的）
比较次数：Cmin=n-1
移动次数：Mmin=0
最差情况（逆序）
比较次数：Cmax=2+3+4+……+n=(n+2)n/2
移动次数：Mmax=1+2+3+……+n-1=n*n/2

若待排序对象序列中出现各种可能排列的概率相同，则可取上述最好情况和最坏情况的平均情况。在平均情况下的关键字比较次数和对象移动次数约为 n²/2。因此，直接插入排序的时间复杂度为 o(n²)。

Java代码实现：

package sort;

public class InsertSort {

	public static void main(String[] args) {
		int[] a = { 22, 55, 11, 66, 88, 77, 44, 99, 33 };
		insertSort(a);
		// 插入排序的结果如下
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "  ");
		}
	}

	public static void insertSort(int[] a) {
		for (int i = 1; i <= a.length - 1; i++) {
			int data = a[i]; // 当前“指示灯数据”
			int j = i - 1; // 使用j变量记录“指示灯数据”的前一个数据的索引
			while (j >= 0 && data < a[j]) {
				a[j + 1] = a[j]; // 后移“指示灯”数据前面的数据
				j--;
			}
			a[j + 1] = data;
		}
	}

}

（2）希尔排序（Shell`s Sort）

定义：

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

按增量序列个数k，对序列进行k 趟排序；

每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

背景：

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序，是直接插入排序算法的一种更高效的改进版本，是非稳定排序算法。

复杂度分析：

时间复杂度

O(n^1.3)

空间复杂度

O(1)

稳定性

不稳定

Java代码实现：

package sort; 

public class ShellSort {  

  
    public static void main(String[] args) {  
        int a[] = {3,1,5,7,2,4,9,6,10,8};    
        ShellSort  obj=new ShellSort();  
        System.out.println("初始值：");  
        obj.print(a);  
        obj.shellSort(a);  
        System.out.println("\n排序后：");  
        obj.print(a);  
  
    }  
    private void shellSort(int[] a) {  
         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;//插入  
            }  
                  
        }  
          
    }  
    public void print(int a[]){  
        for(int i=0;i<a.length;i++){  
            System.out.print(a[i]+" ");  
        }  
    }  
}

三、归并排序（Merge sort）

定义：

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾

将另一序列剩下的所有元素直接复制到合并序列尾背景

复杂度分析：

时间复杂度

归并的时间复杂度分析：主要是考虑两个函数的时间花销，一、数组划分函数mergeSort()；二、有序数组归并函数_mergeSort()；

_mergeSort()函数的时间复杂度为O(n)，因为代码中有2个长度为n的循环（非嵌套），所以时间复杂度则为O(n)；

简单的分析下元素长度为n的归并排序所消耗的时间 T[n]：调用mergeSort()函数划分两部分，那每一小部分排序好所花时间则为 T[n/2]，而最后把这两部分有序的数组合并成一个有序的数组_mergeSort()函数所花的时间为 O(n)；

公式：T[n] = 2T[n/2] + O(n)；

得出的结果为：T[n] = O( nlogn )

该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )。

空间复杂度

归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)

Java代码实现：

package sort;
 
public class MergeSort {
    //　private　static　long　sum　=　0;
     * 　*　@param　s
     * 　*　第一个有序表的起始下标
     * 　*　@param　m
     * 　*　第二个有序表的起始下标
     * 　*　@param　t
     * 　*　第二个有序表的结束小标
     */
    private static void merge(int[] a, int s, int m, int t) {
        int[] tmp = new int[t - s + 1];
        int i = s, j = m, k = 0;
        while (i < m && j <= t) {
            if (a[i] <= a[j]) {
                tmp[k] = a[i];
                k++;
                i++;
            } else {
                tmp[k] = a[j];
                j++;
                k++;
            }
        }
        while (i < m) {
            tmp[k] = a[i];
            i++;
            k++;
        }
        while (j <= t) {
            tmp[k] = a[j];
            j++;
            k++;
        }
        System.arraycopy(tmp, 0, a, s, tmp.length);
    }
 
    /**
     * 　*　@param　len
     * 　*　每次归并的有序集合的长度
     */
    public static void mergeSort(int[] a, int s, int len) {
        int size = a.length;
        int mid = size / (len << 1);
        int c = size & ((len << 1) - 1);
        //　-------归并到只剩一个有序集合的时候结束算法-------//
        if (mid == 0)
            return;
        //　------进行一趟归并排序-------//
        for (int i = 0; i < mid; ++i) {
            s = i * 2 * len;
            merge(a, s, s + len, (len << 1) + s - 1);
        }
        //　-------将剩下的数和倒数一个有序集合归并-------//
        if (c != 0)
            merge(a, size - c - 2 * len, size - c, size - 1);
        //　-------递归执行下一趟归并排序------//
        mergeSort(a, 0, 2 * len);
    }
 
    public static void main(String[] args) {
        int[] a = new int[]{4, 3, 6, 1, 2, 5};
        mergeSort(a, 0, 1);
        for (int i = 0; i < a.length; ++i) {
            System.out.print(a[i] + "　");
        }
    }
}

四、基数排序(Radix Sort)

定义：

将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是比较排序，他不受到 O(n log n) 下限的影响。
简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。

例如要对大小为[1..1000]范围内的n个整数A[1..n]排序

首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储 (10..20]的整数，……集合B[i]存储( (i-1)*10, i*10]的整数，i = 1,2,..100。总共有 100个桶。

然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任何排序法都可以。

最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这样就得到所有数字排好序的一个序列了。

复杂度分析：

排序方法	时间复杂度			空间复杂度	稳定性	复杂性
	平均情况	最坏情况	最好情况
基数排序	O(d*(n+r))	O(d*(n+r))	O(d*(n+r))	O(n+r)	稳定	较复杂

其中，d 为位数，r 为基数，n 为原数组个数。
在基数排序中，因为没有比较操作，所以在复杂上，最好的情况与最坏的情况在时间上是一致的，均为 O(d * (n + r))。

Java代码实现：

package sort;

public class RadixSort
{
    public static void sort(int[] number, int d) //d表示最大的数有多少位
    {
        intk = 0;
        intn = 1;
        intm = 1; //控制键值排序依据在哪一位
        int[][]temp = newint[10][number.length]; //数组的第一维表示可能的余数0-9
        int[]order = newint[10]; //数组orderp[i]用来表示该位是i的数的个数
        while(m <= d)
        {
            for(inti = 0; i < number.length; i++)
            {
                intlsd = ((number[i] / n) % 10);
                temp[lsd][order[lsd]] = number[i];
                order[lsd]++;
            }
            for(inti = 0; i < 10; i++)
            {
                if(order[i] != 0)
                    for(intj = 0; j < order[i]; j++)
                    {
                        number[k] = temp[i][j];
                        k++;
                    }
                order[i] = 0;
            }
            n *= 10;
            k = 0;
            m++;
        }
    }
    public static void main(String[] args)
    {
        int[]data =
        {73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100};
        RadixSort.sort(data, 3);
        for(inti = 0; i < data.length; i++)
        {
            System.out.print(data[i] + "");
        }
    }
}

微风星雨

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java实现排序算法：插入排序，交换排序，归并排序，基数排序

提要简要介绍四种排序算法：交换排序（含快速排序，冒泡排序），插入排序（含直接插入排序，希尔排序），归并排序，基数排序※常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!) 一、交换排序（1）快速排序（Quick Sort）背景：由C.A. R. Hoare（东尼霍尔，Charles Antony Richa...
复制链接

扫一扫