排序演算法的穩定性是指在待排序的序列中，存在多個相同的元素，若經過排序後這些元素的相對詞序保持不變，即Xm=Xn，排序前m在n前，排序後m依然在n前，則稱此時的排序演算法是穩定的。下面針對常見的排序演算法做個簡單的介紹。

1.氣泡排序

public static void bubbletSort(int[] list){
    for(int k=1;k<list.length;k++){
        for (int i=0;i<list.length-k;i++){
            if (list[i] > list[i+1])
                swap list[i] with list[i+1];
        }
    }
}
 

2.歸併排序

public static void mergeSort(int[] list){
    if (list.length>1){
        mergeSort(list[0...list.length/2]);
        mergeSort(list[list.length/2+1... list.length]);
        merge list[0...list.length/2] with list[list.length/2+1... list.length];
    }
}
public static int[] merge(int[] list1,int[] list2){
    int[] temp = new int[list1.length+list2.length];
    int current1 = 0,current2 =0,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++];
    return temp;
}
 

3.選擇排序

public static void selectionSort(int[] list){
    for (int i=0;i<list.length - 1;i++){
        int currentMin = list[i];
        int currentMinIndex = i;
        for(int j=i+1;j<list.length;j++){
            if (currentMin > list[j]){
                currentMin = list[j];
                currentMinIndex = j;
            }
        }
        if (currentMinIndex != i){
            list[currentMinIndex] = list[i];
            list[i] = currentMin;
        }
    }
}
 

4.插入排序

public static void insertionSort(int[] list){
    for (int i=0;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]; //如果當前值大於已排好序列表的k元素，則k元素後移
        }
        list[k+1] = currentElement;
    }
}

5.快速排序

public static void quickSort(int[] list){
    if(list.length > 1){
        select a pivot;
        //一般預設主元為第一個元素，同時從兩邊向中間比較
        //前向找到一個大於主元的元素，後向找到一個小於主元的元素，交換這兩個元素
        //直到前向元素下標大於後向元素下標，把主元與此時後向元素交換，即主元前的元素
        //都小於主元，主元后的元素都大於主元。
        partition list into list1 and list2 such that
            all elements in list1 <= pivot and
            all elements in list2 >pivot;
        quickSort(list1);
        quickSort(list2);
    }
}

6.堆排序

堆可以儲存在一個數組中，對於位置i的節點，它的左孩子在位置2i+1處，右孩子在2i+2處，它的父節點在(i-1)/2處。對堆排序分兩步：新增新節點和刪除跟節點。

新增新節點

Let the last node be the current node;
while(the current node is greater than its parent){
swap the current node with its parent;
Now the current node is one level up;
}

刪除跟節點：(即降序從堆中取出所有元素)

Remove the root node;
Move the last node to replace the root;
Let the root be the current node;
重新對堆排序；

public class Heap<E extends Comparable> {
    private ArrayList<E> list = new 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;
        while (currentIndex>0){
            int parentIndex = (currentIndex-1)/2;
            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;
            currentIndex = parentIndex;
        }
    }
    //刪除跟節點
    public E remove(){
        if (list.size() ==0) return null;
        E removedObject = 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;
            if (leftChildIndex >= list.size()) break;
            int maxIndex = leftChildIndex;
            if (rightChildIndex < list.size()){
                if (list.get(maxIndex).compareTo(list.get(rightChildIndex)) < 0){
                    maxIndex = rightChildIndex;
                }
            }
            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 removedObject;
    }
    public int getSize(){
        return list.size();
    }
}

新增新節點不會破壞相同元素的順序，但刪除根節點獲取會破壞，因此堆排序不是穩定的排序演算法。

7.基數排序

基數排序是按照低位先排序，然後收集；再按照高位排序，然後再收集；依次類推，直到最高位。有時候有些屬性是有優先順序順序的，先按低優先順序排序，再按高優 先級排序，最後的次序就是高優先順序高的在前，高優先順序相同的低優先順序高的在前。基數排序基於分別排序，分別收集，所以其是穩定的排序演算法。

8.希爾排序

希爾排序是按照不同步長對元素進行插入排序，當剛開始元素很無序的時候，步長最大，所以插入排序的元素個數很少，速度很快；當元素基本有序了，步長很小， 插入排序對於有序的序列效率很高。所以，希爾排序的時間複雜度會比o(n^2)好一些。由於多次插入排序，我們知道一次插入排序是穩定的，不會改變相同元 素的相對順序，但在不同的插入排序過程中，相同的元素可能在各自的插入排序中移動，最後其穩定性就會被打亂，所以shell排序是不穩定的。

綜上所述：