希尔排序与快速排序

Posted 2022-03-13 train99999

希尔排序法

希尔排序也是一种插入排序，他是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序

希尔排序交换法

package sort;

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

public class ShellSort 
    public static void main(String[] args) 
        int[] arr = new int[800000];
        for(int i=0;i<arr.length;i++) 
            //每循环一次就添加一个元素
            arr[i]=(int)(Math.random()*80000);
        
        Date data1 = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdf.format(data1);
        System.out.println("开始时间"+dateStr);
        System.out.println("排序进行中........");
        shellSort2(arr);
        Date data2 = new Date();
        String dateStr2 = sdf.format(data2);
        System.out.println("开始时间"+dateStr2);
        System.out.println("排序结束");
        shellSort(arr);
        
    
    //交换法
    public static void shellSort(int[] arr) 
        int temp=0;
        //i等于5是因为第一次想让数组索引5的值和数组索引0的值进行比较
        //退出循环的条件是比较到了最后一个索引
        for(int gap = arr.length/2;gap>0;gap /= 2) 
            for(int i=gap;i<arr.length;i++)        
                for(int j=i-gap;j>=0;j -= gap) //j>=0 j-=gap 确保只循环一次
                    if(arr[j]>arr[j+gap]) 
                        temp = arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    
                
            
            //System.out.println(Arrays.toString(arr));
        //平均9秒
        
    //位移法

       public static void shellSort2(int[] arr) 
        for(int gap = arr.length/2;gap > 0;gap /=2) 
            for(int i = gap;i<arr.length;i++) 
                int j=i;//记录索引的位置,第一次是5
                int temp=arr[j];//记录索引的值，第一次是6
                if(arr[j]<arr[j-gap]) //让两个数字进行比较。例如索引5和索引0的值比较,6<8
                    while(j-gap >= 0 && temp < arr[j-gap]) 
                        arr[j]=arr[j-gap];//把索引0的值8，移动到索引5的位置
                        j-=gap;//只需要比较一次，就需要确保执行一次；j=j-gap
                    
                    arr[j]=temp;//把6移动到0的位置
                
            
                //System.out.println(Arrays.toString(arr));
            
        
    
    //平均1秒

快速排序

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

package sort;

import java.util.Arrays;

public class QuickSort 
    public static void main(String[] args) 
        int[] arr = -9,78,0,23,-567,70;
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    
    public static void quickSort(int[] arr,int left,int right) 
        int l = left;//左下标
        int r = right;//右下标
        int temp;
        int pivot = arr[(left+right)/2];//中下标
        while(l < r) 
            while(arr[l] < pivot) 
                l +=1;
            
            while(arr[r]>pivot) 
                r -= 1;
            
            if( 1 >= r) 
                break;
            
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            
            if(arr[1]==pivot) 
                r -= 1;
            
            
            if(arr[r] == pivot) 
                l += 1;
            
            if(l==r) 
                 l +=1;
                 r -=1;
            
            if(left<r) 
                quickSort(arr,left,r);
            
            if(right>1) 
                quickSort(arr,l,right);