常见的排序算法整理

在这里整理一下目前一些常见的排序算法和一些个人理解，可能会存在一定的错误，后续发现后会立即更正。

所涉及到的算法包括：冒泡排序、选择排序、插入排序、希尔排序、快速排序（递归和非递归版本）、堆排序、归并排序、桶排序、基数排序、计数排序。

一些理解：

快速排序和归并排序都是基于分治的思想，区别在于快速排序是先整体再局部：先把数据整体划分成两部分，一部分大于某个值，另一部分小于某个值，然后再分别对两部分作递归处理，即先保证整体基本有序，再保证局部有序；而归并排序是先把数据划分成最小的排序单元，先局部有序，然后对排序单元进行合并，从而保证整体有序。

计数排序不适合大范围的数据排序的情况，因为会根据最大值来申请空间。

冒泡排序的改进：

①第一遍从前往后遍历，找到最大值，然后从后往前遍历，找到最小值，后面重复这两步操作，这种改进称为鸡尾酒排序。改进点在于增加了遍历的方向，在某些情况下有比冒泡更好的性能，但是两者在最差情况下的表现差不多。

package sortalg;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;

public class SortAlgorithms {
  public static void main(String[] args){
    SortAlgorithms test = new SortAlgorithms();
    int[] arr = new int[]{1,3,4,2,5,4,7,9,21,10,11,8};
    test.radixsort(arr);
//    test.mergesort(arr, 0, arr.length-1);
    for(int i : arr){
      System.out.print(i + " ");
    }
  }

  //冒泡排序
  public void bubble(int[] nums){
    for(int i=0; i<nums.length-1; i++){
      for(int j=0; j<nums.length-1-i; j++){
        if(nums[j] > nums[j+1]){
          nums[j] = nums[j] + nums[j+1];
          nums[j+1] = nums[j] - nums[j+1];
          nums[j] = nums[j] - nums[j+1];
        }
      }
    }
  }

  //选择排序
  public void selectsort(int[] nums){
    for(int i=0; i<nums.length-1; i++){
      int minIndex = i;
      for(int j=i; j<nums.length; j++){
        if(nums[j] < nums[minIndex]){
          minIndex = j;
        }
      }
      swap(nums, i, minIndex);
    }
  }

  //插入排序
  public void insertsort(int[] nums){
    for(int i=1; i<nums.length; i++){
      for(int j=i; j>0; j--){
        if(nums[j]<nums[j-1]){
          nums[j] = nums[j] + nums[j-1];
          nums[j-1] = nums[j] - nums[j-1];
          nums[j] = nums[j] - nums[j-1];
        }
      }
    }
  }

  //希尔排序--插入排序的改进版
  public void shellsort(int[] nums){
    int step = 0;
    while(step < nums.length) step = 3*step +1;
    while(step >0){
      step /= 3;
      for(int i=0; i<step; i++){
        for(int j=i+step; j<nums.length; j += step){
          int tmp = nums[j];
          while(j>=step && nums[j-step] > tmp){
            nums[j] = nums[j-step]; 70             j -= step 71           }
          nums[j] = tmp;
        }
      }
    }
  }

  //堆排序：建堆，交换首尾元素，调整堆
  public void heapsort(int[] nums){
    int len = nums.length;
    while(len>1){
      for(int i = (len-2)/2; i>=0; i--){
        adjustheap(nums, i, len);
      }
      swap(nums, 0, len-1);
      len--;
    }
  }

  // 递归调整堆
  public void adjustheap(int[] nums, int i, int len){
    int k = i;
    int left = 2*i+1, right = 2*i+2;
    if( left < len && nums[left] > nums[k]){
      k = left;
    }
    if(right < len && nums[right] > nums[k]){
      k = right;
    }
    if(k != i){
      swap(nums, i, k);
      adjustheap(nums, k, len);
    }
  }

  // =========================快速排序=============================
  // 递归版本
  public void quicksortRecursion(int[] nums, int low, int high){
    if(low >= high) return;
    int left = low, right = high;
    int tmp = nums[left];
    while(left < right){
      while(right > left && nums[right] >= tmp) right--;
      nums[left] = nums[right];
      while(left < right && nums[left] <= tmp) left++;
      nums[right] = nums[left];
    }
    nums[left] = tmp;
    quicksortRecursion(nums, low, left-1);
    quicksortRecursion(nums, left+1, high);
  }

  // 快速排序-非递归版本
  public void quicksortNonRecursion(int[] nums){
    Stack<Integer> stack = new Stack<>();
    stack.push(0);
    stack.push(nums.length-1);
    while(!stack.empty()){
      int high = stack.pop();
      int low = stack.pop();

      int pivorite = partition(nums, low, high);
      if(pivorite > low){
        stack.push(low);
        stack.push(pivorite-1);
      }
      if(pivorite < high){
        stack.push(pivorite+1);
        stack.push(high);
      }
    }
  }

