D7-排序算法[Java数据结构和算法]

Posted erfishing

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了D7-排序算法[Java数据结构和算法]相关的知识,希望对你有一定的参考价值。

1.快速排序(QuickSort)

   1.1 快速排序是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另一部分的所有数据都要小,然后再按照此方法对这两部分数据进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

技术图片

package cn.atguigu.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class QuickSort 

    public static void main(String[] args) 
        // TODO Auto-generated method stub
//        int[] arr= -9,78,0,23,-567,70;
        int[] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) 
            arr[i] = (int) (Math.random() * 8000);
        
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前时间" + date1Str);
        quickSort(arr, 0, arr.length - 1);

        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后时间" + date2Str);

//        System.out.println(Arrays.toString(arr));
    

    public static void quickSort(int[] arr, int left, int right) 
        int l = left;// 左下标
        int r = right;// 右下标
        int pivot = arr[(left + right) / 2];
        int temp = 0;
        // while循环的目的是让比pivot小的值放左边,大的值放右边
        while (l < r) 
            // 在pivot的左边一直找,找到大于pivot的数
            while (arr[l] < pivot) 
                l += 1;
            
            // 在pivot的右边一直找,找到小于pivot的数
            while (arr[r] > pivot) 
                r -= 1;
            
            // 如果l>=r说明pivot的左右两的值,已将按照左边全部小于pivot值,右边全部大于pivot的值
            if (l >= r) 
                break;
            

            // 交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            // 交换完后,发现arr[l]==pivot,r--,前移
            if (arr[l] == pivot) 
                r -= 1;
            
            if (arr[r] == pivot) 
                l += 1;
            

        
        // 如果l==r,必须l++,r--,否则必须栈溢出
        if (l == r) 
            l += 1;
            r -= 1;
        
        // 向左递归
        if (left < r) 
            quickSort(arr, left, r);
        
        // 向右递归
        if (right > l) 
            quickSort(arr, l, right);
        
    

 

2.归并排序(MergeSort)

   2.1 利用归并的思想实现排序,该算法采用经典的分治策略(divide-and-conquer)

技术图片

技术图片

  2.2 源代码

package cn.atguigu.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class MergeSort 
    public static void main(String[] args) 
//        int[] arr= 8,4,5,7,1,3,6,2;
        int[] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) 
            arr[i] = (int) (Math.random() * 8000);
        
        int temp[]=new int[arr.length];//归并排序需要额外的空间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前时间" + date1Str);
        
        
        mergeSort(arr, 0, arr.length-1, temp);
        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后时间" + date2Str);

//        System.out.println("归并排序后:"+Arrays.toString(arr));
    
    //分+合的方法
    public static void mergeSort(int[] arr,int left,int right,int[] temp) 
        if(left<right) 
            int mid=(left+right)/2;//中间索引
            //向左进行分解
            mergeSort(arr, left, mid, temp);
            //向右进行分解
            mergeSort(arr, mid+1, right, temp);
            //到合并
            merge(arr, left, mid, right, temp);
        
    
    
    //合并的方法
    /**
     * 
     * @param arr 排序的数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp 做中转的数组
     */
    public static void merge(int[] arr,int left,int mid,int right,int[]temp) 
        int i=left;//初始化i,左边有序序列的 初始索引
        int j=mid+1;//初始化j,右边序列的初始索引
        int t=0;//指向temp数组的当前索引
        //先把左右两边的数据按照规则填充到temp数组,直到左右两边的有序序列有一方处理完毕
        while(i<=mid&&j<=right) 
            if(arr[i]<=arr[j]) 
                temp[t]=arr[i];
                i++;
            else 
                temp[t]=arr[j];
                j++;
            
            t++;
        
        
        //将剩余数据的一方的数据一次全部填充到temp
        while (i <= mid) 
            temp[t] = arr[i];
            t++;
            i++;
        
        while (j <= right) 
            temp[t] = arr[j];
            t++;
            j++;
        

        //将temp数组的元素全部拷贝到arr
        t=0;
        int tempLeft=left;
        while(tempLeft<=right) 
            arr[tempLeft]=temp[t];
            t++;
            tempLeft++;
        
    

 

3.基数排序又叫桶排序(radixSort)

  3.1 属于分配式排序(distribution sort),通过键值的各个位的值,将要排序的元素分配至某些“桶”中,达到排序的作用,算法属于稳定性的排序,基数排序法是效率高的稳定性排序法

  基数排序是桶排序的扩展,将整数按位数切割成不同的数字,然后每个位数分别比较。

  3.2 将所有带比较数值统一为同样的数位长度,数位较短的数前面补0。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

  第1轮排序:

    (1)将每个元素的个位数取出,然后看这个数应该放在哪个对应的桶(一个一维数组)

    (2)按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)

  第2轮排序:

    (1)将每个元素的十位数取出,然后看这个数应该放在哪个对应的桶(一个一维数组)

    (2)按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)

  第3轮排序:

    (1)将每个元素的百位数取出,然后看这个数应该放在哪个对应的桶(一个一维数组)

    (2)按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)

  3.3 源代码

