排序

1.选择排序
1）在线性表中找到最小元素，并和第一个元素交换。然后在剩下元素中找到最小元素，并和剩余的线性表中的第一个元素交换。直到线性表中仅剩一个元素为止。
2）第一次比较次数：n-1
第二次比较次数：n-2
…
T(n) = (n-1) + c + (n-1) + c + … + 2 + c + 1 + c = O(n^2)

 public static void selectSort(int[] list){
        for(int i = 0; i < list.length - 1; i++){
            int min = list[i];
            int minIndex = i;
            for(int j = i + 1; j < list.length; j++){
                if(min > list[j]){
                    min = list[j];
                    minIndex = j;
                }
            }
            if(minIndex != i){
                list[minIndex] = list[i];
                list[i] = min;
            }
        }
    }
    public static void main(String[] args){
        int[] list = {2, 9, 5, 4, 8, 1, 6};
        selectSort(list);
        for(int j = 0; j < list.length; j++){
            System.out.print(list[j] + " ");
        }
    }

2.插入排序
时间复杂度：
T(n) = (2+c) +(2 * 2 + c) + (2 * 3 + c) + … + (2 * (n-1) + c)
=2(1+2+…+n-1) + c(n-1) = O(n^2)
选择排序和插入排序有相同的时间复杂度

public class InsertSort {
    public static void insertSort(int[] list){
        for(int i = 1; i < list.length; i++){
            int currentElement = list[i];
            int k;
            for(k = i - 1; k >= 0 && list[k] > currentElement; k--){
                list[k + 1] = list[k];  //前大：后移
            }
            list[k + 1] = currentElement;  //插入到正确的位置
        }
    }
    public static void main(String[] args){
        int[] list = {1, 9, 4, 6, 5, -4};
        insertSort(list);
        for(int i = 0; i < list.length; i++){
            System.out.print(list[i] + " ");
        }
    }
}

3.冒泡排序
稳定的排序。
最好：因为第一次遍历的比较次数为n-1，所以最佳情况下，时间为O（n）。
最坏：最差情况下需要进行n-1次遍历。第一次遍历需要n - 1次比较；第二次遍历需要n-2次比较；依次进行，最后一次遍历需要1次比较。因此，比较总次数为：
(n-1)+(n-2)+…+2+1 = (n-1)n/2 = n*n/2 - n/2 = O(n^2)

public static void bubbleSort(int[] list){
        boolean needNextPass = true;
        for(int k = 1; k < list.length && needNextPass; k++){ //k：遍历次数
            needNextPass = false;
            for(int i = 0; i < list.length - k; i++){ //在第k次遍历时，不需要考虑最后k-i个元素了。因为它们已经有序
                if(list[i] > list[i + 1]){
                    int temp = list[i + 1];
                    list[i + 1] = list[i];
                    list[i] = temp;
                    needNextPass = true;
                }
            }
        }
    }

4.归并排序

package javabase.Sort;

/**
 * 归并排序
 * Created by Administrator on 2017/3/21.
 */
public class MergeSort {
    public static void mergeSort(int[] list){
        if(list.length > 1){
            int[] firstHalf = new int[list.length / 2];
            System.arraycopy(list, 0, firstHalf, 0, list.length / 2);
            mergeSort(firstHalf);

            int secondHalfLength = list.length - list.length / 2;
            int[] secondHalf = new int[secondHalfLength];
            System.arraycopy(list, list.length / 2, secondHalf, 0, secondHalfLength);
            mergeSort(secondHalf);

            merge(firstHalf, secondHalf, list);
        }
    }

    public static void merge(int[] list1, int[] list2, int[] temp){
        int current1 = 0;
        int current2 = 0;
        int current3 = 0;

        while(current1 < list1.length && current2 < list2.length){
            if(list1[current1] < list2[current2]){
                temp[current3++] = list1[current1++];
            }else{
                temp[current3++] = list2[current2++];
            }
            while(current1 < list1.length){
                temp[current3++] = list1[current1++];
            }
            while(current2 < list2.length){
                temp[current3++] = list2[current2++];
            }
        }
    }
    public static void main(String[] args){
        int[] list = {2, 3, 2, 5, 6, 1, -2, 3, 14, 12};
        mergeSort(list);
        for(int i = 0; i < list.length; i++){
            System.out.print(list[i] + " ");
        }
    }
}

