简单排序

冒泡排序

冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最大数。如此下去，直至最终完成排序。
  由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
  用二重循环实现，外循环变量设为i，内循环变量设为j。外循环重复9次，内循环依次重复9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。

package pku.ss.datastructure.Sort;   
  
public class BubbleSort {   
    public static void main(String[] args) {   
        int max = 1000000;   
        ArrayBubble arr = new ArrayBubble(max);   
  
        long startTime = System.currentTimeMillis();   
        for (int j = 0; j < max; j++) {   
            double element = (double) (java.lang.Math.random() * (max - 1));   
            arr.insert(element);   
        }   
        long endTime = System.currentTimeMillis();   
  
        System.out.println("Sort time: " + (endTime - startTime) + " ms");   
  
    }   
}   
  
class ArrayBubble {   
    private int nElement;   
    private double[] array;   
  
    ArrayBubble(int max) {   
        array = new double[max];   
        nElement = 0;   
    }   
  
    public void insert(double x) {   
        // if (array.length == 10) {   
        // System.out.println("[ERROR]Out of memory!");   
        // System.out.println("[INFO]Atempt to insert into a full array");   
        // System.exit(0);   
        // } else {   
        array[nElement] = x;   
        nElement++;   
        // }   
    }   
  
    public void display() {   
        for (int i = 0; i < nElement; i++) {   
            System.out.print(array[i] + " ");   
        }   
        System.out.println();   
        System.out.println();   
    }   
  
    public void bubbleSort() {   
        int outer;   
        for (outer = nElement - 1; outer > 0; outer--)   
            for (int j = 0; j < outer; j++) {   
                if (array[j] > array[j + 1]) {   
                    swap(j, j + 1);   
                }   
            }   
    }   
  
    private void swap(int x, int y) {   
        double temp;   
        temp = array[x];   
        array[x] = array[y];   
        array[y] = temp;   
    }   
}  

 
选择排序

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，以此类推，最后比较a[1]与a[n]的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，以此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。
  优点：稳定，比较次数与冒泡排序一样；
  缺点：相对之下还是慢。

package pku.ss.datastructure.Sort;   
  
public class SelectSort {   
    public static void main(String[] args) {   
        int max = 1000000;   
        ArraySel arr = new ArraySel(max);   
  
        long startTime = System.currentTimeMillis();   
        for (int j = 0; j < max; j++) {   
            double element = (double) (java.lang.Math.random() * (max - 1));   
            arr.insert(element);   
        }   
        long endTime = System.currentTimeMillis();   
  
        System.out.println("Sort time: " + (endTime - startTime) + " ms");   
    }   
}   
  
/** ***************************************** */  
class ArraySel {   
    private double[] a;   
    private int nElement;   
    //--------------------------------------------------------   
    public ArraySel(int max) {   
        a = new double[max];   
        nElement = 0;   
    }   
    //--------------------------------------------------------   
    public void insert(double element) {   
        a[nElement] = element;   
        nElement++;   
    }   
    //--------------------------------------------------------   
    public void display() {   
        for (int i = 0; i < nElement; i++)   
            System.out.print(a[i] + " ");   
        System.out.println();   
    }   
    //--------------------------------------------------------   
    public void selectSort() {   
        int out, in, min;   
        for (out = 0; out < nElement - 1; out++) {   
            min = out;   
            for (in = out + 1; in < nElement; in++) {   
                if (a[in] < a[min]) {   
                    min = in;   
                }   
            }   
            if(min!=out)   
                swap(min, out);   
        }   
    }   
    //--------------------------------------------------------   
    private void swap(int x, int y) {   
        double temp;   
        temp = a[x];   
        a[x] = a[y];   
        a[y] = temp;   
    }   
}  

 

插入排序

已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b[1]当作n=1的数组a）
  优点：稳定，快；
  缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。

package pku.ss.datastructure.Sort;   
  
public class InsertionSort {   
    public static void main(String[] args) {   
        int max = 1000000;   
        ArrayIns arr = new ArrayIns(max);   
  
        long startTime = System.currentTimeMillis();   
        for (int j = 0; j < max; j++) {   
            double element = (double) (java.lang.Math.random() * (max - 1));   
            arr.insert(element);   
        }   
        long endTime = System.currentTimeMillis();   
  
        System.out.println("Sort time: " + (endTime - startTime) + " ms");   
    }   
}   
  
class ArrayIns {   
    private double[] a;   
    private int nElement;   
  
    // --------------------------------------------------------   
    public ArrayIns(int max) {   
        a = new double[max];   
        nElement = 0;   
    }   
  
    // --------------------------------------------------------   
    public void insert(double element) {   
        a[nElement] = element;   
        nElement++;   
    }   
  
    // --------------------------------------------------------   
    public void display() {   
        for (int i = 0; i < nElement; i++)   
            System.out.print(a[i] + " ");   
        System.out.println();   
    }   
  
    // --------------------------------------------------------   
    public void insertionSort() {   
        int out, in;   
        for (out = 1; out < nElement; out++) {   
            double temp = a[out];   
            in = out;   
            while (in > 0 && a[in - 1] >= temp) {   
                a[in] = a[in - 1];   
                in--;   
            }   
            a[in] = temp;   
        }   
    }   
    // --------------------------------------------------------   
  
}