permulation and review

相关知识:next_permulation 、prev_permulation 算法
题目来源：http://zion.sysu.edu.cn/m/ass/6296
题意：
Give you n numbers, and you can have n! permutations.
Then you can sort them with their lexicographically order.
For example, if n = 3 then we have 6 sorted permutations.
0 1 2
0 2 1
1 0 2
1 2 0
2 0 1
2 1 0
The class permu is a permutation.
You have to overload some operators like ++, –, <<
Hint:

实现前置++， 后置++， 前置–， 后置–， 输出流。

++使当前排列变为字典序比他大一个的排列。例如0 1 2会变成 0 2 1 如果是2 1 0则会变成0 1 2

–使当前排列变为字典序比他小一个的排列。例如2 1 0 会变成2 0 1 如果是0 1 2 则会变成2 1 0

输出流 输出格式为n个数字，每两个数字之间用空格隔开。行末没有空格和换行（换行在main.cpp中已经有了）

法一：直接调用algorithm库的next_permulation和prev_permulation函数

法二，自己写,下面在代码注释中讲解算法：

//在这里写成了一个类
#ifndef PERMU_H
#define PERMU_H
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

class permu {
 private:
    vector<int> storage;
    int len;
 public:
    explicit permu(int n);
    //前置++
    permu operator++();
    //后置++
    permu operator++(int temp);
    //前置--
    permu operator--();
    //后置--
    permu operator--(int temp);
    friend ostream& operator<<(ostream& cout, const permu& in);
};

    permu::permu(int n) {
        len = n;
        for (int i = 0; i < n; i++) {
            storage.push_back(i);
        }
    }
    permu permu::operator++() { // next_permulation 算法
        int i, j = 0;
// step 1.倒找第一个元素storage[i]，
满足 storage[i] < storage[i+1]
            if (storage[i] < storage[i+1]) {
                break;
            }
        }
        if (-1 != i) {  /*若找到上述i,则逆序找第一个
        元素storage[j], 满足storage[j] > storage[i],
         然后进行step2. 交换storage[i] 和 storage[j]*/
            for (j = len - 1; j >= 0; j--) {
                if (storage[j] > storage[i]) {
                    break;
                }
            }

            int hold = storage[i];
            storage[i] = storage[j];
            storage[j] = hold;
        }
        /*step 3. 将storage[i+1]到最后一个元素，
        逆序就得到所需序列*/
                /*若找不到这样i，即i = -1，说明
                已没有更大的next_permulation，
                直接将所有元素逆序（）*/
        queue<int> reverse_holder;
        for (int k = len - 1; k > i; k--) {
            reverse_holder.push(storage[k]);
            storage.pop_back();
        }
        while (!reverse_holder.empty()) {
            storage.push_back(reverse_holder.front());
            reverse_holder.pop();
        }
        return *this;
    }
    permu permu::operator++(int temp) {
        permu out = *this;
        ++(*this);
        return out;
    }
    permu permu::operator--() { 
    // prev_permulation算法
        int i, j = 0;
        for (i = len - 2; i >= 0; i--) {
        // step 1.倒找第一个元素storage[i]，满足 storage[i] > storage[i+1]
            if (storage[i] > storage[i+1]) {
                break;
            }
        }
        if (-1 != i) { /*若找到上述i,则逆序找第一个元素storage[j], 
        满足storage[j] < storage[i], 然后进行step2. 
        交换storage[i] 和 storage[j]*/
            for (j = len - 1; j >= 0; j--) {
                if (storage[j] < storage[i]) {
                    break;
                }
            }
            int hold = storage[i];
            storage[i] = storage[j];
            storage[j] = hold;
        }

        queue<int> reverse_holder; /*step 3. 将storage[i+1]到最
        后一个元素，逆序就得到所需序列*/
                /*若找不到这样i，即i = -1，说明已没有
                更小的prev_permulation，直接将所有
                元素逆序（）*/
        for (int k = len - 1; k > i; k--) {
            reverse_holder.push(storage[k]);
            storage.pop_back();
        }
        while (!reverse_holder.empty()) {
            storage.push_back(reverse_holder.front());
            reverse_holder.pop();
        }
        return *this;
    }
    permu permu::operator--(int temp) {
        permu out = *this;
        --(*this);
        return out;
    }
    ostream& operator<<(ostream& cout, const permu& in) {
        int i = 0;
        for (; i < in.len - 1; i++) {
            cout << in.storage[i] << ' ';
        }
        cout << in.storage[in.len - 1];
        return cout;
    }

#endif