数据结构复习：交换排序原理及C++实现

1. 交换排序的基本思想

两两比较key值，如果发生逆序（排列的顺序与期望的顺序相反）就交换，知道所有对象都排序完毕！常见的3种交换排序算法：冒泡排序，shaker排序和快速排序。

2. 冒泡排序

 设待排序列中有 n 个对象， 首先比较对象v[n-1]和v[n-2], 如果v[n-1] < v[n-2],则交换v[n-1]和v[n-2]，然后对v[n-i]和v[n-i-1]进行同样操作，知道对v[1]和v[0]进行完操作，每一次冒泡，使得值小的对象前移动，如此重复，直至有序，图解如下：

3.Shaker排序（双向冒泡排序）

此种排序是对冒泡排序的改进，冒泡排序每次只能从一个方向进行遍历，而shaker排序每次遍历包括两个方向，先从前向后，再从后往前双向交替，效率上较冒泡排序有所改进，图解如下：

4.快速排序

快速排序采用的是一种分治的思想：取待排序对象序列中的某个对象为基准（任意取一个），按照其他对象与该基准对象的大小关系，将整个序列划分为左右两个子序列，其中左侧子序列中所有对象值都小于或者等于基准值，右侧对象序列中的所有对象值都大于基准值，然后对左右这两个子序列重复上述操作（递归），直至子序列为空为止！还是比较容易理解，这里就不画图了。

5.C++实现

#ifndef EXCHANGESORT_H
#define EXCHANGESORT_H
#include <vector>
#include <iostream>
using std::vector;
using std::cout;
using std::endl;
template <typename T>
class ExchangeSort
{
private:
    int len;
    vector<T> list;
public:
    /*
     * Construction function
    */
    ExchangeSort(vector<T> _list, int _len)
    {
        for (int i = 0; i < _len; ++i) list.push_back(_list[i]);
        this->len = _len;
    }

    /*
    * bubbleSort functions
    */
    void bubbleSort()
    {
        for (int i = 0; i < len; ++i)
            for (int j = i + 1; j < len; ++j)
                if (list[i] > list[j]) swap(i, j);
    }

    /*
    * shakerSort functions
    */
    void shakerSort()
    {
        int i, left = 0;
        int shift = 0;
        int right = len - 1;
        while (left < right)
        {
            for (i = left; i < right; ++i) // From left to right
            {
                if (list[i] > list[i + 1])
                {
                    swap(i, i + 1);
                    shift = i;// Record the last index
                }
            }// end for
            right = shift;
            for (i = right; i > left; --i)//From right to left
            {
                if (list[i] < list[i - 1])
                {
                    swap(i, i - 1);
                    shift = i;
                }
            }// end for
            left = shift;
        }//end while
    }


    
    /*
    * quick sort
    */
    void quickSort(int left, int right)
    {
        int i = left;
        int j = right;
        int pivot = list[left];
        while (i < j)
        {
            while (i < j && list[j] >= pivot) --j; // Search the number less than pivot
            if (i < j) swap(i, j);
            while (i < j && list[i] <= pivot) ++i; // Search the number larger than pivot
            if (i < j) swap(i, j);
        }
        if (i != left) quickSort(left, i - 1);
        if (j != right) quickSort(j + 1, right);
    }
    /*
    * Exchange two elements of list
    */
    void swap(int i, int j)
    {
        T temp = list[i];
        list[i] = list[j];
        list[j] = temp;
    }

    /*
    * Display the sorted result
    */
    void out()
    {
        for (int i = 0; i < len; ++i)
        {
            cout << list[i] << " ";
            if ((i + 1) % 18 == 0) cout << endl;
        }
        cout << endl;
    }
};

#endif


//exchangeSortTest
#include "ExchangeSort.h"
#include <vector>
using namespace std;

const unsigned numEle = 8;
int data[numEle] = {1,5,7,3,8,2,6,4};


int main()
{
    vector<int> testData;
    for (unsigned i = 0; i < numEle; ++i) testData.push_back(data[i]);

    ExchangeSort<int> testBubble(testData, numEle);
    cout << "Before sorting: ";
    testBubble.out();
    testBubble.bubbleSort();
    cout << "After sorting with bubbleSort: ";
    testBubble.out();
    

    ExchangeSort<int> testShaker(testData, numEle);
    cout << "Before sorting: ";
    testShaker.out();
    testShaker.shakerSort();
    cout << "After sorting with shakerSort: ";
    testShaker.out();

    ExchangeSort<int> testQuick(testData, numEle);
    cout << "Before sorting: ";
    testQuick.out();
    testQuick.quickSort(0, numEle-1);
    cout << "After sorting with testQuick: ";
    testQuick.out();

    return 0;
}

6.参考文献

左飞：C++数据结构原理与经典问题求解