前言

本文講解常見排序算法的分析與實現(xiàn)，具體包括冒泡排序；選擇排序；插入排序；希爾排序；歸并排序；快速排序；算法實現(xiàn)采用Java和C 兩種語言。

一、冒泡排序（時間復(fù)雜度O（N^2））

• 通俗理解：冒泡排序把數(shù)據(jù)分為

  沉降后和待比較

  兩組，初始狀態(tài)沉降后元素個數(shù)為0，待比較元素個數(shù)為所有數(shù)組元素。每一趟把

  待比較元素中“相對最大”的元素

  放（沉）到

  沉降后元素的第一個位置

  。每一趟后待比較元素少一個，直至待比較元素只剩1個，說明最小的元素已經(jīng)冒到首位，排序完成。

• 排序原理
  1.比較相鄰的元素。如果前一個元素比后一個元素大，就交換這兩個元素的位置。
  2.對每一對相鄰元素做同樣的工作，從開始第一對元素到結(jié)尾的最后一對元素。最終最后位置的元素就是最大
  值。
  

• Java代碼實現(xiàn)

/*冒泡排序：時間復(fù)雜度為n^2*/
public class Bubble {
    public static void sort(Comparable[] a)
    {
        for (int i=a.length-1;i>0;i--) //多少個元素進行排序
        {
            for (int j=0;j<i;j  )  //多少個元素進行比較
            {
                if(greater(a[j],a[j 1])) //執(zhí)行次數(shù)： (n-1) (n-2) ... 1=((n-1) 1)*(n-1)/2=n^2/2 - n/2
                    exch(a,j,j 1);  // 最壞情況下執(zhí)行次數(shù)：(n-1) (n-2) ... 1=((n-1) 1)*(n-1)/2=n^2/2 - n/2
                                      // 因此時間復(fù)雜度為 n^2 -n 即O(n^2)
            }
        }
    }

    private static boolean greater(Comparable v,Comparable w)
    {
        return v.compareTo(w)>0;
    }

    private static void exch(Comparable[] a,int i,int j)
    {
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

• C 代碼實現(xiàn)

/* Bubble sort */
#include<iostream>
using namespace std;

//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b); 

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j);

//printf arrar
template<typename T>
void prt(T data[],int N);

template<typename T>
void bubble(T data[],int N);

int main()
{
int a[]={1,2,3,8,7,6};
prt(a,6);
bubble(a,6);
prt(a,6);
return 1;
}
template<typename T>
void bubble(T data[],int N)
{
for(int i=N-1;i>0;i--)
{
for(int j=0;j<i;j  )
{
if(bigger(data[j],data[j 1])) exch(data,j,j 1);

}
}
} 

//printf arrar
template<typename T>
void prt(T data[],int N)
{
for(int i=0;i<N;i  ) cout<<data[i]<<" ";
cout<<endl;
}
//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b) 
{
return a>b;
}

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j)
{
T temp=data[i];
data[i]=data[j];
data[j]=temp;
}

二、選擇排序（時間復(fù)雜度O（N^2））

• 排序原理
  1.

  每一次遍歷

  的過程中，

  都假定第一個索引處的元素是最小值

  ，和其他索引處的值依次進行比較，如果當前索引處
  的值大于其他某個索引處的值，則假定其他某個索引出的值為最小值，最后可以找到最小值所在的索引
  2.交換第一個索引處和最小值所在的索引處的值
  

• Java代碼實現(xiàn)

/*選擇排序， 時間復(fù)雜度：O(n^2)*/
public class Selection {

    public static void Sort(Comparable[] a)
    {
        for (int i=0;i<=a.length-2;i  ) //待選擇元素
        {
            int minIndex=i;
            for (int j=i 1;j<a.length;j  ) //待比較元素
            {
                if(greater(a[minIndex],a[j]))
                    minIndex=j;
            }
            exch(a,i,minIndex);
        }
    }

    private static boolean greater(Comparable a, Comparable b)
    {
        return a.compareTo(b)>0;
    }

