Java数据结构和算法---排序

几种排序

冒泡排序

• 原理：

  冒泡排序：相邻两个数据进行比较，如果后面的比前面的数据小则进行交换，自然最大的那个数据被排到了最后。但是 ，效率很低，遍历了N次，同时需要交换
  N + （N-1）+(N-2)+...+2+1   ~ N*(N-1)/2   次
  

• 代码

 public class BubbleSort {
    public static void main(String[] args) {
        sort();
    }

    public static void sort() {
        int array[] = new int[]{1, 4, 46, 53, 2425, 42, 34, 5, 234, 46, 3, 456, 456, 4, 656, 24, 626, 26256, 56, 256, 256, 657, 534};
        int temp=0;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {//我们发现这里有弊端就是每次都需要交换，效率低
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

选择排序

• 选择排序
  序—— 我们发现冒泡排序的弊端其中一点是每次都需要交换，达到的效果是把最大的那一个排到了最后，那么，我们是不是可以不交换那么多次来达到这样的效果呢？
• 原理
  在冒泡的基础之上，我们并不需要每次都去换位，而是每次找出最小的放在前面，这样每循环一次只需要交换一次。

public class SelectSort {
    public static void main(String[] args) {
        sort();
    }

    public static void sort() {
        int array[] = new int[]{1, 4, 46, 53, 2425, 42, 34, 5, 234, 46, 3, 456, 456, 4, 656, 24, 626, 26256, 56, 256, 256, 657, 534};
        int min = 0;
        for (int i = 0; i < array.length - 1; i++) {
            min=i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[min]) {
                    min = j;
                }
            }
            swip(array, min, i);
        }
        System.out.println(Arrays.toString(array));
    }

    private static void swip(int[] array, int min, int i) {
        int temp = array[i];
        array[i] = array[min];
        array[min] = temp;
    }
}

快速排序

• 快速排序
  我们知道在有序的查询操作中二分法的效率是很高的，时间复杂度为 O(logN),其原理也很简单。但是我们发现以上的两种排序算法时间复杂度是很高的，那么我们能否去借鉴二分法的原理来提高我们排序的效率呢，答案是肯定的！
• 原理
  请看 http://blog.csdn.net/yzllz001/article/details/50982841 讲解的很到位。
• 代码实现

public class FastSort {
    public static void main(String[] args) {
        int[] a = {12, 20, 5, 16, 15, 45, 97, 245, 32, 8777, 6788, 23, 34, 234, 524, 5684, 2345, 4264, 1, 30, 45, 23, 9};
        int start = 0;
        int end = a.length - 1;
        sort(a, start, end);
        System.out.println(Arrays.toString(a));

    }

    public static void sort(int[] a, int low, int high) {
        int start = low;
        int end = high;
        int key = a[low];//通过这个“中间值”把数据一分为二，然后两边的继续“二分”
        while (end > start) {
            //从后往前比较
            while (end > start && a[end] >= key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if (a[end] <= key) {
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //从前往后比较
            while (end > start && a[start] <= key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
            if (a[start] >= key) {
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
            //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        }
        //递归
        if (start > low) sort(a, low, start - 1);//左边序列。第一个索引位置到关键值索引-1
        if (end < high) sort(a, end + 1, high);//右边序列。从关键值索引+1到最后一个
    }

}