package cn.atguigu.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class radixSort 

    public static void main(String[] args) 
        // TODO Auto-generated method stub
//        int[] arr= 53,3,542,748,14,214;
        
        int[] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) 
            arr[i] = (int) (Math.random() * 80000);
        
        int temp[]=new int[arr.length];//归并排序需要额外的空间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前时间" + date1Str);
        radixSort(arr);
        
        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后时间" + date2Str);

        
    

    public static void radixSort(int[] arr) 
        //最终代码        
        //1.得到数组中的最大的数的位数
        int max=arr[0];//假设第一个数就是最大数
        for(int i=0;i<arr.length;i++) 
            if(arr[i]>max) 
                max=arr[i];
            
        
        //得到最大数是几位数
        int maxLength=(max+"").length();        
        //使用循环代码处理    
        //定义一个二维数组,表示10个桶,每个桶就是一个一维数组
        //说明
        //1.二维数组包含10个一维数组
        //2.为了防止在放入数的时候,数据溢出,则每一个一维数组,大小定位arr.length
        //3.明确基数排序是使用空间换时间的经典算法
        int[][] bucket=new int[10][arr.length];        
        //为了记录每个桶中,实际存放了多少个数据,我们定义一个一维数组记录各个桶的每次放入的数据个数
        //可以这样理解
        //比如:bucketElementCounts[0],记录的就是bucket[0]桶的放入数据
        int[] bucketElementCounts=new int[10];
        
        for(int i=0,n=1;i<maxLength;i++,n*=10) 
            
            for (int j = 0; j < arr.length; j++) 
                //取出每个元素的个数
                int digitOfElement=arr[j]/n%10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
                bucketElementCounts[digitOfElement]++;    
            
            //按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
            int index=0;
            //遍历每一个桶,并将桶中的数据,放入到原来的数组
            for(int k=0;k<bucketElementCounts.length;k++) 
                //如果桶中,有数据,我们才放入到数组
                if(bucketElementCounts[k]!=0) 
                    //循环该桶即第k个桶(第k个一维数组),放入
                    for(int l=0;l<bucketElementCounts[k];l++) 
                        //取出元素放入到arr
                        arr[index]=bucket[k][l];
                        index++;
                    
                
                //第i+1轮处理后,需要将每个bucketElementCounts[k]置0
                bucketElementCounts[k]=0;
            
//            System.out.println("第"+i+"轮,对个位的排序"+Arrays.toString(arr));
        
    

 

 

4.排序算法时间复杂度比较

   4.1 相关术语解释:

  (1)稳定:如果a原本在b前面,而a=b,排序后a仍然在b的前面;

  (2)不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;

  (3)内排序:所有排序操作都在内存中完成;

  (4)外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;

  (5)时间复杂度:一个算法执行所耗费的时间;

  (6)空间复杂度:运行完一个程序所需要内存的大小;

  (7)n:数据规模

  (8)k:“桶”的个数

  (9)In-space:不占用额外内存

  (10)Out-space:占用额外内存

  4.2 常用算法对比

排序算法 平均时间复杂度 最好情况 最坏情况 空间复杂度 排序方式 稳定性
冒泡排序 O(n2) O(n) O(n2) O(1) In-space 稳定
选择排序 O(n2) O(n2) O(n2) O(1) In-space 不稳定
插入排序 O(n2) O(n) O(n2) O(1) In-space 稳定
希尔排序 O(n log n) O(n log2 n) O(n log2 n) O(1) In-space 不稳定
归并排序 O(n log n) O(n log n) O(n log n) O(n) Out-space 稳定
快速排序 O(n log n) O(n log n) O(n2) O(log n) In-space 不稳定
堆排序 O(n log n) O(n log n) O(n log n) O(1) In-space 不稳定
计数排序 O(n+k) O(n+k) O(n+k) O(k) Out-space 稳定
桶排序 O(n+k) O(n+k) O(n2) O(n+k) Out-space 稳定
基数排序 O(n*k) O(n*k) O(n*k) O(n+k) Out-space 稳定

以上是关于D7-排序算法[Java数据结构和算法]的主要内容,如果未能解决你的问题,请参考以下文章

Java数据结构和算法——冒泡选择插入排序算法

Java数据结构和算法:常用排序算法与经典题型

Java算法 选择排序算法 -- 选择排序算法的非递归和递归形式实现

Java排序算法分析与实现:快排冒泡排序选择排序插入排序归并排序

排序算法之冒泡选择插入排序(Java)

排序算法之冒泡选择插入排序(Java)