排序算法

心血来潮，想实现一个支持泛型的快速排序，于是写了如下程序。发现自己算法能力有待提高，因为写这个代码加上调试，花了比较长的时间。快速排序的原理比较简单，不断给元素定位，直到所有元素到了它该到的地方。代码基本思路一样，只是在复制数据的时候有些不同，第一种较麻烦，因为选择待定位数字作为数据中转位，而程序总是选择将第一个数字作为中转位。

public class QuickSort<T extends Comparable<? super T>> {
    //先前再后
    public void sortA(T[] t , int start, int end) {

        if(end >= t.length || start < 0 || t.length == 0){

            return;
        }
        if(start != end) {

            int a = start,b = end;
            T tmp = t[start];
            while(a != b) {

                while(t[a].compareTo(tmp) < 0 && a < b) {

                    a++;
                }
                t[start] = t[a];
                while(t[b].compareTo(tmp) > 0 && a < b) {

                    b--;
                }

                t[a] = t[b];
                t[b] = t[start];

            }
            //在中间向左找一个不大于候选点的位置
            while(t[a].compareTo(tmp) > 0 && a > start) {

                a--;
            }
            t[start] = t[a];
            t[a] = tmp;
            sort(t, start, a);
            sort(t, a+1, end);
            }
        }

    }

    //先后再前
    public void sortB(T[] t , int start, int end) {

        if(end >= t.length || start < 0 || t.length == 0){

            return;
        }
        if(start != end) {

            int a = start,b = end;
            T tmp = t[start];
            while(a != b) {

                while(t[b].compareTo(tmp) > 0 && a < b) {

                    b--;
                }
                t[a] = t[b];
                while(t[a].compareTo(tmp) < 0 && a < b) {

                    a++;
                }
                t[b] = t[a];
            }

            t[a] = tmp;
            sort(t, start, a);
            sort(t, a+1, end);
            }
        }

    }
}

既然完成了快速排序，那么归并排序也不能少，个人觉得最喜欢的就是这两个排序，从时间复杂度与可理解度上来说，都属于比较容易接受的。归并排序并没有将其变成通用的版本，较简单。

public class MergeSort {

    static int[] a = {4,7,9,1,2,5,8,6}; 

    public static void main(String args[]) {

        mergeSort(0, a.length-1);
        for(int i=0; i<a.length; i++) {

            System.out.println(a[i]);
        }
    }

    private static void mergeSort(int s, int e) {

        if(s >= e) {

            return;
        }

        if(e - s == 1) {

            if(a[s] > a[e]) {
                swap(s,e);
            }
        } else {

            int mid = (s + e) / 2;
            mergeSort(s, mid);
            mergeSort(mid+1, e);
            combine(s,mid,e);
        }

    }

    private static void combine(int s, int mid, int e) {

        int tmp[] = new int[e-s + 1]; int point = 0;
        int s1 = s, s2 = mid+1;
        while(s1 <= mid && s2 <= e) {

            if(a[s1] <= a[s2]) {

                tmp[point++] = a[s1++];
            }
            if(a[s1] > a[s2]) {

                tmp[point++] = a[s2++];
            }
        }
        if(s1 <= mid) {

            while(s1 <= mid) {

                tmp[point++] = a[s1++];
            }
        }
        if(s2 <= e) {

            while(s2 <= e) {

                tmp[point++] = a[s2++];
            }
        }
        for(int i = 0; i < tmp.length ; i++) {

            a[s++] = tmp[i];
        }
    }

    public static void swap(int i, int j) {

        a[i] = a[i] +  a[j];
        a[j] = a[i] - a[j];
        a[i] = a[i] - a[j];
    }
}