zoukankan      html  css  js  c++  java
  • 冒泡、选择、插入、快速排序

    package paixu;
    import java.util.Random;
    
    public class test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		
    		int[] a={34,45,6,3,1,3,534,456,3};
    		int[] b;
    	
    		b=maopao(a);
    		System.out.println("冒泡排序:");
    		for(int c:b){
    			System.out.print(c+",");
    		}
    		
    		b=xuanze(a);	
    		System.out.println();
    		System.out.println("选择排序:");
    		for(int c:b){
    			System.out.print(c+",");
    		}
    		
    		b=charu(a);	
    		System.out.println();
    		System.out.println("插入排序:");
    		for(int c:b){
    			System.out.print(c+",");
    		}
    		
    		b = quickSort(a,0,a.length-1);
    		System.out.println();
    		System.out.println("快速排序:");
    		for(int c:b){
    			System.out.print(c+",");
    		}
    		
    		b = quickSort2(a,0,a.length-1);
    		System.out.println();
    		System.out.println("快速排序2:");
    		for(int c:b){
    			System.out.print(c+",");
    		}
    		
    	}
    //	冒泡排序
        /**  
         * 依次比较相邻的两个数,将小数放在前面,大数放在后面  
         * 冒泡排序,具有稳定性  
         * 时间复杂度为O(n^2)  
         * 不及堆排序,快速排序O(nlogn,底数为2)  
         * @author liangge  
         *  
         */ 
    	public static int[] maopao(int[] a){
    		
    		for(int i=0;i<a.length-1;i++){
    			for(int j=a.length-1;j>i;j--){
    				if(a[j]<a[j-1]){
    					int temp=a[j];
    					a[j]=a[j-1];
    					a[j-1]=temp;
    				}
    			}
    		}
    		return a;
    		
    	}
    //	选择排序
        /**  
         * 选择排序  
         * 每一趟从待排序的数据元素中选出最小(或最大)的一个元素,  
         * 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。   
         * 选择排序是不稳定的排序方法。  
         * @author liangge  
         *   
         */
    	public static int[] xuanze(int[] a) {
    		 
    		for (int i = 0; i < a.length-1; i++) {
    			int minindex=i;
    			for (int j = i+1; j < a.length; j++) {
    				if(a[j]<a[minindex]){
    					minindex=j;
    				}
    			}
    			if(minindex!=i){
    				int temp=a[i];
    				a[i]=a[minindex];
    				a[minindex]=temp;
    			}
    		}
    		return a;
    	}
    //	插入排序
        /**  
         * 直接插入排序  
         * 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据  
         * 算法适用于少量数据的排序,时间复杂度为O(n^2)。是稳定的排序方法。  
         */
    	public static int[] charu(int[] a) {
    		
    		for (int i = 0; i < a.length-1; i++) {
    			for (int j = i+1; j > 0; j--) {
    				if(a[j]<a[j-1]){
    					int temp=a[j];
    					a[j]=a[j-1];
    					a[j-1]=temp;
    				}
    			}
    		}
    		return a;
    	}
    //	快速排序
        /**  
         * 快速排序 通过一趟排序将要排序的数据分割成独立的两部分,
         * 其中一部分的所有数据都比另外一部分的所有数据都要小,  
         * 然后再按此方法对这两部分数据分别进行快速排序, 
         * 整个排序过程可以递归进行,以此达到整个数据变成有序序列。  
         * @author liangge  
         *   
         */
    	public static int[] quickSort(int a[],int l,int r){
    	     if(l>=r)
    	       return null;
    
    	     int i = l; int j = r; int key = a[l];//选择第一个数为key
    
    	     while(i<j){
    
    	         while(i<j && a[j]>=key)//从右向左找第一个小于key的值
    	             j--;
    	         if(i<j){
    	             a[i] = a[j];
    	             i++;
    	         }
    
    	         while(i<j && a[i]<key)//从左向右找第一个大于key的值
    	             i++;
    
    	         if(i<j){
    	             a[j] = a[i];
    	             j--;
    	         }
    	     }
    	     //i == j
    	     a[i] = key;
    	     quickSort(a, l, i-1);//递归调用
    	     quickSort(a, i+1, r);//递归调用
    	     
    	     return a;
    	 }
    	
    	/**  
         * 快速排序  
         * @param sort 要排序的数组  
         * @param start 排序的开始座标  
         * @param end 排序的结束座标  
         */  
        public static int[] quickSort2(int[] sort, int start, int end) {   
            // 设置关键数据key为要排序数组的第一个元素,   
            // 即第一趟排序后,key右边的数全部比key大,key左边的数全部比key小   
            int key = sort[start];   
            // 设置数组左边的索引,往右移动判断比key大的数   
            int i = start;   
            // 设置数组右边的索引,往左移动判断比key小的数   
            int j = end;   
            // 如果左边索引比右边索引小,则还有数据没有排序   
            while (i < j) {   
                while (sort[j] > key && j > start) {   
                    j--;   
                }   
                while (sort[i] < key && i < end) {   
                    i++;   
                }   
                if (i < j) {   
                    int temp = sort[i];   
                    sort[i] = sort[j];   
                    sort[j] = temp;   
                }   
            }   
            // 如果左边索引比右边索引要大,说明第一次排序完成,将sort[j]与key对换,   
            // 即保持了key左边的数比key小,key右边的数比key大   
            if (i > j) {   
                int temp = sort[j];   
                sort[j] = sort[start];   
                sort[start] = temp;   
            }   
            //递归调用   
            if (j > start && j < end) {   
                quickSort(sort, start, j - 1);   
                quickSort(sort, j + 1, end);   
            }   
            return sort;
        }   
    
    }
    
    
  • 相关阅读:
    bzoj3505 数三角形 组合计数
    cogs2057 殉国 扩展欧几里得
    cogs333 荒岛野人 扩展欧几里得
    bzoj1123 BLO tarjan求点双连通分量
    poj3352 road construction tarjan求双连通分量
    cogs1804 联合权值 dp
    cogs2478 简单的最近公共祖先 树形dp
    cogs1493 递推关系 矩阵
    cogs2557 天天爱跑步 LCA
    hdu4738 Caocao's Bridge Tarjan求割边
  • 原文地址:https://www.cnblogs.com/dutf/p/14090586.html
Copyright © 2011-2022 走看看