数据结构之排序再学习

冒泡排序

这是一种稳定的排序算法

//简单排序之冒泡排序
//时间复杂度：最好：原来就是顺序的 T = O(N)
//            最坏：原来是逆序的 T = O(N*N)
 public  int[] BubbleSort(int[] A,int n)
{
   int flag = 0;
   for (int p = n - 1; p >= 0; p--) 
   {
       flag = 0;
       for (int i = 0; i < p; i++) 
       {
           if (A[i] > A[i + 1]) //一趟冒泡
           {
               A[i] = A[i] + A[i + 1];
               A[i + 1] = A[i] - A[i + 1];
               A[i] = A[i] - A[i + 1];
               flag = 1; //标识发生了交换
           }  
       }
       if (flag == 0) //全程无交换
       {
           break;
       }
   }
   return A;
} 

---

插入排序

这是一种稳定的排序算法

//简单排序之插入排序
//时间复杂度：最好：原来就是顺序的 T = O(N)
//          最坏：原来是逆序的 T = O(N*N)
public int[] InsertionSort(int[] A, int n)
 {
      int temp = 0;
      int i = 0;
      for (int p =1; p < n; p++)
      {

          temp = A[p]; //摸下一张牌
          for ( i = p; i > 0 && A[i-1]> temp; i--)
          {
                  A[i] = A[i - 1]; // 移出空位
          }
          A[i] = temp; // 新牌落位
      }
      return A;
  } 

---

相关概念-逆序对（inversion）

对于下标i<j,，如果i<j，如果A[i]>A[j]，则称(i,j)是一对逆序对(inversion)。

定理:任意N个不同元素组成的序列平均具有N(N-1)/4个逆序对。
定理:任意仅以交换相邻辆元素来排序的算法，其平均时间复杂度为O(N*N )。

---

希尔排序

这是一种稳定的排序算法

public int[] ShellSort(int[] A, int n)//原始希尔排序；每次都是取一半的间距
{
      int temp = 0;
      int i = 0;
      int d = 0;
      for (d = n / 2; d > 0; d /=2)
      {
          for (int p = d; p < n; p++)
          {

              temp = A[p]; //摸下一张牌
              for (i = p; i > d && A[i - d] > temp; i-=d)
              {
                  A[i] = A[i - d]; // 移出空位
              }
              A[i] = temp; // 新牌落位
          }
       }
      return A;
  }