快速排序

    static void _quick_sort(int array[], int start, int end){  
        int middle;  
        if(start >= end)  
            return;  

        middle = get_middle(array, start, end);  
        _quick_sort(array, start, middle -1);  
        _quick_sort(array, middle + 1, end);  
    }  

    private
 
 static int get_middle(int[] array, int start, int end) {
        int tmp = array[start];    //陣列的第一個作為中軸  
        while (start < end) {  
            while (start < end && array[end] > tmp) {  
                end--;  
            }  
            array[start] = array[end];   //比中軸小的記錄移到低端  
 

            while (start < end && array[start] <= tmp) {  
                start++;  
            }  
            array[end] = array[start];   //比中軸大的記錄移到高階  
        }  
        array[start] = tmp;              //中軸記錄到尾  
        output(array,"step"+ ++index +":");        
        return
 
 start;                   //返回中軸的位置  
    }

    static void quick_sort(int array[], int length){  
        index = 0;
        if(null == array || 0 == length)  
            return;  
        _quick_sort(array, 0, length-1);  
        output(array,"");        
    }

改進冒泡

    private static void bubble_sort(int[] array) {
        index = 0;
        int i_last_swap = -1;  
        int i_last_swap_tmp = 0;  
        for (int i = 0; i < array.length 
                && (i_last_swap_tmp != i_last_swap) //排除已有序的區間
                && (i_last_swap_tmp != array.length-1);//上次排序僅交換了最後兩位
                ++i){  
            i_last_swap = i_last_swap_tmp;
            System.out.println("["+i_last_swap+","+ (int)(array.length-1) +"]:");
            for (int j = array.length - 1; j > i_last_swap; --j)  //從後往前冒泡
            {  
                if (array[j] < array[j - 1])  
                {  
                    int i_tmp = array[j];  
                    array[j] = array[j - 1];  
                    array[j - 1] = i_tmp;  

                    i_last_swap_tmp = j;  
                    output(array, "last_swap_loctaion:"+j+"\nsetp"+ ++index +":");
                }  
            }
            if (i_last_swap_tmp == i_last_swap)  
            {  
                System.out.println("已有序！");
            }  
        }  
        return;  
    }
    //雙向掃描冒泡，效率最高的冒泡，在上一個改進的基礎上每次反向冒泡一次
    public static void ImproveBubble3(int [] array){
        int low, up, _index, i;
        low = 0;
        up = array.length - 1;
        _index = low;

        while( up > low)
        { 
            System.out.println("["+ low +","+ up +"]:");
            for( i = low; i < up; i++)        //從上向下掃描
            {
                if(array[i] > array[i + 1])
                {
                    int i_tmp = array[i];  
                    array[i] = array[i + 1];  
                    array[i + 1] = i_tmp;  
                    _index = i; 
                    output(array, "last_swap_loctaion:"+ i +"\nsetp"+ ++index +":");
                }
            }

            up = _index;                     //記錄最後一個交換的位置
            for(i = up; i > low; i--)             //從最後一個交換位置處從下向上掃描
            {
                if(array[i] < array[i-1])
                {
                    int i_tmp = array[i];  
                    array[i] = array[i - 1];  
                    array[i - 1] = i_tmp;  
                    _index = i;
                    output(array, "last_swap_loctaion:"+ i +"\nsetp"+ ++index +":");
                }
            }
            low = _index;                    //記錄最後一個交換的位置
        }
    }