    private static void exch(Comparable[] a,int i,int j)
    {
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

• C 實現(xiàn)

/* Selection sort */
#include<iostream>
using namespace std;

//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b); 

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j);

//printf arrar
template<typename T>
void prt(T data[],int N);

template<typename T>
void selection(T data[],int N);

int main()
{
int a[]={8,7,6,3,2,1};
prt(a,6);
selection(a,6);
prt(a,6);
return 1;
}
template<typename T>
void selection(T data[],int N)
{
for(int i=0;i<N-1;i  )
{
int minIndex=i;
for(int j=i;j<N;j  )
{
if(bigger(data[minIndex],data[j])) 
{
minIndex=j;
}
}
exch(data,i,minIndex);
}
} 

//printf arrar
template<typename T>
void prt(T data[],int N)
{
for(int i=0;i<N;i  ) cout<<data[i]<<" ";
cout<<endl;
}
//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b) 
{
return a>b;
}

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j)
{
T temp=data[i];
data[i]=data[j];
data[j]=temp;
}

三、插入排序（時間復(fù)雜度O（N^2））

• 排序原理
  1.

  把所有的元素分為兩組，已經(jīng)排序的和未排序的

  ；
  2.找到未排序的組中的第一個元素，向已經(jīng)排序的組中進行插入；
  3.倒敘遍歷已經(jīng)排序的元素，依次和待插入的元素進行比較，直到找到一個元素小于等于待插入元素，那么就把待插入元素放到這個位置，其他的元素向后移動一位；（實際實現(xiàn)方式，

  用交換元素代替插入元素

  。即通過將待排序元素加入已排序組，此時，待排序元素在已排序組中的位置可能不對，因此對已排序組進行一次類似冒泡排序。使待排序元素在已排序組中找到合適的位置。）
  
  插入排序的工作方式非常像人們排序一手撲克牌一樣。開始時，我們的左手為空并且桌子上的牌面朝下。然后，我
  們每次從桌子上拿走一張牌并將它插入左手中正確的位置。為了找到一張牌的正確位置，我們從右到左將它與已在
  手中的每張牌進行比較。
  

• Java實現(xiàn)

/*插入排序；時間復(fù)雜度為：O(N^2) */
public class Insertion {

    public static void sort(Comparable[] a)
    {
        for (int i=1;i<a.length;i  ) //未排序的元素
        {
            for (int j=i;j>0;j--) //已排序的元素
            {
                if(greater(a[j-1],a[j]))  //最壞情況的比較次數(shù)：n^2/2 - n/2
                    exch(a,j-1,j);  //最壞情況的交換次數(shù)：n^2/2 - n/2
                else
                    break;
            }
        }
    }

    private static boolean greater(Comparable v,Comparable w)
    {
        return v.compareTo(w)>0;
    }

    private static void exch(Comparable[] a,int i,int j)
    {
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

• C 實現(xiàn)

/* Bubble sort */
#include<iostream>
using namespace std;

//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b); 

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j);

//printf arrar
template<typename T>
void prt(T data[],int N);

template<typename T>
void insertion(T data[],int N);

int main()
{
int a[]={8,7,6,3,2,1};
prt(a,6);
insertion(a,6);
prt(a,6);
return 1;
}
template<typename T>
void insertion(T data[],int N)
{
for(int i=1;i<N;i  )
{
for(int j=i;j>0;j--)
{
if(bigger(data[j-1],data[j])) exch(data,j,j-1);

}
}
} 

//printf arrar
template<typename T>
void prt(T data[],int N)
{
for(int i=0;i<N;i  ) cout<<data[i]<<" ";
cout<<endl;
}
//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b) 
{
return a>b;
}

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j)
{
T temp=data[i];
data[i]=data[j];
data[j]=temp;
}

四、希爾排序

