• 三种排序算法


    一、冒泡排序

    package com.light.springboot.algorithm;
    
    import com.alibaba.fastjson.JSON;
    
    public class SortMaopao {
    
    	public static void main(String[] args) {
    		int[] intArray = {0,1,2,3,4};
    		System.out.println(JSON.toJSON(maopaoSort(intArray)));
    	}
    	
    	/**
    	 * 冒泡排序法
    	 * 冒泡排序是由两个for循环构成,第一个for循环的变量 i 表示总共需要多少轮比较,第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1,......,length-i】
    	 * 因为每轮比较都会出现一个最大值放在最右边,所以每轮比较后的元素个数都会少一个,这也是为什么 j 的范围是逐渐减小的。相信大家理解之后快速写出一个冒泡排序并不难。
    	 * @param array
    	 * @return
    	 */
    	public static int[] maopaoSort(int[] array){
    		int count = 0;//排序轮数
    		boolean flag = true;//设定一个标记,若为true,则表示此次循环没有进行交换,也就是待排序列已经有序,排序已经完成。
    		
    		//i为一共要比较多少轮
    		for (int i = 1; i < array.length; i++) {
    			
    			//j为参与比较的数组下标范围,每比较一轮,最大值放在最右边,下一轮参与比较的元素就减一
    			for (int j = 0; j < array.length-i; j++) {
    				
    				//如果前面的数比后面的大,就交换两个数据的位置
    				if (array[j] > array[j+1]) {
    					int tmp = array[j];
    					array[j] = array[j+1];
    					array[j+1]=tmp;
    					flag = false;//有交换,说明比较没完成
    				}
    			}
    			count++;//计数
    			
    			//flag为true,说明本轮比较无交换,排序已完成
    			if (flag) {
    				break;
    			}
    		}
    		System.out.println("排序" + count + "轮");
    		return array;
    	}
    }
    

      

    冒泡排序解释:

      冒泡排序是由两个for循环构成,第一个for循环的变量 i 表示总共需要多少轮比较,第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1,......,length-i】,因为每轮比较都会出现一个最大值放在最右边,所以每轮比较后的元素个数都会少一个,这也是为什么 j 的范围是逐渐减小的。相信大家理解之后快速写出一个冒泡排序并不难。

      冒泡排序性能分析:

      假设参与比较的数组元素个数为 N,则第一轮排序有 N-1 次比较,第二轮有 N-2 次,如此类推,这种序列的求和公式为:

      (N-1)+(N-2)+...+1 = N*(N-1)/2

      当 N 的值很大时,算法比较次数约为 N2/2次比较,忽略减1。

      假设数据是随机的,那么每次比较可能要交换位置,可能不会交换,假设概率为50%,那么交换次数为 N2/4。不过如果是最坏的情况,初始数据是逆序的,那么每次比较都要交换位置。

      交换和比较次数都和N2 成正比。由于常数不算大 O 表示法中,忽略 2 和 4,那么冒泡排序运行都需要 O(N2) 时间级别。

      其实无论何时,只要看见一个循环嵌套在另一个循环中,我们都可以怀疑这个算法的运行时间为 O(N2)级,外层循环执行 N 次,内层循环对每一次外层循环都执行N次(或者几分之N次)。这就意味着大约需要执行N2次某个基本操作。

    二、选择排序

    package com.light.springboot.algorithm;
    
    /**
     * 选择排序法
     * 一共排i轮,第 i 轮选出 i 之后最小的值,放在第i个位置
     * 选择排序和冒泡排序执行了相同次数的比较:N*(N-1)/2,但是至多只进行了N次交换。
     * 当 N 值很大时,比较次数是主要的,所以和冒泡排序一样,用大O表示是O(N2) 时间级别。但是由于选择排序交换的次数少,所以选择排序无疑是比冒泡排序快的。
     * 当 N 值较小时,如果交换时间比选择时间大的多,那么选择排序是相当快的。
     * @author qiaozhong
     *
     */
    public class Sortxuanze {
    	public static void main(String[] args) {
    		int[] intArray = {0,5,3,7,8,8,9,6,5,4};
    		for (int i = 0; i < intArray.length; i++) {
    			System.out.println(xuanzeSort(intArray)[i]);
    		}
    	}
    	
    	public static int[] xuanzeSort(int[] intArray){
    		for(int i=0; i < intArray.length; i++){
    			for(int j=i; j<intArray.length; j++){
    				if (intArray[i] > intArray[j]) {
    					int tmp = intArray[j];
    					intArray[j] = intArray[i];
    					intArray[i] = tmp;
    				}
    			}
    		}
    		
    		return intArray;
    	}
    }
    

      

    选择排序性能分析:

      选择排序和冒泡排序执行了相同次数的比较:N*(N-1)/2,但是至多只进行了N次交换。

      当 N 值很大时,比较次数是主要的,所以和冒泡排序一样,用大O表示是O(N2) 时间级别。但是由于选择排序交换的次数少,所以选择排序无疑是比冒泡排序快的。当 N 值较小时,如果交换时间比选择时间大的多,那么选择排序是相当快的。

    三、插入排序

    package com.light.springboot.algorithm;
    
    /**
     * 插入排序法
     * 直接插入排序基本思想是每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到插完所有元素为止。
     * @author qiaozhong
     *
     */
    public class SortCharu {
    	public static void main(String[] args) {
    		int[] intArray = {0,5,3,7,8,8,9,6,5,4};
    		for (int i = 0; i < intArray.length; i++) {
    			System.out.println(charuSort(intArray)[i]);
    		}
    	}
    	
    	/**
    	 * @param intArray
    	 * @return
    	 */
    	public static int[] charuSort(int[] intArray){
    		
    		//默认首个元素自己为有序的,所以从第二个元素开始拍讯,循环length-1次
    		for (int i=1; i < intArray.length; i++) {
    			
    			//记录要插入的数据
    			int j = i;
    			int tmp = intArray[j];
    			
    			//若当前值小于前面元素值,就把前面元素向后移动一个位置,直到当前值大于前面元素数值,或者当前值移动到数组首位
    			while(j>0 && tmp < intArray[j-1]){
    				intArray[j] = intArray[j-1];
    				j--;
    			}
    			intArray[j] = tmp;//要插入的数据存插入到正确位置
    		}
    		return intArray;
    	}
    }
    

      

    插入排序性能分析:

      在第一轮排序中,它最多比较一次,第二轮最多比较两次,一次类推,第N轮,最多比较N-1次。因此有 1+2+3+...+N-1 = N*(N-1)/2。

      假设在每一轮排序发现插入点时,平均只有全体数据项的一半真的进行了比较,我们除以2得到:N*(N-1)/4。用大O表示法大致需要需要 O(N2) 时间级别。

      复制的次数大致等于比较的次数,但是一次复制与一次交换的时间耗时不同,所以相对于随机数据,插入排序比冒泡快一倍,比选择排序略快。

      这里需要注意的是,如果要进行逆序排列,那么每次比较和移动都会进行,这时候并不会比冒泡排序快。

    总结:

    上面讲的三种排序,冒泡、选择、插入用大 O 表示法都需要 O(N2) 时间级别。一般不会选择冒泡排序,虽然冒泡排序书写是最简单的,但是平均性能是没有选择排序和插入排序好的。

      选择排序把交换次数降低到最低,但是比较次数还是挺大的。当数据量小,并且交换数据相对于比较数据更加耗时的情况下,可以应用选择排序。

      在大多数情况下,假设数据量比较小或基本有序时,插入排序是三种算法中最好的选择。

      后面我们会讲解高级排序,大O表示法的时间级别将比O(N2)小。 

    个人理解,如有错误,欢迎指正!
  • 相关阅读:
    AI编辑SVG格式的相关问题
    HTML里的id等属性命名需要注意
    canvas绘图动画细节
    触控获取坐标判断滑动方向
    CSS3卡片旋转效果
    使用CURL下载远程文件保存到服务器
    微信JS-SDK应用DEMO
    布局转换:文档流->绝对定位
    ThinkPHP缓存微信公众号access_token
    JAVA JSP笔记
  • 原文地址:https://www.cnblogs.com/gllegolas/p/13325262.html
Copyright © 2020-2023  润新知