排序类

package com.jdk7.chapter2.sort;
/**
 * 排序功能接口
 * @author Administrator
 *
 */
public interface SortNumber {
    public int[] sortASCNumber(int[] intArray);
}

package com.jdk7.chapter2.sort;

/**
 * 按升序选择排序数字
 * @author Administrator
 *
 */
public class SelectSort implements SortNumber {

    @Override
    public int[] sortASCNumber(int[] intArray) {
        if(intArray==null){
            return null;
        }else{
            int[] array = intArray.clone();
            for(int i=0;i<array.length;i++){
                for(int j=i;j<array.length;j++){
                    if(array[i]>array[j]){
                        swithNumber(array,i,j);
                    }
                }
            }
            return array;
        }
    }
    
    public void swithNumber(int[] array,int a,int b){
        int temp;
        temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
}

package com.jdk7.chapter2.sort;
/**
 * 按升序冒泡排序数字
 * @author Administrator
 *
 */
public class BubbleSort implements SortNumber {

    @Override
    public int[] sortASCNumber(int[] intArray) {
        if(intArray==null){
            return null;
        }else{
            int[] array = intArray.clone();
            int maxChangeTimes = array.length-1;
            int changeTime = 0;
            boolean changeTag = true;
            //如果上一轮的最后一对两两对比没有进行交换则停止循环，每一轮循环找到最大数排在数组最后面
            while((changeTime<maxChangeTimes) && changeTag){
                System.out.println("while");
                for(int i=0;i<(maxChangeTimes-changeTime);i++){
                    System.out.println(array[i]+" "+array[i+1]);
                    changeTag = false;
                    if(array[i]>array[i+1]){
                        switchNumber(array,i,i+1);
                        changeTag = true;
                    }
                }
                changeTime++;
                System.out.println("changeTime: "+changeTime);
                System.out.println("changeTag: "+changeTag);
            }
            return array;
        }
    }
    public void switchNumber(int[] array,int a,int b){
        int temp;
        temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
}

package com.jdk7.chapter2.sort;
/**
 * 线性插入排序
 * @author Administrator
 *
 */
public class LinearInsertSort implements SortNumber {

    @Override
    public int[] sortASCNumber(int[] intArray) {
        if(intArray==null){
            return null;
        }else{
            int[] array = intArray.clone();
            int index = 0;
            int size = array.length;
            int temp = 0;
            for(int i=1;i<size;i++){
                temp = array[i];
                index = i;
                
                System.out.println("(temp<array[index-1]) = "+(temp<array[index-1]));
                System.out.println("(index>0) = "+((index>0)));
                //每次循环中的数组都会按照升序排列,while中的短路与条件必须先要有index>0，然后再有右面的条件，否则数组的索引值会小于0
                while((index>0) && (temp<array[index-1])){
                    System.out.println(array[index-1]+" "+temp);
                    array[index] = array[index-1]; 
                    index--;
                }
                System.out.println("array[index]: "+array[index]);
                array[index] = temp;        //放在while里面和while外面是一样的效果，在每次while执行时一起执行
                SortTest.printIntArray(array);
            }
            return array;
        }
    }
}

package com.jdk7.chapter2.sort;
/**
 * 快速排序
 * @author Administrator
 *
 */
public class QuickSort implements SortNumber {

    @Override
    public int[] sortASCNumber(int[] intArray) {
        if(intArray==null){
            return null;
        }else{
            int[] array = intArray.clone();
            return quickSort(array, 0, array.length-1);
        }
    }
    
    public int[] quickSort(int[] array, int first, int last){
        if(first<last){
            int pos = partition(array, first, last);
            System.out.println("pos = "+pos);
            //所有左分治执行完成以后，再执行右分治
            quickSort(array, first, pos-1);
            quickSort(array, pos+1, last);
        }
        return array;
    }
    
    public int partition(int[] array, int first, int last){
        System.out.println("调用partition方法");
        int temp = array[first];
        int pos = first;
        for(int i=first+1;i<=last;i++){
            if(array[i]<temp){
                pos++; 
                //连续比第一位小都不需要换位，遇到比第一位大的数跳过进行下一次循环，在后面的循环中遇到比第一位小的值则将该值与大值进行换位，直到最大值在最末位
                swap(array, pos, i);    
                SortTest.printIntArray(array);
            }
        }
        //将数组中第二大数值放置在倒数第二位
        swap(array, first, pos);
        System.out.println("将分治点和第一个值进行交换");
        SortTest.printIntArray(array);
        return pos;
    }
    
    public void swap(int[] array, int src, int dest){
        int temp = array[src];
        array[src] = array[dest];
        array[dest] = temp;
    }

}