简单排序---冒泡,简单选择,直接插入_int sort = new int[10]-优快云博客

本文介绍了三种经典的排序算法：冒泡排序、选择排序和插入排序。详细解释了每种算法的工作原理，并通过Java代码实现了这些算法，展示了如何生成随机数组并进行排序的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

 
  	  
  	import java.util.Random;   
  	/**  
  	 * 冒泡排序
  	 * 依次比较相邻的两个数，将小数放在前面，大数放在后面  
  	 * 冒泡排序，具有稳定性  
  	 * 时间复杂度为O（n^2）,比较次数:(N^2)/2;最大交换次数:(N^2)/4
  	 * 
  	 */  
  	public class Bubble {   
  	    public static void main(String[] args) {   
  	        Random ran = new Random();   
  	        int[] sort = new int[10];   
  	        for(int i = 0 ; i < 10 ; i++){   
  	            sort[i] = ran.nextInt(50);   
  	        }   
  	        System.out.print("排序前的数组为");   
  	        for(int i : sort){   
  	            System.out.print(i+" ");   
  	        }   
  	        buddleSort(sort);   
  	        System.out.println();   
  	        System.out.print("排序后的数组为");   
  	        for(int i : sort){   
  	            System.out.print(i+" ");   
  	        }   
  	    }   
  	       
  	    /**  
  	     * 冒泡排序  
  	     * @param sort  
  	     */  
  	    private static void buddleSort(int[] sort){   
  	        for(int i=sort.length-1;i>0;i--){   
  	            for(int j=0;j<i;j++){   
  	                if(sort[j]>sort[j+1]){   
  	                    int temp = sort[j+1];   
  	                    sort[j+1] = sort[j];   
  	                    sort[j] = temp;   
  	                }   
  	            }   
  	        }   
  	    }   
  	}

   	import java.util.Random;   
   	  
   	/**  
   	 * 简单选择排序  
   	 * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，  
   	 * 顺序放在已排好序的序列的最后(或最前)，直到全部待排序的数据元素排完。   
   	 * 选择排序是不稳定的排序方法:如果一个元素比当前元素小，而这个元素又
   	 *       出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了
   	 * 
   	 *   
   	 */  
   	public class Selector {   
   	    public static void main(String[] args) {   
   	        Random ran = new Random();   
   	        int[] sort = new int[10];   
   	        for (int i = 0; i < 10; i++) {   
   	            sort[i] = ran.nextInt(50);   
   	        }   
   	        System.out.print("排序前的数组为");   
   	        for (int i : sort) {   
   	            System.out.print(i + " ");   
   	        }   
   	        selectSort(sort);   
   	        System.out.println();   
   	        System.out.print("排序后的数组为");   
   	        for (int i : sort) {   
   	            System.out.print(i + " ");   
   	        }   
   	    }   
   	  
   	    /**  
   	     * 选择排序 
   	     * 每一趟从待排序的数据元素中选出最小的一个元素,
   	     *  顺序放在已排好序的序列的前面
   	     * @param sort  
   	     */  
   	    private static void selectSort(int[] sort){   
   	        for(int i =0;i<sort.length-1;i++){ 
   	        	  int min=i;  
   	            for(int j = i+1;j<sort.length;j++){  	   	            	  
   	                if(sort[j]<sort[min]){   
   	                     min=j;
   	                }    
   	                 
   	            }  
   	            if(min!=i){
   	               int temp = sort[min];   
   	               sort[min] = sort[i];   
   	               sort[i] = temp; 
   	            
   	           }
   	        }   
   	    }   
   	}

   	/**  
   	 * 直接插入排序  
   	 * 将一个数据插入到已经排好序的局部有序的序列中,
     *     从而得到一个新的、个数加一的局部有序序列  
   	 * 算法适用于少量数据的排序，时间复杂度为O(N^2),比较次数:N*(N-1)/2,
   	 *          赋值次数大致等于比较次数N*(N-1)/2,
   	 *          约比冒泡排序快一倍,比选择排序略快
   	 * 如果数据基本有序,只需要O(N)的时间级
     * 直接插入排序是稳定的排序方法。  
   	 */  
   	import java.util.Random;   
   	  
   	public class DirectInsert {   
   	    public static void main(String[] args) {   
   	        Random ran = new Random();   
   	        int[] sort = new int[10];   
   	        for (int i = 0; i < 10; i++) {   
   	            sort[i] = ran.nextInt(50);   
   	        }   
   	        System.out.print("排序前的数组为");   
   	        for (int i : sort) {   
   	            System.out.print(i + " ");   
   	        }   
   	        directInsertSort(sort);   
   	        System.out.println();   
   	        System.out.print("排序后的数组为");   
   	        for (int i : sort) {   
   	            System.out.print(i + " ");   
   	        }   
   	    }   
   	  
   	    /**  
   	     * 直接插入排序  
   	     *   
   	     * @param sort  
   	     */  
   	    private static void directInsertSort(int[] sort) {   
   	        for (int i = 1; i < sort.length; i++) {   
   	            int index = i - 1;   
   	            int temp = sort[i];   
   	            while (index >= 0 && sort[index] > temp) {   
   	                sort[index + 1] = sort[index];   
   	                index--;   
   	            }   
   	            sort[index + 1] = temp;   
   	  
   	        }   
   	    }   
   	}