排序

1.插入排序

public class InsertSort{

    public static void main(String[] args){

        int[] a = {43,86,26,13,15,66,73};

        for(int i=1;i<a.length;i++){

            int temp=a[i];

            int j;

            for(j=i-1;j>=0;j--){

                if(a[j]>temp){

                    a[j+1]=a[j];

                }else{break;}}

            a[j+1]=temp;}

for(int i =0;i<a.length;i++){

System.out.println(""+a[i]);}}

2.二分法插入排序：

public class BinaryInsertSort{

    private void sort(int [] a){

        for(int i=0;i<a.length;i++){

            int temp=a[i];       //待插入到前面有序序列的值

            int left = 0;

            int right = i-1;

            int mid = 0;

            while(left<=right){

                mid = (left+right)/2;

                if(temp<a[mid]){

                    right = mid -1;}

                else{

                    left = mid +1;}}

            for(int j=i-1;j>=left;j--){

                //比left右边大的值往后移一位，等待temp插入

                a[j+1]=a[j];}

            if(left!=i){

                a[left]=temp;}}

            for(int i=0;i<a.length;i++){

                System.out.println(""+a[i]);}}

public static void main(String[] args){

    BinaryInsertSort binaryInsertSort = new BinaryInsertSort();

    int [] a = {1,2,34,3,56};

    binaryInsertSort.sort(a);

}

3.堆排序

    在二叉数组里，如果根结点或子树根节点数据大于结点或子树下的结点数据，我们称之为大堆，否则为小堆 。

public class HeapSort {   //(1)
        public static void main(String[] args) {
            HeapSort heapSort = new HeapSort();
            int[] array = { 19, 8, 27, 6, 35, 14, 3, 12, 1, 0, 9, 10, 7 };

            System.out.println("Before heap:");
            heapSort.printArray(array);

            heapSort.heapSort(array);

            System.out.println("After heap sort:");
            heapSort.printArray(array);
        }

        public void heapSort(int[] array) {
            if (array == null || array.length <= 1) {
                return;
            }
            buildMaxHeap(array);//建立最大堆
            for (int i = array.length - 1; i >= 1; i--) {
                //最大的在0位置，那么开始沉降，这样每交换一次最大的值就丢到最后了
                exchangeElements(array, 0, i);
                //继续获取0位置最大值
                maxHeap(array, i, 0);
            }
        }

        //(2)        //建立最大堆
        private void buildMaxHeap(int[] array) {
            if (array == null || array.length <= 1) {
                return;
            }
            int half = (array.length-1) / 2;
            for (int i = half; i >= 0; i--) {
                maxHeap(array, array.length, i);
            }
        }

        private void maxHeap(int[] array, int heapSize, int index) {
            int left = index * 2 + 1;
            int right = index * 2 + 2;
            int largest = index;
            if (left < heapSize && array[left] > array[index]) {
                largest = left;
            }
            if (right < heapSize && array[right] > array[largest]) {
                largest = right;
            }
            if (index != largest) {
                exchangeElements(array, index, largest);

                maxHeap(array, heapSize, largest);
            }
        }
        
//（3）        
        public void printArray(int[] array) {  
            System.out.print("{");  
            for (int i = 0; i < array.length; i++) {  
                System.out.print(array[i]);  
                if (i < array.length - 1) {  
                    System.out.print(", ");  
                }  
            }  
            System.out.println("}");  
        }  
        
        
        public void exchangeElements(int[] array, int index1, int index2) {  
            int temp = array[index1];  
            array[index1] = array[index2];  
            array[index2] = temp;  
        }  
    }