希爾排序是插入排序的一種，又稱“縮小增量排序”，是插入排序算法的一種更高效的改進版本。
前面學習插入排序的時候，我們會發(fā)現(xiàn)一個很不友好的事兒，如果已排序的分組元素為{2,5,7,9,10}，未排序的分組元素為{1,8}，那么下一個待插入元素為1，我們需要拿著1從后往前，依次和10,9,7,5,2進行交換位置，才能完成真正的插入，每次交換只能和相鄰的元素交換位置。那如果我們要提高效率，直觀的想法就是一次交換，能把1放到更前面的位置，比如一次交換就能把1插到2和5之間，這樣一次交換1就向前走了5個位置，可以減少交換的次數(shù)，這樣的需求如何實現(xiàn)呢？接下來我們來看看希爾排序的原理。

• 排序原理
  1.選定一個增長量h，按照增長量h作為數(shù)據(jù)分組的依據(jù)，

  對數(shù)據(jù)進行分組

  ；
  2.對分好組的

  每一組數(shù)據(jù)完成插入排序

  ；
  3.減小增長量，最小減為1，重復(fù)第二步操作。
  通過增長量h進行分組，可以實現(xiàn)一次向前走h個位置進行交換元素。每一次增長量減少都會使得數(shù)據(jù)

  局部更加有序

  
  

• 增長量h的初始值確定規(guī)則

h=1;
while(h<N/2)
h=2h 1;

• 增長量h的遞減規(guī)則，一半一半的遞減，直至為1

h=h/2;

• Java實現(xiàn)

public class Shell {

    public static void sort(Comparable[] a)
    {
        int h=1;
        while (h<a.length/2)
        {
            h=2*h 1; //確定增長量h的初值
        }

        // 分而治之，先讓數(shù)據(jù)局部有需序（各個大組有序，大組逐漸變小組），再進行最終的全部有序
        while (h>=1)
        {
            for (int i=h;i<a.length;i  )
            {
                for (int j=i;j>=h;j-=h)
                {
                    if(greater(a[j-h],a[j]))
                        exch(a,j-h,j);
                    else
                        break;
                }
            }
            h=h/2; //減小h的值
        }
    }

    private static boolean greater(Comparable a, Comparable b)
    {
        return a.compareTo(b)>0;
    }

    private static void exch(Comparable[] a,int i,int j)
    {
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

• C 實現(xiàn)

/* Bubble sort */
#include<iostream>
using namespace std;

//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b); 

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j);

//printf arrar
template<typename T>
void prt(T data[],int N);

template<typename T>
void shell(T data[],int N);

int main()
{
int a[]={8,7,6,3,2,1};
prt(a,6);
shell(a,6);
prt(a,6);
return 1;
}
template<typename T>
void shell(T data[],int N)
{
int h=1;
while(h<N/2) //initial h value
h=2*h 1;

while(h>=1)
{
for(int i=h;i<N;i  )
{
for(int j=i;j>=h;j-=h)
{
if(bigger(data[j-h],data[j])) exch(data,j,j-h);
else break;

}
}
h/=2; //decrease h value
}
} 

//printf arrar
template<typename T>
void prt(T data[],int N)
{
for(int i=0;i<N;i  ) cout<<data[i]<<" ";
cout<<endl;
}
//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b) 
{
return a>b;
}

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j)
{
T temp=data[i];
data[i]=data[j];
data[j]=temp;
}

五、歸并排序（時間復(fù)雜度O（nlogn））

• 排序原理
  1.

  盡可能的一組數(shù)據(jù)拆分成兩個元素相等的子組，并對每一個子組繼續(xù)拆分，直到拆分后的每個子組的元素個數(shù)是1為止。

  
  2.對每個子組進行排序
  3.將相鄰的兩個子組進行合并成一個有序的大組；
  4.

  不斷的重復(fù)步驟2,3

  ，直到最終只有一個組為止。
  

• 實現(xiàn)流程解析
  
  
  

• Java實現(xiàn)

/*歸并排序 ，典型的分而治之的策略，先把所有的元素分開，然后再一一攻破;時間復(fù)雜度為O(nlogn)*/
public class Merge {

