交换排序

一.冒泡排序（稳定）

算法原理

 1.首先比较第一个和第二个数据，将其中较小的数据放到第一个位置，较大的放到第二个位置。然后比较第二个和第三个位置，仍将较大的放到后一个位置。以此类推，直到比较第n-1个数据和第n个数据。这样就将待排序序列中的最大的一个放到第n个位置上，这个过程称为一趟排序。

 

2.对前面n-1个数据重复这个过程，将次大的数据放到第n-1个位置上。一般的，第i趟冒泡排序是对第1到n-i+1个数据进行操作，找到第i大的数据放到数组的第n-i+1位置上。重复，直到i=n-1为止。

template <typename Comparable>
void bubbleSort ( vector<Comparable>& a)
 {
     int n = a.size();
      for ( int i = 0; i < n-1; ++i )
     {
         for ( int j = 0; j < n-i-1; ++j )
         {
             if ( a[j] > a[j+1] )
            {
                Comparable temp = a[j];
                a[j] = a[j+1];
                a[j+1] = a[j];
           }
        }
    }
 }

 优化后，最佳情况下，时间复杂度为O(N)

template <typename Comparable>
void bubbleSort ( vector<Comparable>& a)
 {
     int n = a.size();
     bool swap_flag = true;
      for ( int i = 0; i < n-1; ++i )
     {
         swap_flag = false;
         for ( int j = 0; j < n-i-1; ++j )
         {
             if ( a[j] > a[j+1] )
            {
                Comparable temp = a[j];
                a[j] = a[j+1];
                a[j+1] = a[j];
                swap_flag = true;
           }
        }
        if swap_flag == false:
             return;
    }
 }

二.快速排序（不稳定）

基本思想

通过一趟排序将待排序记录分割陈独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

 

【一趟快速排序】首先任意选取一个记录作为枢轴，然后将所有关键字小于它的记录都安置在它之前，将所有关键字大于它的记录安置在它之后。

template<typename Compareble>
void quickSort ( vector<Comparable> & a)
{
   quickSort( a, 0, a.size()-1);
}

void quickSort ( vector<Comparable>&a, int low, int high )
{
    if ( low < high )
   {
        int pivotPos = partition ( a, low, high );
        quickSort ( a, low, pivotPos-1 );
        quickSort ( a, pivotPos+1, high);
   }
}

int partition (vector<int>& nums, int low, int high)
{
    int pivot = nums[low];
    while (low < high)
   {
        while (low < high && pivot <= nums[high])
            high--;
       nums[low] = nums[high];
       while (low < high && pivot >= nums[low])
            low++;
        nums[high] = nums[low];
    }
    nums[low] = pivot;
   return low;
}

注意：如果第一个while中为（low<=high)则算法将陷入死循环。

python版本

def quick_sort(data):
    """快速排序"""

    if len(data) < 2:
        return data

    low = 0
    high = len(data) - 1
    pivot = data[low]

    while low < high:
        while low < high and pivot <= data[high]:
            high -= 1
        data[low] = data[high]

        while low < high and pivot >= data[low]:
            low += 1
        data[high] = data[low]
    data[low] = pivot

    return quick_sort2(data[0:low]) + [data[low]] + quick_sort2(data[low+1:len(data)])