常见排序算法及其java实现

最近学习了下java，感觉java在基本语法上与C++非常相似。作为练习，我用java实现了冒泡排序、选择排序、插入排序、基尔排序、快速排序、堆排序、计数排序、合并排序。

以下为实现代码：

public class Sort{
    public void print_arr(int[] arr){
        int len = arr.length;
        for (int i = 0; i < len; i++){
            System.out.print("" + arr[i] + " ");
        }
        System.out.println("");
    }


    public int[] dup_arr(int[] arr){
        int len = arr.length;
        int re[] = new int[len];
        for (int i = 0; i < len; i++){
            re[i] = arr[i];
        }
        return re;
    }


    public int[] bubble(int[] arr){
        int dup[] = this.dup_arr(arr);
        int len = dup.length;
        int tmp = 0;
        for (int i = 0; i < len; i++){
            for (int j = 0; j < len - 1 - i; j++){
                if (dup[j] < dup[j+1]){
                    tmp = dup[j];
                    dup[j] = dup[j+1];
                    dup[j+1] = tmp;
                }
            }
        }
        return dup;
    }


    public int[] selection(int[] arr){
        int dup[] = this.dup_arr(arr);
        int len = dup.length;
        int tmp = 0;
        int max = 0;
        for (int i = 0; i < len; i++){
            max = i;
            for (int j = i + 1; j < len; j++){
                if (dup[j] > dup[max]){
                    max = j;
                }
            }
            tmp = dup[i];
            dup[i] = dup[max];
            dup[max] = tmp;
        }
        
        return dup;
    }


    public int[] insertion(int[] arr){
        int dup[] = this.dup_arr(arr);
        for (int i = 1; i < dup.length; i++){
            int key = dup[i];
            int j = i - 1;
            while (j >= 0 && dup[j] < key){
                dup[j + 1] = dup[j];
                j--;
            }
            dup[j + 1] = key;
        }
        return dup;
    }


    public int[] shell(int[] arr, int step){
        int dup[] = this.dup_arr(arr);
        while (step > 0){
            //insertion sorting
            for (int i = step; i < dup.length; i += step){
                int j = i - step;
                int key = dup[i];
                while (j >= 0 && dup[j] < key){
                    dup[j + step] = dup[j];
                    j -= step;
                }
                dup[j + step] = key;
            }
            step = step / 2;
        }
        return dup;
    }


    public void quick(int[] dup, int leftpoint, int rightpoint){
        if (leftpoint >= rightpoint){
            return;
        }
        int key = dup[rightpoint];
        int left = leftpoint;
        int right = rightpoint;
        while (true){
            while (left < right && dup[left] >= key){
                left++;
            }
            while (left < right && dup[right] <= key){
                right--;
            }
            int tmp = 0;
            if (left >= right){
                tmp = dup[right];
                dup[right] = key;
                dup[rightpoint] = tmp;
                break;
            }
            tmp = dup[right];
            dup[right] = dup[left];
            dup[left] = tmp;
        }
        this.quick(dup, leftpoint, left - 1);
        this.quick(dup, left + 1, rightpoint);
    }
   

    //min heap
    public int micro_adjust(int[] arr, int i, int last){
        if (2 * i + 1 > last){
            return i;
        }

        int max = arr[i] < arr[2 * i + 1] ? i : (2 * i + 1);
        if (2 * i + 2 > last){
            return max;
        }

        max = arr[max] < arr[2 * i + 2] ? max : (2 * i + 2);
        if (max != i){
            int tmp = arr[i];
            arr[i] = arr[max];
            arr[max] = tmp;
        }

        return max;
    }
    //part of heap sorting. build a min heap
    public void build_heap(int[] arr, int last){
        int mid = (last + 1) / 2 - 1;
        for (int i = mid; i >= 0; i--){
            int tmp = micro_adjust(arr, i, last);
            //System.out.print("i: " + i + " tmp: " + tmp + "arr: ");
            //this.print_arr(arr);
            int flag = i;
            while (tmp <= mid && tmp != flag){
                flag = tmp;
                tmp = micro_adjust(arr, tmp, last);
            }
        }
        return;
    }
    //part of heap sorting. adjust the left arr
    public void adjust_heap(int[] arr, int last){
        int tmp = arr[0];
        arr[0] = arr[last];
        arr[last] = tmp;
        this.build_heap(arr, last - 1);
        return;
    }
    //use min heap to sort arr from big to small
    public int[] heap(int[] arr){
        int dup[] = this.dup_arr(arr);
        this.build_heap(dup, dup.length - 1);
        for (int i = 0; i < dup.length; i++){
            //System.out.print("i: " + i + " arr: ");
            //this.print_arr(dup);
            adjust_heap(dup, dup.length - 1 - i);
        }
        return dup;
    }        