    private static Comparable[] assist;//完成歸并操作需要的輔助數(shù)組

    //對數(shù)組內(nèi)的元素進行排序
    public static void sort(Comparable[] a)
    {
        assist=new Comparable[a.length];
        int minIndex=0; // 數(shù)組中最小的索引
        int maxIndex=a.length-1; // 數(shù)組中最大的索引
        sort(a,minIndex,maxIndex); //對數(shù)組中部分元素進行排序
    }
    //對數(shù)組a中從索引lo到索引hi之間的元素進行排序
    private static void sort(Comparable[] a, int minIndex, int maxIndex)
    {
        if(maxIndex<=minIndex)
            return;
        //將minIndex 到 maxIndex的數(shù)據(jù)分為兩組
        int midIndex = minIndex (maxIndex-minIndex)/2;
        //分別對兩組數(shù)據(jù)進行排序
        sort(a,minIndex,midIndex);
        sort(a,midIndex 1,maxIndex);
        //對兩組數(shù)據(jù)進行歸并
        merge(a,minIndex,midIndex,maxIndex);
    }
    //從索引lo到所以mid為一個子組，從索引mid 1到索引hi為另一個子組，把數(shù)組a中的這兩個子組的數(shù)據(jù)合并成一個有序的大組（從索引lo到索引hi）
    private static void merge(Comparable[] a, int minIndex, int midIndex, int maxIndex)
    {
        //定義三個索引
        int leftIndex=minIndex; // 兩組中左邊一組待比較值的位置索引
        int rightIndex=midIndex 1; // 兩組中右邊一組待比較值的位置索引
        int assistIndex=minIndex; // 輔助數(shù)組中待插入元素的位置索引

        // 一一對應(yīng)比較兩組中的數(shù)據(jù)，將較小的數(shù)據(jù)放到輔助數(shù)組中，直至有一個組的數(shù)據(jù)遍歷完
        while (leftIndex<=midIndex && rightIndex <= maxIndex)
        {
            if(less(a[leftIndex],a[rightIndex]))
                assist[assistIndex  ]=a[leftIndex  ];
            else
                assist[assistIndex  ]=a[rightIndex  ];
        }
        // 將剩余一個組中的數(shù)據(jù)，依次放到輔助數(shù)組中
        while (leftIndex<=midIndex)
            assist[assistIndex  ]=a[leftIndex  ];
        while (rightIndex<=maxIndex)
            assist[assistIndex  ]=a[rightIndex  ];

        // 將輔助數(shù)組中已經(jīng)排序好的數(shù)據(jù)移動到原始數(shù)組中
        for (int i=minIndex;i<=maxIndex;i  )
        {
            a[i]=assist[i];
        }
    }
    //判斷v是否小于w
    private static boolean less(Comparable v,Comparable w)
    {
        return v.compareTo(w)<0;
    }

