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

冒泡排序

void Bubblesort(int *arr, int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - 1 - i; j++)
        {
            int temp = 0;
            if (arr[j]>arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

快速排序

//快速排序递归实现
//快速排序(一)
int Partion(int array[], int left, int right)
{
    int begin = left;
    int end = right;
    int key = array[right];

    while (begin < end)
    {
        //从前往后找比key大的元素，找到之后停止
      while (begin<end && array[begin] <= key)
            begin++;
      //从后往前找比key小的元素，找到之后停止
      while (begin < end && array[end] >= key)
            end--;
      if (begin < end)
      {
          std::swap(array[begin],array[end]);
          begin++;
          end--;
      }
    }
    //处理begin!=right,begin>right
    if (begin!=right && array[begin]>array[right])
    {
        std::swap(array[begin],array[right]);
        return begin;
    }
    return right;
}
//快速排序(二),挖坑法
int Partion(int array[], int left, int right)
{
    int begin = left;
    int end = right;
    int key = array[right];
    while (begin < end)
    {
        while (begin < end && array[begin] <= key)
            begin++;
        if (begin < end)
        {
            array[right] = array[begin];
        }
        while (begin < end && array[end] >= key)
            end--;
        if (begin < end)
        {
            array[begin] = array[end];
        }
    }
    array[begin] = key;
    return begin;
}
//快速排序(三)
int Partion(int array[], int left, int right)
{
    int Cur = left;
    int Prev = Cur - 1;
    int key = array[right];
    while (Cur < right)
    {
        while (array[Cur] <= key && ++Prev != Cur)
        std::swap(array[Prev], array[Cur]);
        ++Cur;
    }
    std::swap(array[++Prev], array[right]);
    return Prev;
}

void QuickSort(int array[], int left, int right)
{
    if (left < right)
    {
        int div = Partion(array,left,right);
        QuickSort(array,left,div-1);
        QuickSort(array,div + 1,right);
    }
}

//快速排序(四)非递归实现
void QuickSort(int array[], int left, int right)
{
    stack<int> s;
    s.push(right);
    s.push(left);


    int div = 0;
    while (!s.empty())
    {
        left = s.top();
        s.pop();
        right= s.top();
        s.pop();

        if (left<right)
        {
            div = Partion(array,left,right);
            s.push(right);
            s.push(div+1);
            s.push(div-1);
            s.push(left);
        }
    }
}