经典排序算法

排序算法

---

前言

基本排序算法(java)

一.冒泡排序

每次比较，将大值向后两两交换

//冒泡
 public int[] BubbleSort(int[] array){

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length-i-1; j++) {
                if(array[j]>array[j+1]){
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                }
            }
        }
        return array;
    }

二.选择排序

每次从当前值向后扫描，找出最小值的索引与当前值交换。

//选择排序
 public int[] SecSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minIndex=i;
            for (int j = i; j <array.length ; j++) {
                if(array[minIndex]>array[j]){
                    minIndex=j;
                }
            }
            if(minIndex!=i){
            int tmp=array[i];
            array[i]=array[minIndex];
            array[minIndex]=tmp;}

        }
        return array;


    }

三.插入排序

前面为已排序序列，将未排序序列中的当前值插入到前面已排序序列

//插入排序
 public int[] InsertSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
           int cur=array[i+1];
           int index=i;
           while (index>=0&&cur<array[index]){
               array[index+1]=array[index];
               index--;
           }
           array[index+1]=cur;
        }
        return  array;

    }

四.希尔排序

对数组进行分组，分别进行插入排序。每次分组排序完成之后减少增量。

//希尔排序
    public int[] ShellSort(int[] array){
        int gap=array.length/2;
        while (gap>0){
            for (int i = 0; i < array.length; i++) {
                int cur=array[i];
                int index=i-gap;
                while (index>=0&&cur<array[index]){
                    array[index+gap]=array[index];
                    index-=gap;
                }
                array[index+gap]=cur;
            }
            gap=gap/2;
        }
        return  array;
    }

五.快速排序

    public void QuickSort(int[] array,int a,int b){
        if(a>=b){
            return ;
        }
        int index=indexFind(array,a,b);
        QuickSort(array,a,index-1);
        QuickSort(array,index+1,b);

    }
    private int indexFind(int[] array,int s,int e){
        int index=array[s];
        while (s<e){
            while (index<array[e])e--;
            array[e]=array[s];
            while(index>array[s])s++;
            array[s]=array[e];
        }
        array[s]=index;
        return s;
    }

六.归并排序

//归并排序
public int[] MergeSort(int[] array){
        if(array.length<2){
            return array;
        }
        int mid=array.length/2;
        int[] left= Arrays.copyOfRange(array,0,mid);
        int[] right=Arrays.copyOfRange(array,mid,array.length);
        return Merge(MergeSort(left),MergeSort(right));
    }
    
    private int[] Merge(int[] left,int[] right){
        int[] ans=new int[left.length+right.length];
        int index=0;
        for (int i = 0,a=0,b=0; i <ans.length ; i++) {
            if(left[a]<=right[b]){
                ans[index++]=left[a++];
            }else if(left[a]>right[b]){
                ans[index++]=right[b++];
            }else if(a>=left.length){
                ans[i]=right[b++];
            }else if(b>=right.length){
                ans[i]=left[a++];
            }
            
        }
        return ans;
        
        
    } 

七.堆排序

构成最大堆，堆顶元素与最后一个元素交换并重新调整堆。

//堆排序
   public int[] HeapSort(int[] array){
        int len=array.length;
        for (int i = (len/2-1); i >=0; i--) {
            help(array,i,len);
        }


        for (int i = len-1; i >=0 ; i--) {
            int tmp=array[0];
            array[0]=array[i];
            array[i]=tmp;
            help(array,0,i);

        }
        return array;

    }
    private void help(int[] array,int index,int length){
        int max=index;
        int lc=index*2;
        int rc=index*2+1;
        if (length>lc&&array[max]<array[lc]){
            max=lc;
        }
        if (length>rc&&array[max]<array[rc]){
            max=rc;
        }
        if(index!=max){
            int tmp=array[index];
            array[index]=array[max];
            array[max]=tmp;
            help(array,max,length);

        }


    }

八.计数排序

将数值化为键值存储在额外开辟的数组空间中

//计数排序

public static int[]  countSort(int[] array){
        int min=array[0];
        int max=array[0];
        for (int i = 0; i < array.length; i++) {
            if(min>array[i]){
                min=array[i];
            }
            if(max<array[i]){
                max=array[i];
            }}
            int[] ans=new int[max+min-1];
            for (int j = 0; j < array.length; j++) {
                ans[array[j]-min]+=1;
            }
            int index=0;
            for (int j = 0; j <ans.length ; j++) {
                int cnt=ans[j];
                while (cnt>0){
                    array[index++]=j+min;
                    cnt--;
                }
            }
            return ans;



    }

九.桶排序

将数据放入每个桶中，再进行排序。

//桶排序
    public static int[] bucketSort(int[] array){
        int max=array[0];
        int min=array[0];
        for (int i = 0; i <array.length ; i++) {
            if(max<array[i]){
                max=array[i];
            }
            if(min>array[i]){
                min=array[i];
            }
        }
        int butNum=array.length;
        ArrayList<ArrayList<Integer>> but=new ArrayList<>();
        for (int i = 0; i < butNum; i++) {
            but.add(new ArrayList<>());
        }
        for (int i = 0; i <array.length ; i++) {
            int num=(array[i]-min)*(butNum-1)/(max-min);//放在第几个桶；
            but.get(num).add(array[i]);
        }

        for (int i = 0; i <but.size() ; i++) {
            Collections.sort(but.get(i));

        }
        int[] result=new int[array.length];
        int index=0;
        for (int i = 0; i <but.size() ; i++) {
            ArrayList<Integer> li=but.get(i);
            for (Integer nu: li) {
                result[index++]=nu;
            }

        }
        return result;

    }