    //交換a數(shù)組中，索引i和索引j處的值
    private static void exch(Comparable[] a,int i,int j)
    {
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

• C 實現(xiàn)

/* Bubble sort */
#include<iostream>
using namespace std;

//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b); 

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j);

//printf arrar
template<typename T>
void prt(T data[],int N);

//data group sort
template<typename T>
void sort(T data[],int N);

//data subgroup sort
template<typename T>
void sort(T data[],int minIndex,int maxIndex);

//subgroup merge
template<typename T>
void merge(T data[],int minIndex,int midIndex,int maxIndex);

//assit array
int assit[6];

int main()
{
int a[]={8,7,6,3,2,1};
prt(a,6);
sort(a,6);
prt(a,6);
return 1;
}

//data group sort
template<typename T>
void sort(T data[],int N)
{
int minIndex=0;
int maxIndex=N-1;
sort(data,minIndex,maxIndex);
} 

//data subgroup sort
template<typename T>
void sort(T data[],int minIndex,int maxIndex)
{
if(minIndex>=maxIndex)
return;
int midIndex=minIndex (maxIndex-minIndex)/2;
sort(data,minIndex,midIndex);
sort(data,midIndex 1,maxIndex);
merge(data,minIndex,midIndex,maxIndex);
}

//subgroup merge
template<typename T>
void merge(T data[],int minIndex,int midIndex,int maxIndex)
{
int leftIndex=minIndex;
int rightIndex=midIndex 1;
int assitIndex=minIndex;
while(leftIndex<=midIndex && rightIndex<=maxIndex)
{
if(bigger(data[leftIndex],data[rightIndex])) assit[assitIndex  ]=data[rightIndex  ];
else assit[assitIndex  ]=data[leftIndex  ];
}
while(leftIndex<=midIndex)
{
assit[assitIndex  ]=data[leftIndex  ];
}
while(rightIndex<=maxIndex)
{
assit[assitIndex  ]=data[rightIndex  ];
}
for(int i=minIndex;i<=maxIndex;i  )
data[i]=assit[i];
}

//printf arrar
template<typename T>
void prt(T data[],int N)
{
for(int i=0;i<N;i  ) cout<<data[i]<<" ";
cout<<endl;
}
//compare the size greater of A and B
template<typename T>
bool bigger(T a,T b) 
{
return a>b;
}

//exchage element i data[i] and data[j]
template<typename T>
void exch(T data[],int i,int j)
{
T temp=data[i];
data[i]=data[j];
data[j]=temp;
}

• 時間復(fù)雜度
  

• 歸并排序的缺點：
  需要申請額外的數(shù)組空間，導(dǎo)致空間復(fù)雜度提升，是

  典型的以空間換時間的操作

  。

六、快速排序（時間復(fù)雜度O（nlogn））

快速排序是對冒泡排序的一種改進。它的基本思想是：通過一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對這兩部分數(shù)據(jù)分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數(shù)據(jù)變成有序序列。

• 排序原理
  1.首先設(shè)定一個分界值（一般取每部分數(shù)據(jù)中的第一個元素值），通過該分界值將數(shù)組分成左右兩部分；
  2.將大于或等于分界值的數(shù)據(jù)放到到數(shù)組右邊，小于分界值的數(shù)據(jù)放到數(shù)組的左邊。此時左邊部分中各元素都小于或等于分界值，而右邊部分中各元素都大于或等于分界值；
  3.然后，左邊和右邊的數(shù)據(jù)可以獨立排序。對于左側(cè)的數(shù)組數(shù)據(jù)，又可以取一個分界值，將該部分數(shù)據(jù)分成左右兩部分，同樣在左邊放置較小值，右邊放置較大值。右側(cè)的數(shù)組數(shù)據(jù)也可以做類似處理。
  4.重復(fù)上述過程，可以看出，這是一個遞歸定義。通過遞歸將左側(cè)部分排好序后，再遞歸排好右側(cè)部分的順序。當左側(cè)和右側(cè)兩個部分的數(shù)據(jù)排完序后，整個數(shù)組的排序也就完成了。
  

• 切分原理
  把一個數(shù)組切分成兩個子數(shù)組的基本思想：
  1.找一個基準值，用兩個指針分別指向數(shù)組的頭部和尾部；
  2.先從尾部向頭部開始搜索一個比基準值小的元素，搜索到即停止，并記錄指針的位置；
  3.再從頭部向尾部開始搜索一個比基準值大的元素，搜索到即停止，并記錄指針的位置；
  4.交換當前左邊指針位置和右邊指針位置的元素；
  5.重復(fù)2,3,4步驟，直到左邊指針的值大于右邊指針的值停止。
  
  
  
  
  

• Java實現(xiàn)

/* 快速排序 最優(yōu)情況下的時間復(fù)雜度是O(nlogn);最壞情況下的時間復(fù)雜度是O(n^2);平均情況下的時間復(fù)雜度通過歸納法推導(dǎo)可得為O(nlogn)*/
public class Quick {
    //對數(shù)組內(nèi)的元素進行排序
    public static void sort(Comparable[] a)
    {
        int minIndex=0;
        int maxIndex=a.length-1;
        sort(a,minIndex,maxIndex);
    }
    //對數(shù)組a中從索引lo到索引hi之間的元素進行排序
    private static void sort(Comparable[] a, int minIndex, int maxIndex)
    {
        if(maxIndex<=minIndex)
            return;
        // 將數(shù)據(jù)中minIndex索引到maxIndex索引之間的元素進行分組（左子組，右子組）
        int separatedValues = partition(a, minIndex, maxIndex);
        //將左子組有序
        sort(a,minIndex,separatedValues-1);
        //將右子組有序
        sort(a,separatedValues 1,maxIndex);
    }
    //對數(shù)組a中，從索引 minIndex到索引 maxIndex之間的元素進行分組，并返回分組界限對應(yīng)的索引，保證左子組的元素小于分組界限值，右子組的元素大于分組界限值
    public static int partition(Comparable[] a,int minIndex,int maxIndex)
    {
        //確定分組界限值
        Comparable key=a[minIndex];
        //定義兩個索引值，分別指向待切分元素的最小索引處和最大索引處
        int left = minIndex;
        int right = maxIndex 1;
        //切分
        while (true)
        {
            //先從右往左掃描，移動right索引，直至找到一個比分界值小的元素，停止
            while (less(key,a[--right]))
            {
                if(right==minIndex)
                    break;
            }
            //再從左往右掃描，移動left索引，直至找到一個比分界值大的元素，停止
            while (less(a[  left],key))
            {
                if (left==maxIndex)
                    break;
            }
            //判斷l(xiāng)eft是否等于right,如果是，則證明元素掃描完畢，結(jié)束循環(huán)，否則，交換元素
            if(left>=right)
                break;
            else
                exch(a,right,left);
        }
        //交換分界值
        exch(a,minIndex,right);

        return right; //返回分界值索引
    }

