主要排序算法的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);
    }
}