快速排序之递归与非递归写法

#include <cstdio>
#include <iostream>
#include <stack>//因为普通的递归写法其实就是用到栈,所以写非递归的时候只要自己手动模拟一下进栈出栈就行了
#include <ctime>//这个头文件是为了计算递归和非递归的时间复杂度
#include <vector>//这是c++的一种用法,下文会具体讲到
#include <cstdlib>//rand()函数需要
#include <algorithm>//这个头文件很神奇,里面有很多已经封装好的算法可以直接调用


using namespace std;


struct node//建立结构体为了方便
{
    int l, r;
};
int partion(vector <int> a, int l, int r)//这个是移位交换函数,相当于挖坑填数
{
    int i, j, num;
    i = l;
    j = r;
    num = a[l];//把首元素当做标杆
    while(i < j)
    {
        while(i < j && a[j] > num)//从后往前遍历
            j--;
        if(i < j)//交换值,i有值了,可是j的值相当于没有了
        {
            a[i] = a[j];
            i++;
        }
        while(i < j && a[i] < num)//从前往后遍历
            i++;
        if(i < j)交换值,上一个j有值了,可是当前i的值相当于没有了
        {
            a[j] = a[i];
            j--;
        }
    }
    a[i] = num;//最后把首元素赋给"中间"的这个值
    return i;//返回中间的这个数,把原始数组分成左右两部分,左边的比他小,右边的比他大
}
void quick_sort2(vector <int> a, int l,int r)
{
    stack <node> s;
    if(l < r)
    {
        int i = partion(a, l, r);//排序
        if(l < i - 1)
        {
            node no = {l, i - 1};
            s.push(no);//左边压栈
        }
        if(i + 1 < r)
        {
            node no = {i + 1, r};
            s.push(no);//右边压栈
        }
        while(!s.empty())
        {
            node no = s.top();
            s.pop();//这里一定要记得出栈
            i = partion(a, no.l, no.r);//排序
            if(no.l < i - 1)
            {
                node de = {no.l, i - 1};
                s.push(de);//左边压栈
            }
            if(i + 1 < no.r)
            {
                node de = {i + 1, no.r};
                s.push(de);//右边压栈
            }
        }
    }
}
void quick_sort1(vector <int> a, int l, int r)
{
    if(l < r)
    {
        int i = partion(a, l, r);
        quick_sort1(a, l, i - 1);//有点树的味道,先遍历左边的,再遍历右边的
        quick_sort2(a, i + 1, r);
    }
}
int main()
{
    int i, len = 1000;
    vector <int> a;//建立一个Vector 
    for(i = 0; i < len; i++)
    {
        a.push_back(rand());//随机 在尾部加入一个数据。
    }
    clock_t t1 = clock();
    quick_sort1(a, 0, len - 1);
    clock_t t2 = clock();
    printf("the recursion time:%f\n", 1.0 * (t2 - t1) / CLOCKS_PER_SEC);//这里就是为了计算时间复杂度了,可以控制len的长度,即数组大小来控制时间,其中如果len太小会是0哦
    random_shuffle(a.begin(), a.end());//a.begin()返回的是首地址,这个韩式是为了打乱随机数的顺序
    clock_t t3 = clock();
    quick_sort2(a, 0, len - 1);
    clock_t t4 = clock();
    printf("the non recursion time:%f\n", 1.0 * (t4 - t3) / CLOCKS_PER_SEC);
    return 0;

}

vector是一个能够存放任意类型的动态数组，能够增加和压缩数据

对于random_shuffle()函数参考此文点击打开链接

简单的使用方法如下：

1 2 3

vector<int>test; //建立一个vector test.push_back( 1 ); test.push_back( 2 ); //把1和2压入vector这样test[0]就是1,test[1]就是2

c.back()

传回最后一个数据，不检查这个数据是否存在。

c.begin()

传回 迭代器中的第一个数据地址。

c.capacity()

返回容器当前已分配的容量。

c.clear()

移除容器中所有数据。

c.empty()

判断容器是否为空。

c.end() //指向 迭代器中末端元素的下一个，指向一个不存在元素。

c.erase(pos)//　删除pos位置的数据，传回下一个数据的位置。

c.erase(beg,end)

删除[beg,end）区间的数据，传回下一个数据的位置。

c.front()

传回第一个数据。

vector<Elem> //创建一个空的vector

vector<Elem> c1(c2)//复制一个vector

vector <Elem> c(n)//创建一个vector，含有n个数据，数据均已缺省构造产生

vector <Elem> c(n,elem)//创建一个含有n个elem拷贝的vector

vector <Elem> c(beg,end)//创建一个以（beg;end）为区间的vector

c.~ vector <Elem>()//销毁所有数据，释放内存

vector容器提供了多种创建方法，下面介绍几种常用的。

创建一个Widget类型的空的vector对象：

vector<Widget> vWidgets;

创建一个包含500个Widget类型数据的vector：

vector<Widget> vWidgets(500);

创建一个包含500个Widget类型数据的vector，并且都初始化为0：

vector<Widget> vWidgets(500,Widget(0));

创建一个Widget的拷贝：

vector<Widget> vWidgetsFromAnother(vWidgets);

向vector添加一个数据

vector添加数据的缺省方法是 push_back（）。 push_back（）函数表示将数据添加到vector的尾部，并按需要来分配内存。

vector传参时得定义vector类型