java--数据结构--排序代码总结

import java.util.Arrays;

//数据结构排序
public class sort {
    public static void main(String[] args){
        int []arr={30,1001,23,96,78,37,45,66,99,100,1000,1,9007 };
        //print(arr);
        
        //insertHeap(arr,30);
        print(arr);
        Arrays.sort(arr);//java虚拟机中直接排序，开发常用
        //sort(arr,arr.length);
        print(arr);
        
    }
   public static void print(int []arr){//打印数组
      if(arr==null || arr.length<1) return ;
       for(int i: arr) System.out.print(i+" ");
       System.out.println();
   }
   /* public static void sort(int arr[],int n)//直接插入排序
   {
       int i,j,temp;
       for(i=1;i<n;i++){
           temp=arr[i];
           while(arr[i]<arr[i-1]){
                for(j=i-1;arr[j]>temp  && j>=0;j--)
                    arr[j+1]=arr[j];
                arr[j+1]=temp;
               
             
               
           }
       }
   }
     public static void sort(int []arr,int n ){//直接插入排序哨兵法
         int i ,j;
         for(i=2;i<n;i++)//数组0位置放哨兵，1位置不用比较，从2开始,结果会覆盖23
         {
             arr[0]=arr[i];
             while(arr[i]<arr[i-1])
             {
                 for(j=i-1;arr[j]>arr[0];j--)
                    arr[j+1]=arr[j];
                 arr[j+1]=arr[0];
             }
         }
         
     }
     public static void sort(int []arr ,int n){//改进直接插入法，用折半查找法查找插入位置
         int i ,j ,mid ,low ,high;
         for(i=2;i<n;i++){
             arr[0]=arr[i];
             low=1;high=i-1;
             while(low<=high){//看判定条件，因为这个不插入排序算法，需要每次增加元素都要折半查找
                 //这个循环用来查找插入位置，直到low>high
                 mid=(low+high)/2;
                 if(arr[mid]>arr[0]) high=mid-1;//mid值比插入值大，区间要在前半区间找
                 else low=mid+1;
            }
             for(j=i-1;j>=low;j--)//此时low>high,low指向比插入值大的值，low所指的值也要往后移
                 arr[j+1]=arr[j];
            // System.out.println(arr[j]+" zheli"+arr[high]);
             arr[j+1]=arr[0];//j移动完毕，指向high
             
         }
    public static void sort(int arr[],int n){//希尔排序
        int d,i,j;
        for(d=n/2;d>=1;d=d/2){//步长
            for(i=d+1;i<n;i++)
            {
                if(arr[i]<arr[i-d]){
                arr[0]=arr[i];
                for(j=i-d;j>0 && arr[j]>arr[0];j-=d)
                
                    arr[j+d]=arr[j];
                arr[j+d]=arr[0];
                
            }}
            print(arr);
        }
        
    }
   public static void sort(int arr[],int n){//希尔排序，先
       int d,i ,j;
       for(d=n/2;d>=1;d=d/2){
           for(i=d+1;i<n;i++){
               if(arr[i]<arr[i-d])
               {
                   arr[0]=arr[i];
                   for(j=i-d;j>0 && arr[j]>=arr[0];j-=d)
                   arr[j+d]=arr[j];
                   arr[j+d]=arr[0];
               }
           }
       }
   }
   public static void sort(int arr[] ,int n){//冒泡排序--交换排序的第一种
     int i ,j ,temp;
    
     for(i=0;i<n-1;i++){//从0开始遍历，遍历0结束后，0位置就固定，数组长度n,0-n-1;n-1不用循环
        boolean flag ;
             for(j=n-1;j>i;j--){
                 if(arr[j]<arr[j-1]){
                     temp=arr[j];
                     arr[j]=arr[j-1];
                     arr[j-1]=temp;
                    flag=true;
                 }
             }
             if(flag=false) return;
         
     }
       
       
       
   }
         public static void sort(int []arr ,int n ){//冒泡排序
             int i ,j,temp; 
             for(i=0;i<n-1;i++){
                 boolean flag=false;
                 for(j=n-1;j>i;j--){
                     if(arr[j]<arr[j-1]){
                         temp=arr[j];
                         arr[j]=arr[j-1];
                         arr[j-1]=temp;
                         flag= true;
                     }
                 }
                 if(flag == false) return;
                 print(arr);
             }
         }
   public static void sort(int []arr,int low,int high){//快排交换
      if(low<high){
       int partition=partition(arr,low,high);
      sort(arr,low,partition);
      sort(arr,partition+1,high);}
   }
   public static int partition(int []arr,int low,int high){
       int temp,left,right;
       temp=arr[low];
     left=low;  right=high-1;
    while(left<right){//用于寻找left==right
       while(arr[right]>=temp  && left<right) right--;//寻找右边第一个小于temp的值
       arr[left]=arr[right];
       while(arr[left]<temp && left<right) left++;//寻找左边第一个大于temp的值
              arr[right]=arr[left]; 
       
    }
      arr[right]=temp;
        print(arr);
       return left;
           
       }
   
     public static void sort(int []arr,int n){//简单选择排序--选择排序一种另一种是堆排序
         int i ,j ,temp;
         for(i=0;i<n-1;i++ ){
             int min=i;
             for(j=i+1;j<=n-1;j++)
                 if(arr[j]<arr[i])
                 {
                     temp=arr[j];
                     arr[j]=arr[i];
                     arr[i]=temp;
                 }
         }
     }
   public static void sort(int arr[],int n){//交换排序另一种，堆排序王道的堆有误
          buildHeapSort(arr,n);//先建立一个大根堆
       for(int i=n-1;i>1;i--){//n-1的调堆过程
           swap(arr,1,i);
           headAdjust(arr,1,i-1);
       }
   }
       public static void  swap(int arr[],int i,int k){
           int temp=arr[i];arr[i]=arr[k];arr[k]=temp;}
           
    public static void buildHeapSort(int arr[],int n){//建立大根堆
        for(int i=n/2;i>=1;i--)
            headAdjust(arr,i,n);
    }
    public static void headAdjust(int arr[],int k,int n){
        int temp;
       temp=arr[k];
        for(int i=2*k;i<n;i*=2){//找到arr[0]应该插入的位置
            if(arr[i]<arr[i+1] && i+1<n) i++;//找到子节点最大的
            if(temp<arr[i])  {arr[k]=arr[i]; k=i;}
            else  break;//把子节点大的搬上去，k指针下移，寻找arr[0]的存放位置
            
        }
       arr[k]=temp;
    }    */
   
