排序算法 java实现2

继续排序算法

4.冒泡排序

从第一个开始，跟后面一个数比较，如果比后面大就交换位置，这样没完成一轮，就可以把最大的选出来

    public static <T extends Comparable<T>> T[] genericBubbleSort(T[] a) {
        int n = a.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (a[j].compareTo(a[j + 1]) > 0) {
                    T temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        return a;
    }

改进上面的冒泡排序

方案一：设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,

故在进行下一趟排序时只要扫描到pos位置即可

    public static <T extends Comparable<T>> T[] genericBubbleSortGai(T[] a) {
        int n = a.length;
        int i = n - 1;
        while (i > 0) {
            int pos = 0;
            for (int j = 0; j < i; j++) {
                if (a[j].compareTo(a[j + 1]) > 0) {
                    pos = j;
                    T temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
            i = pos;
        }
        return a;
    }

改进方案二：

两边同时进行  先找最大的  然后找最小的

    public static <T extends Comparable<T>> T[] genericBubbleSortGai2(T[] a) {
        int n = a.length;
        int low = 0, high = n - 1;
        int j;
        T tmp;
        while (low < high) {
            for (j = low; j < high; j++) {
                if (a[j].compareTo(a[j + 1]) > 0) {
                    tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                }
            }
            high--;
            for (j = high; j > low; j--) {
                if (a[j].compareTo(a[j - 1]) < 0) {
                    tmp = a[j];
                    a[j] = a[j - 1];
                    a[j - 1] = tmp;
                }
            }
            low++;
        }
        return a;
    }

改进方案三：

设置一个标志  如果有一趟没有发生交换  则排序完成

    public static <T extends Comparable<T>> T[] genericbubblesortgai3(T[] a) {
        int n = a.length;
        boolean flag = true;
        for (int i = 0; i < n - 1; i++) {
            if (!flag) {
                return a;
            }
            flag = false;
            for (int j = 0; j < n - i - 1; j++) {
                if (a[j].compareTo(a[j + 1]) > 0) {
                    flag = true;
                    T temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }

        }
        return a;
    }

5.快速排序

<快速排序> 基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
* 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。快速排序是一种不稳定的排序算法

    public static <T extends Comparable<T>> T[] QuickSortStart(T[] list) {
        quickSort(list, 0, list.length - 1);
        return list;
    }

    private static <T extends Comparable<T>> void quickSort(T[] list,
            int first, int last) {
        if (last > first) {
            int povitIndex = partition(list, first, last);
            quickSort(list, first, povitIndex - 1);
            quickSort(list, povitIndex + 1, last);
        }
    }

    private static <T extends Comparable<T>> int partition(T[] list, int first,
            int last) {
        /*
         * 把数组分为两组，将比povit小的数放在它前面，比povit大的数放在它后面
         */
        T povit = list[first];
        int low = first + 1;
        int high = last;

        while (high > low) {
            while (high > low && list[low].compareTo(povit) <= 0)
                low++;
            while (low <= high && list[high].compareTo(povit) > 0)
                high--;
            if (high > low) {
                T temp = list[high];
                list[high] = list[low];
                list[low] = temp;
            }
        }
        while (high > first && list[high].compareTo(povit) >= 0)
            high--;
        if (povit.compareTo(list[high]) > 0) {
            list[first] = list[high];
            list[high] = povit;
            return high;
        }
        return first;
    }

6.归并排序

将一个序列一直对半拆分，知道不能拆分，然后开始归并，归并采用插入排序

    public static <T extends Comparable<T>> T[] mergesort(T[] a) {
        T[] temp = a.clone();
        a = msort(a, temp, 0, a.length);
        return a;
    }

    public static <T extends Comparable<T>> T[] msort(T[] a, T[] temp,
            int first, int last) {
        if (first + 1 < last) {
            int mid = (first + last) / 2;
            msort(a, temp, first, mid);
            msort(a, temp, mid, last);

            int index1 = first;
            int index2 = mid;
            int index3 = first;
            while (index1 < mid && index2 < last) {
                if (a[index1].compareTo(a[index2]) < 0) {
                    temp[index3] = a[index1];
                    index1++;
                } else {
                    temp[index3] = a[index2];
                    index2++;
                }
                index3++;
            }
            while (index1 < mid) {
                temp[index3++] = a[index1++];
            }
            while (index2 < last) {
                temp[index3++] = a[index2++];
            }
            for (int i = first; i < last; i++)
                a[i] = temp[i];

        }
        return a;
    }

感觉就是把代码复制上去了，说的不是很清楚，，，还有一个堆排序没有写

最后对上面的排序算法做了下测试，生成10000个int数，进行排序，算时间

1.归并排序  50~60 ms之间

2.简单选择排序 135~155 ms之间

3.选择排序 220 ms    //可能是我数据没选好，10000个数，生成的随机数也是0~10000

4.快速排序  30ms  左右

5.冒泡排序 改进方案二快点  280ms

6.插入排序  70ms左右

然后还是10000个随机数，范围换成0~100000，结果基本每种排序的时间更短

所以排序的时间长短是和数据本身有关系的