排序算法实现

1冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换m慢慢"浮"到数列的顶端。

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

/** 冒泡排序 */
void Sort::Bubble(vector<int> &Array){
    bool flag=false;
    Display(Array);
    for(int i=0;i<Array.size()-1;i++){
        flag=false;
        for(int j=0;j<Array.size()-1-i;j++){
            if(Array[j]>Array[j+1]){
                swap(Array[j],Array[j+1]);
                flag=true;
            }
        }
        if(!flag)break;
    }
    Display(Array);

}

2 选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

/** 选择排序 */
void Sort::Select(vector<int> &Array){
    int min=0;
    int pos=0;
    Display(Array);
    for(int i=0;i<Array.size()-1;i++){
        min=Array[i];
        pos=i;
        for(int j=i+1;j<Array.size();j++){
            if(Array[j]<min){
                min=Array[j];
                pos=j;
            }
        }
        if(pos!=i)swap(Array[i],Array[pos]);
    }
    Display(Array);

}

3 插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

算法步骤

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

/** 插入排序*/
void Sort::Insert(vector<int> &Array){
    int temp;
    Display(Array);
    for(int i=1;i<Array.size();i++){
        temp=Array[i];
        for(int j=0;j<i;j++){
            if(Array[j]>Array[i]){
                for(int k=i;k>j;k--){
                    Array[k]=Array[k-1];
                }
                Array[j]=temp;
                break;
            }
        }
    }
    Display(Array);
}

4 归并排序

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

• 自上而下的递归；
• 自下而上的迭代；

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

算法步骤

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

4. 重复步骤 3 直到某一指针达到序列尾；

5. 将另一序列剩下的所有元素直接复制到合并序列尾。

   /** 归并排序*/
   void Sort::Merge(vector<int> &Array){
       Display(Array);
       subMerge(Array,0,Array.size()-1);
       Display(Array);
   }
   void Sort::subMerge(vector<int> &Array, int left, int right){
       if(right-left>1){
           int mid=(right+left)/2;
           subMerge(Array,left,mid);
           subMerge(Array,mid+1,right);
           vector<int> temp;
           int lefttemp=left;
           int rightemp=mid+1;
           while (temp.size()!=(right-left+1)) {
               if(lefttemp<=mid&&rightemp<=right){
                   if(Array[lefttemp]<Array[rightemp]){
                       temp.push_back(Array[lefttemp]);
                       lefttemp++;
                   }else{
                       temp.push_back(Array[rightemp]);
                       rightemp++;
                   }
               }else if (lefttemp<=mid) {
                   temp.push_back(Array[lefttemp]);
                   lefttemp++;
               }else{
                   temp.push_back(Array[rightemp]);
                   rightemp++;
               }
           }
           for(int i=0;i<temp.size();i++){
               Array[i+left]=temp[i];
           }
       }else if(right-left==1){
           if(Array[left]>Array[right]){
               swap(Array[left],Array[right]);
           }
       }
   }

   5 快速排序

   1. 算法步骤

•  从数列中挑出一个元素，称为 "基准"（pivot）;

• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序； 

  /** 快速排序 */
  void Sort::Quick(vector<int> &Array){
      Display(Array);
      int size=Array.size();
      int gap=1;
      while (gap<size/3) {
          gap=gap*3+1;
      }
      for()
      Display(Array);
  }
  void Sort::subQuick(vector<int> &Array, int start, int end){
      if(end-start>1){
          int temp=0;
          for(int i=1;i<end-start+1;i++){
              if(Array[start+i]<Array[start]){
                  swap(Array[start+i],Array[start+temp+1]);
                  temp++;
              }
          }
          swap(Array[start],Array[start+temp]);
          if(temp>1){
  
              subQuick(Array,start,start+temp-1);
          }
          if(temp+start<end-1){
              subQuick(Array,start+temp+1,end);
          }
      }else if(end-start==1){
          if(Array[start]>Array[end]){
              swap(Array[start],Array[end]);
          }
      }
  }