Java 排序

转载自：http://my.oschina.net/luffyke/blog/49217

排序操作就是：将一个按值无序的数据序列转换成为一个按值有序的数据序列的过程。

 

冒泡排序，顾名思义，就像水底的气泡不断的向上“冒”。速度也是最慢的，时间复杂度O(n^2)，具体实现代码如下:

Java版本的，因为C语言要传多个数组的长度做参数进去(因为C语言的数组其实已经“退化”成指针了)，哈哈！

?
1
2
3
4
5
6
7
8
9
10
11
12
public void bubble_sort(int[] a){
    int temp;
    for(int i = 0; i < a.length; ++i){
        for(int j = 0; j < a.length-1; ++j){
            if(a[j] > a[j+1]){
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

直接插入排序

下面是排序过程：

初始 : {[3], 6, 4, 2, 9, 8, 7}

1 : {[3, 6], 4, 2, 9, 8, 7}

2 : {[3, 4, 6], 2, 9, 8, 7}

3 : {[2, 3, 4, 6], 9, 8, 7}

4 : {[2, 3, 4, 6, 9], 8, 7}

5 : {[2, 3, 4, 6, 8, 9], 7}

6 : {[2, 3, 4, 6, 7, 8, 9]}

代码实现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
public void insert_sort(int[] a){
    int k = 0, temp;
    for(int i = 1; i < a.length; ++i){
        temp = a[i];
        k = i;
        while(k > 0 && temp < a[k-1]){
            a[k] = a[k-1];
            k--;
        }
        a[k] = temp;
    }
}

选择排序， 就是序列中选择最小的与第1个交换，再选择最小的与第2个交换，以此类推。

代码实现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void select_sort(int[] a){
    int k = 0;
    int min;
    for(int i = 0; i < a.length; ++i){
        min = a[i];
        k = i;
        for(int j = i+1; j < a.length; ++j){
            if(a[j] < min){
                min = a[j];
                k = j;
            }
        }
        a[k] = a[i];
        a[i] = min;
    }
}

希尔排序，又称为“缩小增量排序”，是对插入排序的一种改进。

就是按增量gap以此把序列分为若干个子序列，然后子序列进行其他排序方法，直到增量gap=1为止，代码具体实现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void shell_sort(int[] a){
    int gap = a.length / 2;
    int temp;
    int flag = 0;
    while (gap >= 1) {
        do {
            flag = 0;
            for (int i = 0; i < a.length - gap; ++i) {
                if (a[i] > a[i + gap]) {
                    temp = a[i];
                    a[i] = a[i + gap];
                    a[i + gap] = temp;
                    flag = 1;
                }
            }
        } while (flag != 0);
        gap = gap / 2;
    }
}

接下要讲的是目前认为最好的一种排序方法 - 快速排序：

原理就是按基准元素(一般是序列的第一个元素)把序列分为前后两个子序列，前面是小于等于基准元素的，后面的是大于基准元素的，然后再在子序列中用同样的方法进行排序，其实就是一个递归的过程。

最差时间复杂度 \Theta(n^2)
最优时间复杂度 \Theta(n\log n)
平均时间复杂度 \Theta(n\log n)

代码具体实现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void quick_sort(int[] a, int start, int end) {
    int i = 0, j = 0;
    int temp;
    if (end - start < 1) {
        return;
    }
    i = start;
    j = end;
    while (i < j) {
        while (a[i] <= a[start] && i < end) {
            i++;
        }
        while (a[j] > a[start] && j >= start) {
            j--;
        }
        if (i < j) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        } else {
            break;
        }
    }
    temp = a[start];
    a[start] = a[j];
    a[j] = temp;
 
    fast_sort(a, start, j - 1);
    fast_sort(a, j + 1, end);
}

上面讲的都是在同一个序列里面排序，意思就是空间复杂度是T(n)。

下面这个算法是以空间换时间，速度相对于前面的所有算法，确实快了很多，不过序列中不能存在大于序列长度的数据。

代码具体实现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
public void fast_sort(int a[]){
    int k = 0;
    int[] nums = new int[a.length];
    for(int i = 0; i < a.length; ++i){
        nums[a[i]]++;
    }
    for(int i = 0; i < a.length; ++i){
        while(nums[i] > 0){
            a[k++] = i;
            nums[i]--;
        }
posted @ 2015-04-27 16:14  julieyuan  阅读(123)  评论(0)  编辑  收藏  举报