数据结构之排序

不再详细说明理论了，直接贴上代码

插入排序

直接插入排序

public class InsertSort {
    static void Sort(int[] G){
        int listener=0;
        int index=0;
        for(int i=1;i<G.length;i++){
            if(G[i]<G[i-1]){
                listener=G[i];
                for(int j=i-1;j>=0&&listener<G[j];--j){
                    G[j+1]=G[j];
                    index=j;
                }
                G[index]=listener;
            }
            System.out.println("---第"+i+"次排序"+Arrays.toString(G));
        }
        System.out.println(Arrays.toString(G));
    }
    public static void main(String[] args){
        int[] G={0,2,4,3,6,1,7,0};
        int[] G1={0,1};
        Sort(G1);
    }
}

折半插入排序

public class ASLSort {
    public static void Sort(int[] G){
        int listener=0;
        int index=0;
        int low=0;
        int high=0;
        int mid=0;
        for(int i=1;i<G.length;i++){
            low=0;high=i-1;
            listener=G[i];
            while(low<=high){
                System.out.println("mid="+mid+",up="+high+",low="+low);
                mid=(low+high)/2;
                if(listener<G[mid]) high=mid-1;
                else low=mid+1 ;
                System.out.println("mid="+mid+",up="+high+",low="+low);
            }
            for(int j=i-1;j>=high+1;j-=1){
                G[j+1]=G[j];
                index=j;
            }
            G[high+1]=listener;
            //for(int j=i-increase;j>=high+1&&listener<G[j];j-=increase){
            //  G[j+increase]=G[j];
            //  index=j;
            //}
            System.out.println(Arrays.toString(G));
        }
    }
    public static void main(String[] args){
        int[] G={0,2,4,3,6,1,7,0};
        int[] G1={0,1,0,1,0};
        //SortWithShell(G);
        ShellSort(G1);
        //Sort(G);
        System.out.println("123");
    }
}

希尔排序

public class ASLSort {
    public static void ShellSort(int[] G){
        int listener=0;
        int index=0;
        for(int increase=G.length/2;increase>=1;increase/=2){
            System.out.println(increase);
            System.out.println(Arrays.toString(G));
            for(int i=increase;i<G.length;i++){
                if(G[i]<G[i-increase]){
                    //System.out.println(i);
                    listener=G[i];
                    for(int j=i-increase;j>=0&&listener<G[j];j-=increase){
                        G[j+increase]=G[j];
                        index=j;
                    }
                    G[index]=listener;
                }
            }
        }
        System.out.println(Arrays.toString(G));
    }
    public static void main(String[] args){
        int[] G={0,2,4,3,6,1,7,0};
        int[] G1={0,1,0,1,0};
        //SortWithShell(G);
        ShellSort(G1);
        //Sort(G);
        System.out.println("123");
    }
}

交换排序

冒泡排序

快速排序

选择排序

归并排序

public class BubleSort {
    private static String chars;
    //冒泡排序
    public static void Sort(int[] G){
        for(int i=0;i<G.length;i++){
            for(int j=G.length-1;j>i;j--){
                int temp=0;
                if(G[i]>G[j]){
                    temp=G[i];
                    G[i]=G[j];
                    G[j]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(G));
    }

    //快速排序
    public static void QuickSort(int[] G,int left,int right){
        if(left<right){
            int q=Partion(G,left,right);
            chars=Arrays.toString(G);
            if(chars==Arrays.toString(G)) return;
            QuickSort(G,left,q-1);
            QuickSort(G,q+1,right);
        }
    }

    //选择排序
    public static void SelectSort(int[] G){
        for(int i=0;i<G.length-1;i++){
            int min=i;
            for(int j=i+1;j<G.length;j++){
                if(G[min]>G[j]) min=j;
            }
            if(min!=i){
                int temp=G[i];
                G[i]=G[min];
                G[min]=temp;                
            }
            System.out.println(Arrays.toString(G));
        }
    }

    //归并排序
    public static void MergerSort(int[] G,int left,int right){
        if(left<right){
            int mid=(left+right)/2;
            System.out.println("mid="+mid+",left="+left+",right="+right);
            MergerSort(G,left,mid);
            MergerSort(G,mid+1,right);
            Merger(G,left,mid,right);
        }
    }

    public static void Merger(int[] G,int left,int mid,int right){
        int[] Temp=G.clone();
        int i=0,j=0,k=0;
        System.out.println("i="+i+",j="+j+",mid="+mid+",right="+right+",k="+k+",left="+left+",right="+right);
        for(i=left,j=mid+1,k=i;i<mid+1&&j<=right;k++){
            if(Temp[i]<Temp[j]) G[k]=Temp[i++];
            else
                G[k]=Temp[j++];
        }
        System.out.println("i="+i+",j="+j+",mid="+mid+",right="+right+",k="+k);
        while(i<=mid) G[k++]=Temp[i++];
        while(j<=right) G[k++]=Temp[j++];
        System.out.println(Arrays.toString(G));
    }

    static int Partion(int[] G,int left,int right){
        int temp=G[left];
        while(left<right){
            while(left<right&&temp<G[right]) --right;
            temp=G[right];
            while(left<right&&temp>=G[left]) ++left;
            G[right]=G[left];
            G[left]=temp;
        }
        return left;
    }
    public static void main(String[] args){
        int[] G={0,2,4,3,6,1,7,0};
        //QuickSort(G,0,G.length-1);
        //SelectSort(G);
        MergerSort(G,0,G.length-1);
    }
}