主要排序算法的Java实现

最近温习算法，花点时间写了点代码验证下，在这里做个存档。

 package com.chrischeng.hacker;

 import java.util.*;

 /**
  * Created by Yexin on 2016/11/4.
  */

 //Complete the code
 public class Solution
 {
     private final static int ARRAYSIZE = 50;
     private final static int ARRAYRANGE = ARRAYSIZE * 2;

     // 通过随机数发生器生成一个指定大小的随机数组
     public static int[] createArray(int size){
         int []retArray = new int [size];
         Random random = new Random();
         for(int i = 0;i < size;i++)
             retArray[i] = random.nextInt(ARRAYRANGE);
         return retArray;
     }

     // 打印指定数组
     public static void printArray(int []arr){
         for(int a : arr)
             System.out.print(a + " ");
         System.out.println();
     }

     // 交换数组中指定序号的元素值
     public static void swap(int[] arr, int i, int j ){
         if(i >= arr.length || j >= arr.length)
             return;
         else{
             int temp = arr[i];
             arr[i] = arr[j];
             arr[j] = temp;
         }
     }

     // 使用带有标志位的冒泡排序
     public static void bubbleSort(int []arr){
         int len = arr.length;
         boolean flag = false;
         for(int i = 0; i < len - 1; i++){
             for(int j = i + 1; j < len;j++){
                 if(arr[i] > arr[j]) {
                     swap(arr, i, j);
                     flag = true;
                 }
             }
             if(flag == false)
                 break;
         }
     }

     // 直接插入排序
     public static void insertionSort(int []arr){
         int len = arr.length, i = 1, j;
         for(; i < len; i++){
             int temp = arr[i];
             if(arr[i - 1] > arr[i]){
                 j = i - 1;
                 while(j >= 0 && arr[j] > temp) {
                     arr[j+1] = arr[j];
                     j--;
                 }
                 arr[j+1] = temp;
             }
         }
     }

     // Shell排序（本质上就是分治法的直接插入排序）
     public static void shellSort(int []arr){
         int len = arr.length, gap, i, j;
         for(gap = len/2; gap > 0; gap /= 2){
             for(i = gap;i < len; i++){
                 if(arr[i] < arr[i -gap]){
                     int temp = arr[i];
                     j = i - gap;
                     while(j >= 0 && arr[j] > temp){
                         arr[j+gap] = arr[j];
                         j -= gap;
                     }
                     arr[j+gap] = temp;
                 }
             }
         }
     }

     // 快速排序
     public static void quickSort(int []arr, int l, int r){
         if(l < r) {
             int i = l, j = r, base = arr[r];
             while (i < j) {
                 // 由左至右遍历，找到第一个大于中轴的元素
                 while (i < j && arr[i] < base)
                     i++;
                 // 如果i和j没有交叉且找到了第一个大于中轴的元素（index为i），则将它的值存放在j的位置，而j位置的值存放在base中
                 if (i < j)
                     arr[j--] = arr[i];
                 // 从右到左遍历，找到第一个小于中轴的元素
                 while (i < j && arr[j] > base)
                     j--;
                 // 如果i和j没有交叉且找到了第一个小于中轴的元素，则将他的值存放在上一步中index-i的位置上
                 if (i < j)
                     arr[i++] = arr[j];
             }
             // 上面的遍历完成后，i左侧都是小于base的元素，右侧都是大于base的元素，base作为中值存放在index=i的位置上，并不参与下次排序
             arr[i] = base;
             // 分别对数组左右侧进行递归排序
             quickSort(arr,l,i-1);
             quickSort(arr,i+1,r);
         }
     }

     // 桶排序
     // 本质上其实就是彻底的牺牲空间换取时间的做法
     // 适用于数字范围在一定区间内的随机数组
     public static void bucketSort(int arr[]){
         // 此处之所以使用对象数组，是因为实际情况中存在多个同值元素存在的可能性
         ArrayList<Integer> buckets[] = new ArrayList[ARRAYRANGE + 1];
         for(int i : arr) {
             if (buckets[i] == null)
                 buckets[i] = new ArrayList<Integer>();
             buckets[i].add(new Integer(i));
         }
         int index = 0;
         for(ArrayList<Integer> al : buckets){
             if(null != al && al.size() > 0){
                 for(Integer i : al)
                     arr[index++] = i;
             }
         }
     }

     // 基数排序
     // 本质上就是按照从低位到高位的桶排序，所以无论随机数组的长度为多大，永远只需要十个桶
     public static void radixSort(int arr[]){
     }

     public static void main(String[] args){
         int [] arr = createArray(ARRAYSIZE);
         printArray(arr);
         bucketSort(arr);
         printArray(arr);
     }
 }