e最近開始投各種技術類的崗位，於是乎覺得必須補一下之前的資料結構演算法知識了，因為真的很重要！幾乎每家面試都會問到其中的幾個演算法。本文部分演算法是從其他大神博主那邊搬運的，大家可以搜尋相關演算法檢視其他大神的解說和思路~~~~
穩定性：排序演算法是否穩定，根據序列中相同的元素排序前後的位置來判斷，如果兩個相同元素經過排序後，其相對位置未發生變化，則稱該排序是穩定的。
注：對陣列型序列的插入操作要考慮移位；後移：a[i+1]=a[i]；前移：a[i-1]=a[i].
1.插入類排序
1）直接插入排序
定義，對於一個待排序列，如a[ ]=1,3,4,6,5,7,8；令i=1，首先取出a[1]，將a[1]插入到序列中，當前a[1]只需和a[0]相比，然後將其插入適當位置，i++；每次將a[i]插入到a[0]至a[i-1]的序列中（因為a[i]之前的序列已經有序）。
對於n個數，要進行n-1趟插入排序，所以其時間複雜度為O(n^2)，其空間複雜度為O(1)，該排序是穩定的；
若待排序列為正序，時間複雜度為O(n)，當要排序的資料量很大時，不適合用該方法。 直接插入排序常出現在筆試的選擇題中。
C++程式碼實現：

int Insort(int A[],length){
        int temp=0;
        for(int i=1;i<length;i++)
          {
              if(A[i]<A[i-1])
              {
                 temp=A[i];
                 for(int j=i-1;j>=0&&A[j]>temp;j--)
                 {
                    A[j+1]=A[j];
                 }
                 A[j+1
 
]=temp; //將temp放在該放的位置
             }
          }    
       return A;         
}                          

2）折半插入排序
其定義為，首先通過折半查詢（轉查詢演算法）找到資料要插入的位置，再對序列中的資料進行移動並插入待排資料；時間複雜度為O(n^2)；穩定排序；
折半的概念來自於折半查詢
插入類排序的空間複雜度均為O(1).
3）希爾排序
定義，是一種縮小增量的排序；將待排序列分割為幾組，每次分割要基於一定的增量，每次的增量不一樣；在小組內排好序後，再進行下一次分組；
第一次分組，d=10/2=5
第二次分組，d=3

int Shellsort(int A[],int length){
        int gap=0;
        int temp=0;
      for(gap=length/2;gap>0;gap/=2)
      {
            for(int i=gap;i<length;i++)
            {
             for (int j=i;j>=gap;j-=gap)
             {
               if(A[j]<A[j-gap])
               {
                 temp=A[j];
                 A[j]=A[j-gap];
                 A[j-gap]=temp;
               }
               else
               {
                 break;
               }  
             }
           }
         }
        return A;
}

說明：第二層j的值從i開始，每次跳到j-gap，且j的值大於等於gap，是因為當i往後移的時候，gap之前的數已經逐漸排好序了，後面j只需要控制在比較gap之後的元素即可。

2.交換排序：
1）氣泡排序
定義：從頭開始比較序列中的元素，每次保留較大（小）的數，直到一次迴圈結束，選出最大（小）數；
每一趟排序會將當前序列的最大（小）值放在其相應的位置上。從演算法就可以知道，執行兩層迴圈所需要的時間即為其時間複雜度；
最壞以及平均時間複雜度為O(n^2)
空間複雜度：O(1). 穩定排序
C++實現：
每一趟排序，當j和i相遇的時候，說明前i個值已經排好了，即已經將前i次每次找出的最小值放在相應位置上，所以j的值只需大於i即可：

int BubbleSort(int []A){
   int temp;
   for(int i=0;i<A.length();i++)
      {
         for(int j=A.length()-1; j>i; j--)
             {
                if(A[j]<A[j-1])
                {
                   temp=A[j];
                   A[j]=A[j-1];
                   A[j-1]=temp;
                  } 
              }
      }
    return A;
}    

2）快速排序
定義，從序列中選出一個數作為“樞軸”，通常會選擇第一個數，也可以選擇中間的數；在序列的首尾各有一個指標low、high，首先從high指向的數開始，與樞軸元素做比較，若遇到比樞軸小的元素，則將其挖出來放到low指向的位置；下一步則從當前low開始往後移動，若遇到比樞軸大的元素，將其挖出來放到當前high指向的位置；這樣經過一次移動完畢即low==high時，樞軸的左邊的數都比它小，其右邊的數都比它大。再對其左、右的子序列遞迴呼叫快排。
C++實現：

int QuickSort(int A[],int l,int r){
      int low=l;
      high=r;
      int pivot=A[low];       
      if(l<r)
         {
           while(low<high && pivot<=A[high])
           {
               high--;
               }
           if(low<high) A[low++]=A[high];          
           while(low<high && pivot>=A[low])
           {
             low++;
             }
           if(low<high){ 
            A[high--]=A[low];
           }     
         A[low]=pivot;
         QuickSort(A,int l,int low-1);
         QuickSort(A,int low+1,int r);         
    }
   return A;
 }                            

時間複雜度推導公式可以檢視相關資料，主要考慮其每次一分為二的特性。
快速排序的最好以及平均時間複雜度均為O(nlogn)
最壞時間複雜度為O（n2），對於快排，越有序的序列時間複雜度越高；
空間複雜度為O(logn)至O(n). 不穩定排序

3.選擇排序
1）簡單選擇排序
2）堆排序
堆排序；首先建立一個大頂或小頂堆；每次則可以找到最大或最小元素；將最大或最小元素與最後一個元素交換，接著繼續調整堆；
最壞時間複雜度O(nlogn)，最好時間複雜度O(nlogn)，平均時間複雜度O(nlogn)；空間複雜度為O(1);

//調整堆中的元素時，假設沒有交換的子節點保持著最大（最小）堆性質，所以只對經過交換的子節點進行調整
void swap(int &a, int &b)
{
    int tmp = 0;
    tmp = a;
    a = b;
    b = tmp;

}
void ShiftHeap(int A[],int maxSign,int n)//maxSign為當前根節點，n表示n個節點；
{
    int j = 2 * maxSign + 1;
    int temp=A[maxSign];
    while (j < n)
    {
        if (j+1 < n && A[j] < A[j + 1])
        {
            j = j + 1;
        }
        if (temp > A[j])  break;
        else
        {
            A[maxSign] = A[j];
            maxSign = j;
            j = 2 * maxSign + 1;
        }
    }
    A[maxSign] = temp;
}

//正式開始堆排序，首先建立一個大頂或小頂堆，接著將頂端元素與最後一個元素交換，繼續進行交換後的調整；
void Heapsort(int A[],int n)
{
    for (int j = n / 2 - 1; j >= 0; j--)
    {
        ShiftHeap(A, j, n);
    }
    //交換過程：
    for (int i = n - 1; i >= 1; i--)
    {
        swap(A[i], A[0]);   
        ShiftHeap(A, 0, i);
    }
}

不得不說，每次只對度為2以上的節點進行調整，大大減少了時間複雜度，使其達到logn級別，真的hin棒了！
4.歸併排序
5.二叉樹排序