算法之排序算法

Posted 2022-11-29 strandtrack

1.冒泡排序

思想：

两个两个的比较，第一和第二比，如果第一<第二，交换位置，接着第一和第三比，同样小的放前面，这样走一轮最后一位就确定绝对是最大的。然后再走第二轮第三轮，直到所有位置都确定。

代码实现：

package sort;

import java.util.Arrays;

public class BubbleSort 
    public static void main(String[] args) 
        int[] arr = new int[800];
        for(int i =0; i < 800;i++) 
            arr[i] = (int)(Math.random() * 8000);

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

    
    public static void bsort(int [] arr)

        int temp;
        boolean flag=false;//是否交换，为交换为false
        for (int i=0;i<arr.length-1;i++)
        
            for (int j=0;j<arr.length-1;j++)
            
                if(arr[j]>arr[j+1])
                
                    flag=true;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                
            
            if(!flag)
                break;
            
            else 
                flag=true;
            
        
    

 

2.选择排序

思想：

先把第一个值假设为最小的，然后与后面的数一一对比，如果后面的数比他小就设为最小数，走一轮之后确定一个最终的最小的数，然后把它的值与数组中的第一个数交换。这样第一个数就是最小的数，下一轮从第二个值开始，同样的方法选出第二小的数，一直到倒数第二个的值选出，排序就完成了。

代码实现：

package sort;

import java.util.Arrays;

public class SelectSort 
    public static void main(String[] args) 
        int[] arr = new int[800];
        for(int i =0; i < 800;i++) 
            arr[i] = (int)(Math.random() * 8000);

        
        System.out.println(Arrays.toString(arr));
        ssort(arr);
        System.out.println(Arrays.toString(arr));
    
    public static void ssort(int [] arr)
    
        for(int i=0;i<arr.length-1;i++)
        
            int min=arr[i];
            int minIndex=i;
            for(int j=i+1;j<arr.length;j++)
            
               if(min>arr[j])
               
                   min=arr[j];
                   minIndex=j;
               
            
           if(minIndex!=i)
           
               arr[minIndex] =arr[i];
               arr[i]=min;
           


        
    

 

3.希尔排序

思想：

代码实现：

package sort;

import java.util.Arrays;

public class ShellSort 
    public static void main(String[] args) 
       int[] arr = new int[800];
        for(int i =0; i < 800;i++) 
            arr[i] = (int)(Math.random() * 8000);

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

    //希尔排序之交换法
    public static void ssort(int [] arr)
    
        int temp;

        for(int book=arr.length/2;book>0;book/=2)
        
            for(int i=book;i<arr.length;i++)
            
                for(int j=i-book;j>=0;j-=book)
                
                    if(arr[j+book]<arr[j])
                    
                        temp=arr[j+book];
                        arr[j+book]=arr[j];
                        arr[j]=temp;
                    
                
            
        
    

4.快速排序

思想：

设置一个基准数，假设就是数组的最左边，arr[0]，在数组的左边和右边用两个变量i和j记录，首先j开始出动往左边走（必须是在基准数反方向的变量先出发，因为如果从相同方向找比基准数大的如果i=j了，这个时候就需要交换基准数和i所在的数，这个数是大于基准数的，我们要的是小于基准数的在左边，这就不对了），找到一个小于基准数的数后停下来，然后i开始走，走到大于基准数停下来，这时候两个变量所在的数组交换，然后继续j先走，i后走，交换。直到i和j相等的时候，这个时候把这个arr[i]和基准数的位置arr[0]交换，这个时候基准数所在的位置左边都小于他，右边都大于他。然后递归分为两个：

• 基准数左边的
• 基准数右边的

代码实现：

public class QuickSort 
    public static void main(String[] args) 
        int[] arr = new int[800];
        for(int i =0; i < 800;i++) 
            arr[i] = (int)(Math.random() * 8000);

        
        System.out.println(Arrays.toString(arr));
        int j=arr.length-1;
        qsort(arr,0,j);
        System.out.println(Arrays.toString(arr));
    
    public static void qsort(int[] arr,int left,int right) 
        int i,j,temp,t;
        if(left>right)
            return;
       //作为基准数
       temp=arr[left];
       i=left;
       j=right;
       while (i!=j)
       
           //找到小于基准数的停止
           while (arr[j]>=temp &&i<j)
           
               j--;

           
           //找到大于基准数停止
           while (arr[i]<=temp && i<j)
           
               i++;
           
           if(i<j)
           
               t=arr[j];
               arr[j]=arr[i];
               arr[i]=t;
           

       
      arr[left]=arr[i];
       arr[i]=temp;

       qsort(arr,left,i-1);
       qsort(arr,i+1,right);
       return;