    //判斷v是否小于w
    private static boolean less(Comparable v,Comparable w)
    {
        return v.compareTo(w)<0;
    }

    //交換a數(shù)組中，索引i和索引j處的值
    private static void exch(Comparable[] a,int i,int j)
    {
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

• C 實現(xiàn)

待更新

• 快速排序和歸并排序的區(qū)別
  快速排序是另外一種分治的排序算法，它將一個數(shù)組分成兩個子數(shù)組，將兩部分獨立的排序?？焖倥判蚝蜌w并排序是互補的：歸并排序?qū)?shù)組分成兩個子數(shù)組分別排序，并將有序的子數(shù)組歸并從而將整個數(shù)組排序，而快速排序的方式則是當兩個數(shù)組都有序時，整個數(shù)組自然就有序了。在歸并排序中，一個數(shù)組被等分為兩半，歸并調(diào)用發(fā)生在處理整個數(shù)組之前，在快速排序中，切分數(shù)組的位置取決于數(shù)組的內(nèi)容，遞歸調(diào)用發(fā)生在處理整個數(shù)組之后。

• 快速排序時間復(fù)雜度分析
  
  

常見排序算法的穩(wěn)定性

• 穩(wěn)定性的定義
  數(shù)組arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某種排序算法排序后，能夠保證A元素依然在B元素的前面，可以說這個該算法是穩(wěn)定的。
  

• 穩(wěn)定性的意義
  

  如果一組數(shù)據(jù)只需要一次排序，則穩(wěn)定性一般是沒有意義的，如果一組數(shù)據(jù)需要多次排序，穩(wěn)定性是有意義的

  。例如要排序的內(nèi)容是一組商品對象，第一次排序按照價格由低到高排序，第二次排序按照銷量由高到低排序，如果第二次排序使用穩(wěn)定性算法，就可以使得相同銷量的對象依舊保持著價格高低的順序展現(xiàn)，只有銷量不同的對象才需要重新排序。這樣既可以保持第一次排序的原有意義，而且可以減少系統(tǒng)開銷。

• 常見排序算法的穩(wěn)定性分析