T(n) = T(n/2) + T(n/2) + 2n - 1 = O(nlogn)
归并排序时间复杂度：O(nlogn)，优于选择、插入、冒泡（它们都是O(n^2)）
java.util.Arrays类中的sort()使用的就是归并排序算法的变体实现的。

5.快速排序

public class QuickSort {
    public static void quickSort(int[] list){
        quickSort(list, 0, list.length - 1);
    }

    private static void quickSort(int[] list, int first, int last){
        if(last > first){
            int pivotIndex = partition(list, first, last);
            quickSort(list, first, pivotIndex - 1);
            quickSort(list, pivotIndex + 1, last);
        }
    }

    private static int partition(int[] list, int first, int last){
        int pivot = list[first];
        int low = first + 1;  // 从前找
        int high = last;      // 从后找

        while(high > low){
            while(low <= high && list[low] <= pivot)  // 从左搜.找第一个大于主元对元素
                low++;
            while(low <= high && list[high] > pivot)  //从右搜.找第一个小于等于主元对元素
                high--;
            if(high > low){
                int temp = list[high];
                list[high] = list[low];
                list[low] = temp;
            }
        }
        while(high > first && list[high] >= pivot)   //high和low指向同一个时。即high=low。条件1防止high出界
            high--;

        //所有元素都检查过了
        // swop pivot with list[high]。返回主元下标
        if(pivot > list[high]){
            list[first] = list[high];
            list[high] = pivot;
            return high;
        }else{
            return first;
        }
    }

    public static void main(String[] args){
        int[] list = {2, 3, 2, 5, 6, 1, -2, 3, 14, 12};
        quickSort(list);
        for(int i = 0; i < list.length; i++){
            System.out.print(list[i] + " ");
        }
    }
}

6.堆排序

package sort;
import java.util.ArrayList;

/**
 * Created on 2017/7/1.
 */
public class Heap<E extends Comparable> {
    private ArrayList<E> list = new java.util.ArrayList<E>();

    public Heap(){
    }
    public Heap(E[] objects){
        for(int i = 0; i < objects.length; i++){
            add(objects[i]);
        }
    }

    public void add(E newObject){
        list.add(newObject);
        int currentIndex = list.size() - 1; // the index of the last node

        while(currentIndex > 0){
            int parentIndex = (currentIndex - 1) / 2;
            //swap if the current object is greater then its parent
            if(list.get(currentIndex).compareTo(list.get(parentIndex)) > 0){
                E temp = list.get(currentIndex);
                list.set(currentIndex, list.get(parentIndex));
                list.set(parentIndex, temp);
            }else
                break;   //the tree is a heap now

            currentIndex = parentIndex;
        }
    }

    //remove the root from the heap
    public E remove(){
        if(list.size() == 0){
            return null;
        }

        E removeObject = list.get(0);
        list.set(0, list.get(list.size() - 1));
        list.remove(list.size() - 1);

        int currentIndex = 0;
        while(currentIndex < list.size()){
            int leftChildIndex = 2 * currentIndex + 1;
            int rightChildIndex = 2 * currentIndex + 2;

            // find the maximum between two children
            if(leftChildIndex >= list.size()) break; // the tree is a heap
            int maxIndex = leftChildIndex;
            if(rightChildIndex < list.size()){
                if(list.get(maxIndex).compareTo(list.get(rightChildIndex)) < 0){
                    maxIndex = rightChildIndex;
                }
            }// 比较左右子节点大小，找到更大大

            //swap if the current node is less than the maximum
            if(list.get(currentIndex).compareTo(list.get(maxIndex)) < 0){
                E temp = list.get(maxIndex);
                list.set(maxIndex, list.get(currentIndex));
                list.set(currentIndex, temp);
                currentIndex = maxIndex;
            }else
                break;
        }
        return removeObject;
    }

    public int getSize(){
        return list.size();
    }
}

package sort;

/**
 * Created by on 2017/7/1.
 */
public class HeapSort {
    public static <E extends Comparable> void heapSort(E[] list){
        Heap<E> heap = new Heap<E>();

        //add elements to the heap
        for(int i = 0; i < list.length; i++){
            heap.add(list[i]);
        }

        //remove elements from the heap
        //以降序删除这些元素
        for(int i = list.length - 1; i >= 0; i--){
            list[i] = heap.remove();
        }
    }

    public static void main(String[] args){
        Integer[] list = {2, 3, 2, 5, 6, 1, -2, 3, 14, 12};
        heapSort(list);
        for(int i = 0; i < list.length; i++){
            System.out.print(list[i] + " ");
        }
    }


}