啊哈!算法之快速排序与桶排序

 

啊哈!算法之快速排序与桶排序

 

1.快速排序算法

快速排序由 C. A. R. Hoare(东尼·霍尔,Charles Antony Richard Hoare)在1960 年提出,之后又有许多人做了进一步的优化。
在数列种随机找出一个基准数,因为数列是杂乱的,所以取首项为基准数。
从后往前找到比基准数大的位置,再从前往后找到比基准数小的位置,交换元素;
右游标向前移动与左游标向后移动,它们相遇时用基准数的位置与相遇的位置交换。
此时原来数列以相遇的位置被划分为了两个需要排序的数列,再次执行上述过程;
当左游标在右游标的相同位置或右侧时,表示数列中只有一个元素或已没有需要排序的元素。
当所有的数列排序结束时,快速排序结束。

更多疑问可以参考《啊哈!算法》的『第1 章 一大波数正在靠近——排序』。

 

2.快速排序代码

代码如下:

package yuki.algorithm.sort;

import java.util.Random;

public class QuicksortDemo {

    public static void main(String[] args) {
        int[] a = new int[8];
        Random random = new Random();
        for(int i = 0; i < a.length; ++i)
            a[i] = random.nextInt(10);
        
        print(a);
        quicksort(a);
        print(a);
    }


    private static void quicksort(int[] a) {
        quicksort(a, 0, a.length - 1);
    }
    
    
    private static void quicksort(int[] a, int left, int right) {
        if(left >= right)
            return;
        int i = left;
        int j = right;
        int temp = a[left];
        while(i != j){
            while(a[j] >= temp && i < j)
                --j;
            while(a[i] <= temp && i < j)
                ++i;
            if(i < j)
                swap(a, i, j);
        }
        swap(a, left, i);
        quicksort(a, left, i-1);
        quicksort(a, i+1, right);
    }


    private static void swap(int[] a, int i, int j) {
        if(i == j || a[i] == a[j])
            return;
        System.out.println("[" + a[i] + "(" + i + "), " + a[j] + "(" + j + ")]");
        a[i] ^= a[j];
        a[j] ^= a[i];
        a[i] ^= a[j];
        print(a);
    }


    private static void print(int[] a) {
        for (int i = 0; i < a.length - 1; ++i)
            System.out.print(a[i] + "\t");
        System.out.println(a[a.length - 1]);
    }
}

 

运行结果如下:

6	9	0	8	5	4	6	5
[9(1), 5(7)]
6	5	0	8	5	4	6	9
[8(3), 4(5)]
6	5	0	4	5	8	6	9
[6(0), 5(4)]
5	5	0	4	6	8	6	9
[5(0), 4(3)]
4	5	0	5	6	8	6	9
[5(1), 0(2)]
4	0	5	5	6	8	6	9
[4(0), 0(1)]
0	4	5	5	6	8	6	9
[8(5), 6(6)]
0	4	5	5	6	6	8	9
0	4	5	5	6	6	8	9

 

3.桶排序算法

找到数列中的最大值,新建一个以这个最大值为长度的数组。
其下标用来存放待排序数组的数值,其值用来存放待排序数组的元素存放个数。
依次从按桶的顺序取出待排序数组的元素,并放回到原数列中,排序结束。

代码如下:

package yuki.algorithm.sort;

import java.util.Random;

public class BucketsortTest {

    public static void main(String[] args) {
        int[] a = new int[8];
        Random random = new Random();
        for(int i = 0; i < a.length; ++i)
            a[i] = random.nextInt(10);
        
        print(a);
        bucketsort(a);
        print(a);
    }
    

    private static void bucketsort(int[] a) {
        int max = 0;
        for (int i = 0; i < a.length; i++)
            if(max < a[i])
                max = a[i];
        
        int[] b = new int[max + 1];
        for (int i = 0; i < a.length; i++)
            ++b[a[i]];
        print(b);
        
        for (int i = 0, j = 0; j < b.length; ){
            if(b[j] == 0)
                ++j;
            else if(--b[j] >= 0)
                a[i++] = j;
        }
        print(b);
    }


    private static void print(int[] a) {
        for (int i = 0; i < a.length - 1; ++i)
            System.out.print(a[i] + "\t");
        System.out.println(a[a.length - 1]);
    }
}

 

运行结果如下:

7	4	9	4	8	7	3	3
0	0	0	2	2	0	0	2	1	1
0	0	0	0	0	0	0	0	0	0
3	3	4	4	7	7	8	9

 

4.冒泡排序代码

代码如下:

package yuki.algorithm.sort;

import java.util.Random;

public class BubblesortTest {

    public static void main(String[] args) {
        int[] a = new int[8];
        Random random = new Random();
        for(int i = 0; i < a.length; ++i)
            a[i] = random.nextInt(10);
        
        print(a);
        bubblesort(a);
        print(a);
    }

    
    private static void bubblesort(int[] a) {
        for(int i = a.length - 1; i > 0; --i)
            for(int j = 0; j < i; ++j)
                if(a[j] > a[j+1]){
                    System.out.println("[" + a[j] + "(" + j + "), " + a[j+1] + "(" + (j+1) + ")]");
                    a[j] ^= a[j+1];
                    a[j+1] ^= a[j];
                    a[j] ^= a[j+1];
                    print(a);
                }
    }
    
    
    private static void print(int[] a) {
        for (int i = 0; i < a.length - 1; ++i)
            System.out.print(a[i] + "\t");
        System.out.println(a[a.length - 1]);
    }
}

 

运行结果如下:

8	3	9	4	9	6	5	0
[8(0), 3(1)]
3	8	9	4	9	6	5	0
[9(2), 4(3)]
3	8	4	9	9	6	5	0
[9(4), 6(5)]
3	8	4	9	6	9	5	0
[9(5), 5(6)]
3	8	4	9	6	5	9	0
[9(6), 0(7)]
3	8	4	9	6	5	0	9
[8(1), 4(2)]
3	4	8	9	6	5	0	9
[9(3), 6(4)]
3	4	8	6	9	5	0	9
[9(4), 5(5)]
3	4	8	6	5	9	0	9
[9(5), 0(6)]
3	4	8	6	5	0	9	9
[8(2), 6(3)]
3	4	6	8	5	0	9	9
[8(3), 5(4)]
3	4	6	5	8	0	9	9
[8(4), 0(5)]
3	4	6	5	0	8	9	9
[6(2), 5(3)]
3	4	5	6	0	8	9	9
[6(3), 0(4)]
3	4	5	0	6	8	9	9
[5(2), 0(3)]
3	4	0	5	6	8	9	9
[4(1), 0(2)]
3	0	4	5	6	8	9	9
[3(0), 0(1)]
0	3	4	5	6	8	9	9
0	3	4	5	6	8	9	9

 

友情链接:)
[快速排序(Quicksort)的Javascript实现](http://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html)
[可视化对比十多种排序算法](http://blog.jobbole.com/72850/)
[啊哈!算法](http://www.amazon.cn/%E5%95%8A%E5%93%88-%E7%AE%97%E6%B3%95-%E5%95%8A%E5%93%88%E7%A3%8A/dp/B00KSWT268/)

 

如果你觉得本文对你有帮助,请点击右下方的推荐按钮,这样就可以让更多的小伙伴看到它了。

本文地址:http://www.cnblogs.com/kodoyang/p/AhaAlgorithm_Quicksort_Bucketsort.html

雨木阳子
2015年9月13日

 

你可能感兴趣的:(啊哈!算法之快速排序与桶排序)