    public int[] counting(int[] arr){
        int min = arr[0];
        int max = arr[0];
        for (int i = 1; i < arr.length; i++){
            min = min < arr[i] ? min : arr[i];
            max = max > arr[i] ? max : arr[i];
        }

        int buckets[] = new int[max - min + 1];
        int index = 0;
        for (int i = 0; i < arr.length; i++){
            index = arr[i] - min;
            buckets[index]++;
        }

        int res[] = new int[arr.length];
        for (int i = 0; i < res.length; i++){
            res[i] = -1;
        }

        for (int i = 0; i < arr.length; i++){
            index = arr[i] - min;
            int cnt = 0;
            for (int j = 0; j < index; j++){
                cnt += buckets[j];
            }
            while (res[res.length - 1 - cnt] != -1){
                cnt++;
            }
            res[res.length - 1 - cnt] = arr[i];
        }
        return res;
    }


    /*Failure: don't know how to build the buckets arr ......
    public int[] radix(int[] arr){
        int dup[] = this.dup_arr(arr);

        Queue[] buckets = new Queue[10];
        for (int i = 0; i < 10; i++){
            buckets[i] = new LinkedList();
        }

        int max = dup[0];
        for (int i = 1; i < dup.length; i++){
            max = max > dup[i] ? max : dup[i];
        }
        
        int n = 10;
        while (max > 0){
            for (int i = 0; i < dup.length; i++){
                buckets[dup[i] % n].add(dup[i]);
            }
            int j = 0;
            for (int i = 0; i < 10; i++){ 
                while (!buckets[i].isEmpty()){
                    dup[j++] = buckets[i].getFirst();
                    buckets[i].removeFirst();
                }
            }
            max /= 10;
            n *= 10;
        }
        return dup;
    }
    */


    //part of merge sorting: merge two arr together
    public int[] merge(int[] arr1, int[] arr2){
        int res[] = new int[arr1.length + arr2.length];
        int i = 0;
        int j = 0;
        int k = 0;
        while (i < arr1.length && j < arr2.length){
            if (arr1[i] > arr2[j]){
                res[k++] = arr1[i++];
            }else{
                res[k++] = arr2[j++];
            }
        }
        
        while (i < arr1.length){
            res[k++] = arr1[i++];
        }
        while (j < arr2.length){
            res[k++] = arr2[j++];
        }
        return res;
    }
    //the main part of merge_sort
    public int[] merge_sort(int[] arr, int start, int end){
        //System.out.println("start: " + start + " end: " + end);
        if (end - start < 1){
            //System.out.println("end == start");
            int tmp[] = {arr[start]};
            return tmp;
        }
        
        int flag = (end - start) / 2;
        int res1[] = merge_sort(arr, start, start + flag);
        //System.out.println("res1:");
        //this.print_arr(res1);
        int res2[] = merge_sort(arr, start + flag + 1, end);
        //System.out.println("res2:");
        //this.print_arr(res2);
        int res[] = merge(res1, res2);
        //this.print_arr(res);
        return res;
    }


    public static void main(String[] args){
        int arr[] = {6, 6, 7, 5, 3, 2, 4, 1, 8, 9, 0};
        Sort s = new Sort();
        System.out.print("The original array:        ");
        s.print_arr(arr);

        System.out.print("after bubble sorting:      ");
        s.print_arr(s.bubble(arr));

        System.out.print("after selection sorting:   ");
        s.print_arr(s.selection(arr));

        System.out.print("after insertion sorting:   ");
        s.print_arr(s.insertion(arr));

        System.out.print("after shell sorting:       ");
        s.print_arr(s.shell(arr, arr.length/2));

        System.out.print("after quick sorting:       ");
        int dup[] = s.dup_arr(arr);
        s.quick(dup, 0, dup.length - 1);
        s.print_arr(dup);

        System.out.print("after heap sorting:        ");
        s.print_arr(s.heap(arr));

        System.out.print("after counting sorting:    ");
        s.print_arr(s.counting(arr));
        
        //failure: because don't know how to define buckets
        //System.out.print("after radix sorting:       ");
        //s.print_arr(s.radix(arr));
        
        //failure: because don't know how to define buckets
        //System.out.print("after buckets sorting:       ");
        //s.print_arr(s.buckets(arr));

        System.out.print("after merge sorting:       ");
        dup = s.dup_arr(arr);
        s.print_arr(s.merge_sort(dup, 0, dup.length - 1));
    }
}