java - 简单排序

冒泡排序

package testSort;
/**
 * 10-7 冒泡排序
 * 五个数,每轮选出一个最大的数,一轮选一个数,四轮之后,还有一个数就是最小的不需要选了,需要四轮,即array.length-1
 * 第一轮有五个数,需要比较四次
 * 第二轮有四个数,需要比较三次
 * 第三轮有三个数,需要比较两次
 * 第四轮有两个数,需要比较一次
 * 外层变量控制比较轮数，内层控制比较次数，例如5个数的数组，比较5轮，第一轮比较4次，第二轮比较3次。。。
 * @author Administrator
 *
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {5,8,3,0,7};
        
        for(int i = 0; i < array.length-1; i++) {
            for(int j = 0; j < array.length-1-i; j++) {
                int temp;
                /**从小排到大，假设前面的数比后面的都大，如果不这样假设，那岂不是不用排序了(即前面的都比后面的小)，实际当中没人
                *知道数组里面的大小，这样的话如果前面的都比后米的小，就不用重新赋值，反之则重新赋值
                */
                if(array[j] > array[j+1]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        
        for(int k = 0; k < array.length; k++) {
            System.out.print(array[k]);
        }
    }
}

快速排序

package testSort;
/**
 * 2011-10-09 快速排序
 * @author Administrator
 *
 */
public class QuickSort3 {
    static int times = 0;//排了几次
    //从小到大的排序方法
    public static void qucikSort(int[] array, int low, int high) {
        int i = low,j = high;
        if(low < high) {
            int refVal = array[i];//调用此方法只有一开始执行了，后面的代码都是while里的代码在执行，所以refval一直都是37没变，假定的中间值
            while(i != j) {
                times++;
                /**
                 * 从后向前寻找较小值
                 */
                while (i < j && array[j] >= refVal) {
                    j--;
                }
                
                if (i < j) {
                    array[i] = array[j];
                    i++;
                }
                
                /**
                 * 从前向后寻找较大值
                 */
                while (i < j && array[i] < refVal) {
                    i++;
                }
                if (i < j) {
                    array[j] = array[i];
                    j--;
                }
                System.out.print("第" + times + "次交换后的数据：");
                print(array);
            }
            
            //此时i=j,且空出一个位置,将基准值传给array[i]
            array[i] = refVal;
            qucikSort(array, low, j-1);
            qucikSort(array, i+1, high);
            
        }
    }
    
    public static void print(int[] array) {
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        int[] array = {37,45,4,9,333,66,73,3,0};
        System.out.print("最初的数据：");
        print(array);
        
        qucikSort(array, 0, array.length-1);
        System.out.print("排序的数据：");
        print(array);
    }
}

/**
 * 
 */
package testSort;

/**
 * @description
 *                    此类是 百度百科中的快速排序
 * @package name      
 *                    testSort.QuickSortByNet.java
 * @author            
 *                    lj
 * @since              
 *                    2012-4-29下午04:52:16
 */
public class QuickSortByNet {
    public static void sort(Comparable[] data,int low,int high) {
        // 枢纽元，一般以第一个元素为基准进行划分
        int i = low;
        int j = high;
        if (low < high) {
            // 从数组两端交替地向中间扫描
            Comparable pivotKey = data[low];
            // 进行扫描的指针i,j;i从左边开始，j从右边开始
            while (i < j) {
                while (i < j && data[j].compareTo(pivotKey) > 0) {
                    j--;
                }// end while
                if (i < j) {
                    // 比枢纽元素小的移动到左边
                    data[i] = data[j];
                    i++;
                }// end if
                while (i < j && data[i].compareTo(pivotKey) < 0) {
                    i++;
                }// end while
                if (i < j) {
                    // 比枢纽元素大的移动到右边
                    data[j] = data[i];
                    j--;
                }// end if
            }// end while
            // 枢纽元素移动到正确位置
            data[i] = pivotKey;
            // 前半个子表递归排序
            sort(data,low,i - 1);
            // 后半个子表递归排序
            sort(data,i + 1,high);
        }// end if
    }// end sort
    public static void main(String[] args) {
        // 在JDK1.5版本以上，基本数据类型可以自动装箱
        // int,double等基本类型的包装类已实现了Comparable接口
        Comparable[] c = { 4,9,23,1,45,27,5,2 };
        sort(c,0,c.length - 1);
        for (Comparable data : c) {
            System.out.println(data);
        }
    } 
}

选择排序

package testSort;
/**
 * 2011-10-8 选择排序
 * @author Administrator
 *
 */
public class SelectSort {
    public static int[] array = {1,8,3,4,7};
    
    public static void main(String[] args) {
        select1();
        System.out.println();
        select2();
        System.out.println();
        select3();
        System.out.println();
        /*select2();
        System.out.println();*/
    }
    
    private static void select1() {
        for(int i = 0; i < array.length; i++) {//选出一个数
            for(int j=i+1; j < array.length; j++) {//与选出之后的每一个数做比较
                int temp;
                if(array[i] > array[j]) {
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
            System.out.print(array[i]);
        }
    }
    
    private static void select2() {
        for(int i = 0; i < array.length; i++) {
            int min = i;//假设最小的数就在i这个索引这里
            for(int j=min+1; j < array.length; j++) {//与选出的最小的数后面的数做比较
                if(array[min] > array[j]) { //如果后面的数还比前面的数小
                    min = j;                //就将此数的索引传给MIN
                }
            }
            if(min != i) {
                int temp = array[i];
                array[i] = array[min];
                array[min] = temp;
            }
            System.out.print(array[min]);
        }
    }
    /**
     * 将变量的定义位置作出调整,减少内存的占用
     */
    private static void select3() {
        int min,temp; 
        for(int i = 0; i < array.length; i++) {
            min = i;//假设最小的数就在i这个索引这里
            for(int j=min+1; j < array.length; j++) {//与选出的最小的数后面的数做比较
                if(array[min] > array[j]) { //如果后面的数还比前面的数小
                    min = j;                //就将此数的索引传给MIN
                }
            }
            if(min != i) {
                temp = array[i];
                array[i] = array[min];
                array[min] = temp;
            }
            System.out.print(array[min]);
        }
    }
}