一天一个算法，边回想算法细节，边捡回C++，试验性程序，留作记念。

交换排序有：冒泡排序和快速排序

#include <iostream>
#include <conio.h>

using namespace std;
int arrs[] = { 23, 65, 12, 3, 8, 76, 345, 90, 21, 75, 34, 61 };
int arrLen = sizeof(arrs) / sizeof(arrs[0]);

void quickSort(int * arrs, int left, int right){
    int oldLeft = left;
    int oldRight = right;
    bool flag = true;
    int baseArr = arrs[oldLeft]; 
    while (left < right){
        while (left < right &amp;& arrs[right] >= baseArr){
            right--;
            flag = false;
        }
        arrs[left] = arrs[right];
        while (left < right && arrs[left] <= baseArr){
            left++;
            flag = false;
        }
        arrs[right] = arrs[left];
    }
    arrs[left] = baseArr;
    if (!flag){
        quickSort(arrs, oldLeft, left-1);
        quickSort(arrs, left+1, oldRight);
    }
}

int main()
{
    quickSort(arrs, 0, arrLen - 1);
    for (int i = 0; i < arrLen; i++)
        cout << arrs[i] << endl;
    getch();
    return 0;
}

网上一兄弟写的快排csharp类，留作参考：

namespace QuickSort
{
    public class QuickSortClass
    {
        public int Division(List<int> list, int left, int right)
        {
            //首先挑选一个基准元素
            int baseNum = list[left];
            while (left < right)
            {
                //从数组的右端开始向前找，一直找到比base小的数字为止(包括base同等数)
                while (left < right && list[right] >= baseNum)
                    right = right - 1;
                //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置
                list[left] = list[right];
                //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）
                while (left < right && list[left] <= baseNum)
                    left = left + 1;
                //最终找到了比baseNum大的元素，要做的事情就是将此元素放到最后的位置
                list[right] = list[left];
            }
            //最后就是把baseNum放到该left的位置
            list[left] = baseNum;
            //最终，我们发现left位置的左侧数值部分比left小，left位置右侧数值比left大
//至此，我们完成了第一篇排序
            return left;
        }

        public void QuickSort(List<int> list, int left, int right)
        {
            //左下标一定小于右下标，否则就超越了
            if (left < right)
            {
                //对数组进行分割，取出下次分割的基准标号
                int i = Division(list, left, right);

                //对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                QuickSort(list, left, i - 1);

                //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                QuickSort(list, i + 1, right);
            }
        }
    }
}