【编程题目】字符串的排列（字符串）★

/*
53.字符串的排列（字符串）。
题目：输入一个字符串，打印出该字符串中字符的所有排列。
例如输入字符串 abc，则输出由字符 a、b、c 所能排列出来的所有字符串
abc、acb、bac、bca、cab 和 cba。
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char A[128][2] = {0}; //统计字符串中每种字符出现的次数
char ANS[10000]; //可能的输出
int N; //字符种类数
int LEN; //输入字符串长度
int getTimes(char * in) //统计字符个数 以及 每个字符出现的次数
{
    int len = strlen(in);
    bool B[100] = {0};
    int n = 0;
    for(int i = 0; in[i] != ‘\0‘; i++)
    {
        if(B[i] == false)
        {
            for(int j = i; in[j] != ‘\0‘; j++)
            {
                if(in[j] == in[i])
                {
                    A[n][0] = in[i];
                    A[n][1]++;
                    B[j] = true;
                }
            }
            n++;
        }
    }
    return n;
}

void traverse(int len) //递归求解 每个位置遍历选用A中可用次数大于0的的字符
{
    if(len == 0)
    {
        for(int i = 0; i < LEN; i++)
        {
            printf("%c ", ANS[i]);
        }
        printf("\n");
        return;
    }
    for(int i = 0; i < N; i++)
    {
        if(A[i][1] != 0) //如果不等于0 说明该字符还可以使用
        {
            ANS[LEN - len] = A[i][0]; //把当前字符存在答案中
            A[i][1]--;  //当前字符可用次数减1
            traverse(len - 1); //求下一个位置的字符
            A[i][1]++;  //恢复当前字符的可使用次数
        }
    }
    
}

void getall(char * in)
{
    LEN = strlen(in);
    N = getTimes(in);
    traverse(LEN);
}
int main()
{
    char in[100] = "abcc"; 
    getall(in);
    return 0;
}

/*
http://blog.csdn.net/hackbuteer1/article/details/7462447
在上面的网址上看了答案后 发现自己写的代码实在是太挫了，有很多不必要的全局变量。还有输入字符中一共有几种字符，每种字符的出现次数其实可以不用具体
求出来的。直接比较判断就好了。
网上还给出了非递归算法，找到了从小到大输出所有可能组合的方法，非常值得学习。
*/

//递归
#include<stdio.h>
#include<string.h>
#include <algorithm>
using namespace std;
bool isswap(char * pBegin, char * pNow)
{
    for(char *p = pBegin; p < pNow; p++)
    {
        if(*p == *pNow)
            return false;
    }
    return true;
}

void traverse(char * pStr,char * pBegin)
{
    if(/**pBegin == ‘\0‘*/strlen(pBegin) == 1) //两种判断方式都可以
    {
        static int n = 0;
        printf("%d: %s\n", ++n, pStr);    
    }
    else
    {
        for(char *p = pBegin; *p != ‘\0‘; p++)
        {
            if(isswap(pBegin, p))
            {
                swap(*pBegin, *p);    //注意swap应该是 数值 而不是指针
                traverse(pStr, pBegin + 1);
                swap(*p, *pBegin);
            }
        }
    }
}

//非递归
int cmp(const void * a,const void * b)
{
    return *((char *)a) - *((char *)b);
}

void reverse(char * pBegin, char * pEnd)
{
    while(pBegin < pEnd)
    {
        swap(*pBegin++, *pEnd--);
    }
}
bool nonrtraverse(char * pStr)
{
    int l = strlen(pStr);
    char * pEnd = pStr + l - 1; //定位最后一个字符
    if(pStr == pEnd)  //注意对只有一个字符的处理
        return false;
    for(char *p = pEnd; p != pStr; p--)
    {
        char * q = p - 1;
        if(*q < *p)
        {
            char* pFind = pEnd;
            while(*pFind <= *q) //注意这里，找到第一个比交换点数大的数
                --pFind;
            swap(*q, *pFind);
            reverse(p, pEnd);
            return true;
        }
    }
    reverse(pStr, pStr +l - 1);
    return false;
}

int main()
{
    char str[30] = "1224";
    traverse(str, str);
    qsort(str, strlen(str)-1, sizeof(char), cmp);
    int i = 0;
    do
    {
        printf("%d:%s\n", ++i, str);
    }
    while(nonrtraverse(str));
    return 0;
}