七大经典排序-序

今天是开篇，得要吹一下算法，算法就好比程序开发中的利剑，所到之处，刀起头落。

针对现实中的排序问题，算法有七把利剑可以助你马道成功。

首先排序分为四种： 

      交换排序： 包括冒泡排序，快速排序。

      选择排序： 包括直接选择排序，堆排序。

      插入排序： 包括直接插入排序，希尔排序。

      合并排序： 合并排序。

首先看一个简单的排序

package algorithm;

import java.util.ArrayList;
import java.util.Random;

public class BubbleSort {

    /**
     * @param args
     * 七大排序
     */
    public static void main(String[] args) {
        multiSort();
    }
    
    public static ArrayList createArrayList()
    {
        ArrayList value = new ArrayList();
        for (int i = 0; i < 10000; i++)
        {
            //产生100000以内的随机数
            value.add(new Random().nextInt(100000));
        }
        
        return value;
    }
    //五次比较
    public static void multiSort()
    {
        for (int i = 0; i < 5; i++){
            ArrayList value = createArrayList();
            System.out.println("\n第" + (i+1) + "次比较：");
            //获得当前的毫秒数
            long start_time = System.currentTimeMillis();
            value = buble(value);
            long end_time = System.currentTimeMillis();
            System.out.println("\n冒泡排序耗费时间：" + (end_time - start_time));
            System.out.println("输出前是十个数：" + (value.subList(0, 20)).toString());
        }
    }
    
    public static ArrayList buble(ArrayList value)
    {
        for (int i = 0; i < value.size() - 1; i++){
            for (int j = 0; j < value.size() - 1 - i; j++){
                if (value.get(j) < value.get(j+1)){
                    int temp = value.get(j);
                    value.set(j, value.get(j+1));
                    value.set(j+1, temp);
                }
            }
        }
        
        return value;
    }
}

运行结果如图：

现在稍微改版一下，让其支持多个排序，并且比较运算结果

package algorithm;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Random;

public class Sort {

    /**
     * @param args
     * 冒泡排序
     */
    public static void main(String[] args) {
        try {
            new Sort().multiSort();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public ArrayList createArrayList()
    {
        ArrayList value = new ArrayList();
        for (int i = 0; i < 10000; i++)
        {
            //产生100000以内的随机数
            value.add(new Random().nextInt(100000));
        }
        
        return value;
    }
    //五次比较
    public void multiSort() throws Exception
    {
        for (int i = 0; i < 5; i++){
            ArrayList value = createArrayList();
            System.out.println("\n第" + (i+1) + "次比较：");
            printSort((ArrayList)value.clone(), "chooseSort", "选择");
            printSort((ArrayList)value.clone(), "bubleSort", "冒泡");
            //这里添加需要排序的方法
        }
    }
    
    private void printSort(final ArrayList value, String method, String sortName) throws Exception
    {
        //获得当前的毫秒数
        long start_time = System.currentTimeMillis();
        ArrayList sort_value = new ArrayList();
        sort_value = extracted(method, value);
        long end_time = System.currentTimeMillis();
        System.out.println("\n"+sortName+"排序耗费时间：" + (end_time - start_time));
        System.out.println("输出前是十个数：" + (sort_value.subList(0, 10)).toString());
    }

    private ArrayList extracted(String methodName, ArrayList value) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
        Sort sort = new Sort();
        Class clazz = sort.getClass(); 
        Method method = clazz.getDeclaredMethod(methodName, ArrayList.class); 
        
        return (ArrayList) method.invoke(sort, value);
    }
    //冒泡排序
    private ArrayList bubleSort(ArrayList value)
    {
        
        return value;
    }
    //快速排序
    public ArrayList fastSort(ArrayList value){
        
        return value;
    }
    //选择排序
    public ArrayList chooseSort(ArrayList value)
    {
        
        return value;
    }
    //堆排序
    public ArrayList heapSort(ArrayList value){
        
        return value;
    }
    //希尔排序
    public ArrayList shellSort(ArrayList value){

        return value;
    }
    //插入排序
    public ArrayList insertSort(ArrayList value){
        
        return value;
    }
    //归并排序
    public ArrayList mergeSort(ArrayList value){
            
        return value;
    }
    
}

我们在接下的几章中着重介绍排序的实现方式

七大经典排序【 交换排序】之冒泡排序

七大经典排序【 交换排序】之快速排序