数组常用排序算法

排序算法总结

常用排序算法

冒泡排序BubbleSort

直接选择排序SelectSort

快速排序QuickSort

今天复习到数组部分，发现数组部分中比较重要的可能就是排序这个问题了。其他像遍历、填充替换数组元素、复制数组、查询数组等都相对简单，就把排序部分稍作整理。没什么高深知识，随便看看就好。
首先贴出冒泡排序和直接选择排序的代码，两者相近且比较简单，本来打算分着写更明显，不过看着实在太短了，就在一个类中写出了，类名也没改，大家将就看吧=。=

public class BubbleSort {//冒泡排序和直接选择排序

    public static void main(String[] args) {
        int a[]=new int[]{5,3,2,4,1};
        bubble(a);
        select(a);
    }
    public static void bubble(int arr[]){
        int temp;
        for(int i=0;ifor(int j=0;j1-i;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        for(int x:arr){
            System.out.print(x+" ");
        }
        System.out.println();
    }
    public static void select(int arr[]){

        for(int i=0;iint index = 0;
            for(int j=0;j1-i;j++){
                if(arr[index]1]){
                    index=j+1;
                }
            }
            int temp;
            temp=arr[arr.length-1-i];
            arr[arr.length-1-i]=arr[index];
            arr[index]=temp;
        }
        for(int x:arr){
            System.out.print(x+" ");
        }
    }
}

在我看来，冒泡排序和直接选择排序相近。两者的比较次数相同，交换次数：冒泡排序>直接选择排序，代码有一定的相似性。
两者代码都是有嵌套的两层for循环作为主体，冒泡排序是相邻两数比较，若前者大于后者，则交换位置，直接选择排序则是一轮循环下来用一个index标记此轮循环的最大值，然后在内层for循环结束后进行本轮最后一个位置和最大值的交换。
而快速排序和他们则有所区别。

public class QuickSort {
    public static void main(String[] args) {
        int arr[] = { 5, 2, 3, 1, 4 };
        quickSort(arr, 0, arr.length - 1);
        //quick(arr,0,arr.length-1);
        for (int x : arr) {
            System.out.println(x);
        }
    }

    public static void quickSort(int arr[], int top, int end) {
        if (top < end) {
            int p = partition(arr, top, end);
            quickSort(arr, top, p);
            quickSort(arr, p + 1, end);
        }

    }

    public static int partition(int arr[], int top, int end) {//每次调用就完成一轮快排
        int x = arr[top];
        int i = top, j = end + 1;
        while (true) {
            while (arr[++i] < x && i < end)//从左开始找到比top值大得数
                ;
            while (arr[--j] > x)//从右开始找到比top值小得数
                ;
            if (i >= j)//判断两个数是否相遇
                break;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;//不相遇就交换两个数
        }
        arr[top] = arr[j];
        arr[j] = x;
        return j;

    }
    public static void quick(int[] a, int left, int right){//sort函数源码,
        for (int i = left, j = i; i < right; j = ++i) {//第一次进去时，i和j总相等
            int ai = a[i + 1];//令ai=当前位置的下一个，记录下新的要排序的数的值
            while (ai < a[j]) {//通过交换找到ai值在0-i+1范围内应当在的位置，这不是快速排序，
                a[j + 1] = a[j];
                if (j-- == left) {
                    break;
                }
            }
            a[j + 1] = ai;//到此会发现i+1位之前都是从小到大排序，即每完成一轮循环，数组前面的数就多一个有序的。
        }
    }

}

快速排序则和他们完全不同。快速排序用到了分治思想，用递归算法达到将数组分割，简化排序过程。
每一次调用quickSort()方法都会将当前数组分成三部分：首项、>首项、<首项。
分别在后两个数组中再调用quickSort()方法，分割的下标则是由partition()方法决定的partition为“划分”意，在这里用来找到首项应该在的下标位置。
上述代码中还出现了一个方法quick()，这个方法是从Arrays.sort()方法的源码中找到的，一开始我认为是快速排序的一个非递归化变形，后来发现似乎不是如此，这个方法是从第一个数开始，不断的往后扩展，没添加一个数就找到这个数应当在的前面的位置，感觉类似直接选择排序的倒叙版，但是他每一次又不会遍历整个数组，所以说我也拿不准究竟如何形容他，不过他玲珑的代码段还是惊艳到我了，果然编程是一门艺术活，总有一些神奇的代码片有着匪夷所思的用处。
如有不妥，敬请交流指教。