  public int partition(int[] nums, int low, int high){
    if(low >= high) return low;
    int left = low, right = high;
    int tmp = nums[left];
    while(left < right){
      while(right > left && nums[right] >= tmp) right--;
      nums[left] = nums[right];
      while(left < right && nums[left] <= tmp) left++;
      nums[right] = nums[left];
    }
    nums[left] = tmp;
    return left;
  }
  // =========================快速排序 end=============================

  // 归并排序
  public void mergesort(int[] nums, int left, int right){
    int mid = left + (right-left)/2;
    if(right > left){
      mergesort(nums, left, mid);
      mergesort(nums, mid+1, right);
      mergePartion(nums, left, mid, right);
    }
  }

  // 合并每个partion
  public void mergePartion(int[] nums, int left, int mid, int right){
    int[] tmp = new int[right-left +1];
    int low = left, high = mid+1;
    int i=0;
    while(low <= mid && high <= right){
      if(nums[low] <= nums[high]){
        tmp[i++] = nums[low++];
      }else{
        tmp[i++] = nums[high++];
      }
    }
    while(low<=mid) tmp[i++] = nums[low++];
    while(high<=right) tmp[i++] = nums[high++];
    for(i=left; i<=right; i++){
      nums[i] = tmp[i-left];
    }
  }

  // =========================桶排序 start=============================
  // 先把元素放到桶里，再对每一个桶分别排序，最后汇总输出
  public void bucketsort(int[] nums){
    int len = nums.length;
    int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
    //找到最小值和最大值
    for(int i=0; i<len; i++){
      if(nums[i] < min) min = nums[i];
      if(nums[i] > max) max = nums[i];
    }
    int bucketnum = max/len - min/len + 1;
    List list = new ArrayList<ArrayList<Integer>>();
    for(int i=0; i<bucketnum; i++){
      list.add(new ArrayList<>());
    }

    // 把数据放到不同的桶里
    for(int i=0; i<len; i++){
      int index = (nums[i] - min)/len;
      ((ArrayList<Integer>)list.get(index)).add(nums[i]);
    }

    // 对每个桶分别排序
    for(int i=0; i<bucketnum; i++){
      Collections.sort((ArrayList)list.get(i));
    }

    // 汇总数据
    int k=0;
    for(int i=0; i<bucketnum; i++){
      List<Integer> list1 = (ArrayList<Integer>)list.get(i);
      if(list1.size()>0){
        for(int j : list1){
          nums[k++] = j;
        }
      }
    }
  }
  // =========================桶排序 end=============================

  // =========================计数排序 start=============================
  public void countsort(int[] nums){
    int max = Integer.MIN_VALUE;
    for(int num : nums){
      if(num > max) max = num;
    }
    int busketnum = max + 1;
    int[] arr = new int[busketnum];
    for(int num : nums){
      arr[num]++;
    }
    int index = 0;
    for(int i=0; i< busketnum; i++){
      while(arr[i]>0){
        nums[index++] = i;
        arr[i]--;
      }
    }
  }
  // =========================计数排序 end=============================

  // =========================基数排序 end=============================
  public void radixsort(int[] nums){
    //获取最大的数字
    int max = Integer.MIN_VALUE;
    for(int num : nums){
      if(num > max) max = num;
    }
    for(int exp = 1; max/exp > 0; exp*=10){
      radixsort(nums, exp);
    }
  }

  public void radixsort(int[] nums, int exp){
    int[] busket = new int[10];
    int[] output = new int[nums.length];
    for(int i=0; i<nums.length; i++){
      busket[(nums[i]/exp)%10]++;
    }

    // 修改后，每个数组元素就代表小于等于当前位的数字有多少
    // 例如当前是个位排序，busket: 0 1 1 2 3 4 7 7 8 9的4表示个位小于等于5的数字有4个
    for(int i=1; i<busket.length; i++){
      busket[i] += busket[i-1];
    }

    // 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。 注意这里要从后向前遍历
    for(int i=nums.length-1; i>=0; i--){
      int busketIndex = (nums[i]/exp)%10;
      output[--busket[busketIndex]-1] = nums[i];279     }

    for(int i=0; i<nums.length; i++){
      nums[i] = output[i];
    }
  }
  // =========================基数排序 end=============================

  public void swap(int [] nums, int  i, int j){
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
  }
}

 补充鸡尾酒排序：

    //鸡尾酒排序：冒泡排序的改进，稳定
    //先从低到高，再从高到低
    public void cocktail(int[] arr){
        if(arr==null||arr.length==0) return;
        for(int left=0,right=arr.length-1;left<right;){
            //从低到高，将较大元素后移
            for(int i=left;i<right;i++){
                if(arr[i]>arr[i+1]){
                    exchange(arr,i,i+1);
                }                
            }
            right--;
            //从高到低，将较小元素前移
            for(int j=right;j>0;j--){
                if(arr[j]<arr[j-1]){
                    exchange(arr,j,j-1);
                }
            }
            left++;
        }
    }