  /* public static void sort(int arr[],int n){//duipaixu
       heapSort(arr,n);
       for(int i=n-1;i>0;i--){
           swap(arr,i,0);
           heapAdjust(arr,0,i-1);
       } }
       public static void swap(int arr[],int i,int k){
           int temp=arr[i];
           arr[i]=arr[k];
           arr[k]=temp;
       }
       public static void heapSort(int arr[],int n){
           for(int i=n/2-1;i>=0;i--){
               heapAdjust(arr,i,n);
           }                 }
       public static void heapAdjust(int arr[],int k,int n ){
           int temp=arr[k];
                  for(int i=2*k;i<n;i*=2){
               if(arr[i]<arr[i+1] && i+1<n) i++;
             // if(arr[i]<=temp) break;//此处有问题，当k==0时i=2k=0,
             //  else {arr[k]=arr[i];k=i;}
               if(arr[i]>temp) {arr[k]=arr[i];k=i;}
               else break;
           }
           arr[k]=temp;
          
       }
    public static void sort(int arr[],int n){//堆排序
       for(int i=n/2-1;i>=0;i--)       
           adjustSort(arr,i,n);
       for(int i=n-1;i>0;i--)
       {
           int temp=arr[0];
           arr[0]=arr[i];
           arr[i]=temp;
           adjustSort(arr,0,i);  
       }
   }
      public static void adjustSort(int arr[],int k,int n){
          int temp=arr[k];
          for(int i=2*k+1;i<n;i=2*i+1)
          {
              if(i+1<n && arr[i]<arr[i+1]) { i++;}
            //  if(arr[i]<arr[i+1] && i+1<n){  i++;}
             
              if(arr[i]>temp) {arr[k]=arr[i]; k=i;}
              else break;
          }
          arr[k]=temp;
         // print(arr);
      }
       
    public static void sort_1(int[] arr,int len) {
        for (int i = len / 2 - 1; i >= 0; i--) 
            adjustHeap(arr, i, len);
        
          for (int n = len - 1; n > 0; n--) {
            int temp = arr[n];
            arr[n] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, n);
        }
    }
    private static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];
        for (int j = i * 2 + 1; j < length; j = j * 2 + 1) {
            
            if (j + 1 < length && arr[j] < arr[j + 1]) {j++;}
            if (arr[j] > temp) {
                arr[i] = arr[j];  i = j;
            } else break;    
        }
        arr[i] = temp;
    }*/
   public static void sort(int arr[],int n){
      for(int i=n/2-1;i>=0;i--){
          adjustSort(arr,i,n);
      }
       for(int i=n-1;i>=1;i--){
           int temp=arr[i];
           arr[i]=arr[0];
           arr[0]=temp;
           adjustSort(arr,0,i-1);
       }
   }
   public static void adjustSort(int arr[],int k,int n){
       int temp=arr[k];
       for(int i=2*k+1;i<n;i=2*i+1)
       {
           if(i+1<n && arr[i]<arr[i+1] )  i++;
           if(arr[i]<temp) break;
           else {arr[k]=arr[i];k=i; }
        arr[k]=temp;   
           
       }
   }
   public static void insertHeap(int[]arr ,int m)
   {
       int pos=arr.length-1;
       arr[pos]=m;//插入到数组尾部
       for(int i=(pos-1)/2;i>=0;i=(i-1)/2){
           if(arr[i]<=m) break;
           else {
               int temp=arr[i];
                 arr[i]=m;
                 arr[pos]=temp;
                 pos=i;
           }
       }
   }
}