java 实现多种排序

public class Sort {
    
    //交换两个数
    private void swap(int[] arr, int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    //普通版冒泡排序,时间复杂度为O(n^2),稳定的排序算法
    public void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=arr.length-2;j>=i;j--){
                if(arr[j] > arr[j+1])
                    swap(arr, j, j+1);
            }
        }        
    }
    
    //改进版的冒泡排序
    public void bubble2Sort(int[] arr){
        boolean flag = true;
        for(int i=0;i<arr.length-1;i++){
            flag = false;
            for(int j=arr.length-2;j>=i;j--){
                if(arr[j] > arr[j+1]){
                    swap(arr, j, j+1);
                    flag = true;
                }
            }
        }
    }
    
    //简单选择排序,时间复杂度为O(n^2),稳定的排序算法，性能上优于冒泡，移动次数少，最多移动n-1次
    public void selectSort(int[] arr){
        int min;
        for(int i=0;i<arr.length-1;i++){
            min = i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[min] > arr[j])
                    min = j;
            }
            if(min != i)
                swap(arr,i,min);
        }
    }
    
    //直接插入排序，稳定的排序算法，比较、移动的时间复杂度为O(n^2)
    public void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){
            int temp = arr[i];
            int j;
            for(j=i-1;j>=0&&arr[j]>temp;j--)
                arr[j+1] = arr[j];
            arr[j+1] = temp;
        }
    }
    
    //双点直接插入排序，稳定的排序算法,不是从开始进行的排序
    public void insertSort2(int[] arr,int left, int right){
        for(int i=left;++left<=right;i=++left){
            int a1 = arr[i];
            int a2 = arr[left];
            if(a1<a2){
                a2 = a1;
                a1 = arr[left];
            }
            while(a1 < arr[--i]){
                arr[i+2] = arr[i];
            }
            arr[++i + 1] = a1;
            while(a2 < arr[--i]){
                arr[i+1] = arr[i];
            }
            arr[i+1] = a2;
        }
            int last = arr[right];
            while(last < arr[--right])
                arr[right+1] = arr[right];
            arr[right+1] = last;
    }
    
    //希尔排序，不是稳定的排序算法，是对插入排序的升级版，最好可以达到O(n^(3/2)),不好可以是O(n^2)
    public void shellSort(int[] arr){
        for(int gap=arr.length/2;gap>0;gap /= 2){
            for(int i=0;i<gap;i++){
                for(int j=i+gap;j<arr.length;j += gap){
                    if(arr[j]<arr[j-gap]){
                        int temp = arr[j];
                        int k = j - gap;
                        while(k>=0 && arr[k]>temp){
                            arr[k+gap] = arr[k];
                            k -= gap;
                        }
                        arr[k+gap] = temp;
                    }
                }
            }
        }
    }
    
    //堆排序，时间复杂度为O(nlogn)，不适合待排列个数较少的情况
    public void heapSortAsc(int[] arr){
        for(int i=arr.length/2-1;i>=0;i--){
            heapAdjust(arr,i,arr.length-1);
        }
        for(int i=arr.length-1;i>0;i--){
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapAdjust(arr,0,i-1);
        }
    }
    
    //建堆与调整堆的过程
    private void heapAdjust(int[] arr, int start, int end){
        int c = start;
        int lChild = 2 * c + 1;
        int temp = arr[c];
        for(; lChild <= end; c = lChild, lChild = 2 * lChild + 1){
            if(lChild < end && arr[lChild] < arr[lChild + 1])
                lChild++;
            if(arr[lChild] < temp){
                break;
            }    
            else{
                arr[c] = arr[lChild];
                arr[lChild] = temp;
            }
        }
    }
    
    //归并排序，稳定的排序方法，比较占内存，时间复杂度为O(nlogn)
    //归并排序分为两个部分，分解与合并，从上往下的排序
    public void mergeSortUp2Down(int[] arr, int start, int end){
        if(arr == null || start >= end)
            return;
        int mid = (start + end) / 2;
        mergeSortUp2Down(arr,start,mid);
        mergeSortUp2Down(arr, mid+1, end);
        
        merge(arr,start,mid,end);
    }
    //归并排序的合并部分
    public void merge(int[] arr, int start, int mid, int end){
        int i = start;
        int j = mid + 1;
        int k = 0;
        int[] temp = new int[end-start+1];
        while(i<=mid && j <= end){
            if(arr[i] <= arr[j])
                temp[k++] = arr[i++];
            else
                temp[k++] = arr[j++];
        }
        while(i <= mid)
            temp[k++] = arr[i++];
        while(j <= end)
            temp[k++] = arr[j++];
        for(i=0;i<k;i++){
            arr[start+i] = temp[i];
        }
        
    }
    
    //从下往上的排序，
    public void mergeSortDown2Up(int[] arr){
        if(arr == null)
            return;
        for(int i=1;i<arr.length;i *= 2)
            mergeGroups(arr, arr.length,i);
    }
    
    //对数组进行若干次排序
    public void mergeGroups(int[] arr, int len, int gap){
        int i;
        for(i=0;i+2*gap-1<len;i = i+2*gap){
            merge(arr,i,i+gap-1,i+2*gap-1);
        }
        if(i+gap-1<len-1)
            merge(arr,i,i+gap-1,len-1);
    }
    
    //快速排序，不稳定的排序算法，时间复杂度为O(nlogn)
    public void quickSort(int[] arr, int low, int high){
        int pivot;
        if(low < high){
            pivot = partition(arr,low,high);
            quickSort(arr,low,pivot-1);
            quickSort(arr,pivot+1,high);
        }
    }
    
    //快速排序，进行位置交换
    private int partition(int[] arr, int low, int high){
        int pivot = arr[low];
        while(low < high){
            while(low < high && arr[high] >= pivot)
                high--;
            swap(arr,low,high);
            while(low < high && arr[low] <= pivot)
                low++;    
            swap(arr,low,high);
        }
        return low;    
    }
    
    //双基准的快速排序算法    
    private void quickSort2(int[] arr, int lowIndex, int highIndex) {
      if(lowIndex >= highIndex) return;
      int pivot1 = arr[lowIndex];
      int pivot2 = arr[highIndex];
      if(pivot1 > pivot2){
          arr[lowIndex] = pivot2;
          arr[highIndex] = pivot1;
          pivot1 = arr[lowIndex];
          pivot2 = arr[highIndex];
      }else if(pivot1 == pivot2){
          while(pivot1 == pivot2 && lowIndex <= highIndex){
              pivot1 = arr[++lowIndex];
          }
      }
      int i = lowIndex + 1;
      int lt = lowIndex + 1;
      int gt = highIndex - 1;
      while(i<=gt){
          if(pivot1 > arr[i]){
              swap(arr,lt++,i++);
          }else if(pivot2 < arr[i]){
              swap(arr,i,gt--);
          }else{
              i++;
          }
      }
      swap(arr,lowIndex,--lt);
      swap(arr,highIndex,++gt);
      quickSort2(arr,lowIndex,lt-1);
      quickSort2(arr,lt+1,gt-1);
      quickSort2(arr,gt+1,highIndex);
  }
    
    //桶排序
    public void bucketSort(int[] arr, int max){
        if(arr == null || max < 1) return ;
        int[] buckets = new int[max];
        for(int i=0;i<arr.length;i++)
            buckets[arr[i]]++;
        for(int i=0, j=0;i<max;i++)
            while((buckets[i]--)>0)
                arr[j++] = i;
    }
    
    //计数排序，稳定的排序算法，桶排序另一种，时间复杂度为O(n)
    public void countSort(int[] arr, int max){
        int[] result = new int[arr.length];
        int[] temp = new int[max];
        for(int i=0;i<arr.length;i++){
            temp[arr[i]]++;
        }
        for(int i=1;i<temp.length;i++){
            temp[i] += temp[i-1];
        }
        for(int i=0;i<temp.length;i++)
            temp[i] -= 1;
        for(int i=arr.length-1;i>=0;i--){
            result[temp[arr[i]]--] = arr[i];
        }
        System.arraycopy(result, 0, arr, 0, arr.length);       
    }
    //基数排序，桶排序的升级版，利用计数排序来做
    public void radixSort(int[] arr, int max){
        for(int exp=1;max/exp>0;exp *= 10){
            countSort1(arr,exp);
        }
    }
    //基数排序调用计数排序
    public void countSort1(int[] arr, int exp){
        int[] temp = new int[10];
        int[] result = new int[arr.length];
        for(int i=0;i<arr.length;i++)
            temp[arr[i]]++;
        for(int i=1;i<10;i++)
            temp[i] += temp[i-1];
        for(int i=0;i<10;i++)
            temp[i]--;
        for(int i=arr.length-1;i>=0;i--)
            result[temp[arr[i]]--] = arr[i];
        System.arraycopy(result, 0, arr, 0, arr.length);
    }
   
    
    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] arr = {1,6,3,5,3,2,4,5,1,6};
        sort.radixSort(arr,7);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i] + " ");
        }
    }
}