求给定数列的全排列

递归的方式

对于数组A[0..n-1]，它的全排列可以表示为A[0] 和余下数全排的组合，A[1]和余下数全排的组合......A[n-1]和余下数全排的组合的并集。余下数可以按照这种方式递归下去，直至余下数只有一个。

#include <iostream>
#include <vector>

void swap(vector<int> &numberslist , int i , int x)
{
    if(i != x)
    {
        int temp = numberslist[i];
        numberslist[i] = numberslist[x];
        numberslist[x] = temp;
    }
}
void fullarray(vector<int> &numberslist , int i , int j)
{
    //上次递归进行到对一个数进行全排列，则意味着得到新序列，打印
    if(i>j)
    {
        for(int y = 0; y< numberslist.size(); y++)
            cout<<numberslist[y]<<" ";
        cout<<endl;
        return;
    }
    for(int x = i; x <= j; x++)
    {
        //将此次全排的序列的每一个和此序列的第一个进行交换，然后将剩下的继续全排
        swap(numberslist, i ,x);
        fullarray(numberslist, i+1, j);
        //全排列结束后还原
        swap(numberslist, i ,x);
    }
}
int main()
{
    vector<int> numberslist;
    int number;
    while(cin>>number)
        numberslist.push_back(number);
    fullarray(numberslist,0,numberslist.size()-1);

非递归的方式

非递归的方式可以分为两种，一种是对递归方式的改写（模拟栈），感兴趣的可以试一下。另外一种采取了不同的思路

例如对数组 12345，求它的全排列，可以归纳为迭代的求比他大的第一个排列，即12354，然后再求比12354大的第一个排列，即12435，以此类推。。。

如何求下一个排列呢，比如对排列378763来说，我们从后往前找第一对递增的相邻数，相邻数依次为63，76，87，78，37，78为第一对递增的相邻数，并把7称为替换数，

再从替换数从前往后找比它大的最小数，这里就是8，与之替换，再将之后的数翻转，得到下一个排列，383677。可以用笔试试为什么这么做就能得到下一个排列。好了，下面贴上代码。

#include <algorithm>
#include <iostream>
#include<vecto#include<stdio.h>

using namespace std;

void swap(vector<int> &,int,int);

void print(const vector<int>& numbers)
{
    for(int i = 0; i< numbers.size(); i++)
        printf("%d ",numbers[i]);
    printf("\n");
}
int partial_reverse(vector<int> & numbers, int i ,int j)
{
    if(i >= j)
        return -1;
    int p = i , q = j;
    while(p < q)
    {
        int temp = numbers[p];
        numbers[p] = numbers[q];
        numbers[j] = temp;
        p++,q--;
    }
    return 0;
}
int minOf(vector<int> & numbers , int p)
{
    int n = numbers.size()-1;
    int min = p;
    if(p > n)
        return -1;
    for(int i = p+1; i <= n; i++)
    {
        if(numbers[i] <= numbers[min] && numbers[i] > numbers[p-1])
            min = i;
    }
    return min;
}
void non_re_fullarray(vector<int> & numbers)
{
    print(numbers);
    int p = numbers.size()-1;
    while(p > 0)
    {
        if(numbers[p-1] < numbers[p])
        {
            int min = minOf(numbers,p);
            swap(numbers , p-1 ,min);
            partial_reverse(numbers,p,numbers.size()-1);
            print(numbers);
            p = numbers.size()-1;
        }
        else
        {
            p--;
        }
    }
}

int main()
{
    vector<int> numberslist;
    int number;
    while(cin>>number)
        numberslist.push_back(number);
    sort(numberslist.begin(),numberslist.end());
    non_re_fullarray(numberslist);
}

 恩，再贴一个我同学的代码，把非递归改为递归的，不过他递归部分的代码和我的不太一样，他没有采用交换，而是采用标记的方式。

#include <iostream>
#include <stack>

using namespace std;

int a[] = {1, 2, 3,4,5};
int s[] = {-1, -1,-1,-1,-1};
int length = 5;
bool v[] = {false, false, false,false,false};

void permutation(int n)
{
    if (n == 1)
    {
        for (int i = 0; i < length - 1; i++)
        {
            cout << a[s[i]] << ' ';
        }
        for (int i = 0; i < length; i++)
        {
            if (!v[i])
            {
                cout << a[i] << endl;
                break;
            }
        }
    }
    else
    {
        for (int i = 0; i < length; i++)
        {
            if (!v[i])
            {
                v[i] = true;
                s[length - n] = i;
                permutation(n - 1);
                v[i] = false;
            }
        }
    }
}

void nonrecursive()
{
    stack<int> stack_n, stack_i;
    stack_n.push(length);
    stack_i.push(0);
    while (!stack_n.empty())
    {
        int n = stack_n.top();
        if (n == 1)
        {
            for (int i = 0; i < length - 1; i++)
            {
                cout << a[s[i]] << ' ';
            }
            for (int i = 0; i < length; i++)
            {
                if (!v[i])
                {
                    cout << a[i] << endl;
                    break;
                }
            }
            stack_n.pop();
            stack_i.pop();
        }
        else
        {
            if (stack_i.top() > 0)
            {
                v[stack_i.top() - 1] = false;
            }
            bool lastloop = true;
            for (int i = stack_i.top(); i < length; i++)
            {
                if (!v[i])
                {
                    v[i] = true;
                    s[length - n] = i;
                    stack_i.pop();
                    stack_i.push(i + 1);
                    stack_n.push(n - 1);
                    stack_i.push(0);
                    lastloop = false;
                    break;
                }
            }
            if (lastloop)
            {
                stack_i.pop();
                stack_n.pop();
            }
        }
    }
}

int main()
{
    permutation(length);
    cout << "==============" << endl;
    nonrecursive();
    return 0;
}