排序算法总结

排序算法总结

1.几种基本的代码实现

冒泡排序：

 /**
     * 冒泡排序
     * @param arr 待排序数组
     * @return
     */
 public void BubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
    }

快速排序：

/**
     * 快速排序
     * @param arr   待排数组
     * @param start 下标
     * @param end   上标
     */
    public void QuickSort(int[] arr, int start, int end) {
        if (start > end)
            return;
        //下标
        int low = start;
        //上标
        int high = end;
        //基准数
        int temp = arr[start];

        while (low < high) {
            while (temp <= arr[high] && low < high)
                high--;
            while (temp >= arr[low] && low < high)
                low++;
            if (low < high) {
                int t = arr[high];
                arr[high] = arr[low];
                arr[low] = t;
            }
        }

        arr[start] = arr[low];
        arr[low] = temp;

        QuickSort(arr, start, high - 1);
        QuickSort(arr, high + 1, end);
    }

插入排序：

/**
     * 插入排序
     * @param arr 待排数组
     */
    public void InsertSort(int[] arr) {
        int len = arr.length;
        if (arr.length <= 1)
            return;
        for (int i = 1; i < len; i++) {
            int temp = arr[i];
            for (int j = 0; j < i; j++) {
                if (arr[j] > temp) {
                    int t = i;
                    while (t > j) {
                        arr[t] = arr[t - 1];
                        t--;
                    }
                    arr[j] = temp;
                    break;
                }
            }
        }
    }

选择排序：

/**
     * 选择排序
     * @param arr 待排数组
     */
    public void SelectSort(int[] arr) {
        int len = arr.length;
        int minindex = 0;
        for (int i = 0; i < len; i++) {
            int min = 10000000;
            for (int j = i; j < len; j++) {
                if (arr[j] < min) {
                    min = arr[j];
                    minindex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minindex];
            arr[minindex] = temp;
        }
    }

2.几种基本的排序算法比较

排序算法	时间复杂度	稳定性	特点
冒泡排序	O(n2)	稳定	一般情况下，特别是在逆序时，它很不理想。它是对数据有序性非常敏感的排序算法。
插入排序	O(n2)	稳定	插入排序将要优于冒泡排序。直接插入法也是一种对数据的有序性非常敏感的一种算法。在有序情况下只需要经过n-1次比较，在最坏情况下，将需要n(n-1)/2次比较
选择排序	O(n2)	不稳定	对数据的有序性不敏感。它虽然比较次数多，但它的数据交换量却很少。所以我们将发现它在一般情况下将快于冒泡排序
快速排序	O(nlogn) 平均时间, O(n2) 最坏情况	不稳定	在理论上讲，如果每次能均匀划分序列，它将是最快的排序算法， 因此称它作快速排序。虽然很难均匀划分序列，但就平均性能而言，它仍是基于关键字比较的内部排序算法中速度最快者。
堆排序	O(nlogn)	不稳定	一般在小规模的序列中不合适，但对于较大的序列，将表现出优越的性能