全排列c语言
#include <stdio.h>
#include <string.h>
char string[]="123456789a";
int used[10]={0};
char output[10];
int length;
void Fun(int d)
{
int i;
for(i=0;i<=length;i++)
{
if(!used[i])
{
used[i]=1;
output[d]=string[i];
if(d==length)
{
for(d=0;d<length;d++)
{
if(output[d]=='a')
printf("10 ");
else printf("%c ",output[d]);
}
if(output[length]=='a')
printf("10\n");
else
printf("%c\n",output[length]);
}
else
Fun(d+1);
used[i]=0;
}
}
}
int main()
{
int n;
scanf("%d",&n);
string[n]=0;
length=strlen(string)-1;
Fun(0);
return 0;
}
⑵ C语言怎么实现有重复元素的全排列
整体思路就是利用回溯的思想，也可认为是深度优先搜索
从字符串第一位idx=0开始，每次递归都从s[idx]之后选择一个字符与s[idx]交换
因为可能有重复字符，可使用哈希数组标记当前循环每个字符是否被选择
因为字符范围不超过ASCII码，所以使用128空间的数组足够用来标记了
选择好当前字符s[i]并与s[idx]交换之后，递归调用继续排列下一位s[idx+1]
注意这里要进行回溯，即不选s[i]而选择之后的某个字符交换到s[idx]
所以要将之前的s[i]与s[idx]交换过来，恢复原状，才能循环判断下一个选择
具体代码截图如下：
结果正确，望采纳~
附源码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXN 1000000 // 排列总数可能很多
int num = 0; // 记录排列总数
char *res[MAXN] = {NULL}; // 指针数组保存排列结果
void swap(char *x, char *y) { // 交换两个字符变量的内容
char ch = *x;
*x = *y;
*y = ch;
}
void perm(char *s, int n, int idx) { // 回溯产生字符串全排列
if (idx == n) { // 已排列到字符串结尾
res[num] = (char *)malloc(sizeof(char) * (n + 1));
//printf("%s ", s); // 输出当前排列
strcpy(res[num], s); // 保存当前排列
num++; // 排列总数加1
return;
}
int i, hash[128] = {0}; // 哈希数组，标记每个字符是否被选择
for (i = idx; i < n; i++) {
if (hash[s[i]] == 1)
continue; // 跳过已被标记过的重复字符
hash[s[i]] = 1; // 选过的话在数组中标记为1
swap(&s[idx], &s[i]); // 选择s[i]交换到s[idx]
perm(s, n, idx + 1); // 递归，继续s[idx+1]的选择
swap(&s[idx], &s[i]); // 回溯，当前不选择s[i]，而选择其他字符
}
}
int main() {
int n, i;
scanf("%d", &n);
char *s = (char *)malloc(sizeof(char) * (n + 1));
scanf("%s", s);
perm(s, n, 0);
printf("一共有%d种排列: ", num); // 输出排列总数
for (i = 0; i < num; i++) { // 输出所有排列
printf("%s ", res[i]);
free(res[i]); // 释放内存空间
}
free(s);
return 0;
}
⑶ C语言的全排列问题！急！
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int hash[27];
char word[201];
int n;
void dfs(int cur)
{
if(cur>=n)
{
printf("%s\n",word);
return ;
}
int i;
for(i=0;i<26;i++)
if(hash[i])
{
hash[i]--;
word[cur]=i+'a';
dfs(cur+1);
hash[i]++;
}
return ;
}
int main()
{
int i;
scanf("%s",word);
n=strlen(word);
memset(hash,0,sizeof(hash));
for(i=0;i<n;i++)
hash[word[i]-'a']++;
dfs(0);
return 0;
}
楼主看一下，输入一行字符，输出全排列，多个案例的话最外面加个while循环就是了
⑷ c语言 重复字符全排列
给程序加点注释，让别人也稍微余搏明白一下
呵呵，你确定自己的程序在思想上之类的没有错误么？
在perm后面的for中调用circle_*的函数的时候，你传入的l总是会比i大的
这样一来在函数中m接收l，i接收i
然后竖辩祥再circle_*中的for循环的判断条件是i-m应该灶雹是不会执行吧
至于你说的那个功能我也不是很清楚
呵呵，能帮的就只有这些了
⑸ c语言全排列
基本思想是用回溯法来搜索每一种排列
不过楼主对问题的说明不是很详细，所以我只好写个
普适性
比较大的了
下面这个
程序
读取一行
字符串
，然后对该字符串中的所有
字符
进行全排列输出
注：输入的字符串不要太长，因为不存在能够在短时间内输出全排列的
算法
#include
<stdio.h>
#include
<string.h>
#include
<memory.h>
int
m;//记录字符串
长度
int
n;//记录字符串中的字符
种类
数
char
map[256];//记录是哪几种字符
int
count[256];//记录每种字符有多少个
void
Make_Map(char
*str)//统计字符串的相关信息
{
int
s[256];
int
i;
memset(s,0,sizeof(s));
memset(count,0,sizeof(count));
m=strlen(str);
while(*str)
{
s[*str]++;
str++;
}
n=0;
for
(i=0;i<256;i++)
if
(s[i])
{
map[n]=i;
count[n]=s[i];
n++;
}
}
int
stack[1000];//递归用的栈，并记录当前生成的排列
void
Find(int
depth)//递归式回溯法生成全排列
{
if
(depth==m)
{
int
i;
for
(i=0;i<depth;i++)
putchar(map[stack[i]]);
putchar('\n');
}
else
{
int
i;
for
(i=0;i<n;i++)
if
(count[i])
{
stack[depth]=i;
count[i]--;
Find(depth+1);
count[i]++;
}
}
}
main()
{
char
str[1000];
gets(str);
Make_Map(str);
Find(0);
}
⑹ 求c语言全排列算法
这个说起来太麻烦了, 我找了一个, 你看看行不, 不可以的话, 私聊吧.
全排列用的是 置换算法，
算法这东西重在理解。具体代码并不那么重要。
全排列是将一组数按一定顺序进行排列，如果这组数有n个，那么全排列数为n!个。现以{1, 2, 3, 4, 5}为
例说明如何编写全排列的递归算法。
1、首先看最后两个数4, 5。 它们的全排列为4 5和5 4, 即以4开头的5的全排列和以5开头的4的全排列。
由于一个数的全排列就是其本身，则宽从而得到以上结果。
2、再看后三个数3, 4, 5。它们的全排列为3 4 5、3 5 4、握罩 4 3 5、 4 5 3、 5 3 4、 5 4 3 六组数。
即以3开头的和4,5的全排列的组合、以4开头的和3,5的全排列的组合和以5开头的和3,4的全排列的组合.
从而可以推断，设一组数p = {r1, r2, r3, ... ,rn}, 全排列为perm(p)，pn = p - {rn}。
因此perm(p) = r1perm(p1), r2perm(p2), r3perm(p3), ... , rnperm(pn)。当n = 1时perm(p} = r1。
为了更容易理解，将整组孙皮亮数中的所有的数分别与第一个数交换，这样就总是在处理后n-1个数的全排列。
算法如下：
#include <stdio.h>
int n = 0;
void swap(int *a, int *b)
{
int m;
m = *a;
*a = *b;
*b = m;
}
void perm(int list[], int k, int m)
{
int i;
if(k > m)
{
for(i = 0; i <= m; i++)
printf("%d ", list[i]);
printf("\n");
n++;
}
else
{
for(i = k; i <= m; i++)
{
swap(&list[k], &list[i]);
perm(list, k + 1, m);
swap(&list[k], &list[i]);
}
}
}
int main()
{
int list[] = {1, 2, 3, 4, 5};
perm(list, 0, 4);
printf("total:%d\n", n);
return 0;
}
链接: http://..com/question/71586341.html?si=2
⑺ c语言 给出一个数怎样输出该数的全排列
C语言版：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
inta[10],book[10],n,k[10],l;
voiddfs(intstep)
{
inti=0;
if(step==l+1)
{
if(a[1]!=0)
{
for(i=1;i<=l;i++)
{
printf("%d",a[i]);
}
printf(" ");
}
return;
}
for(i=0;i<l;i++)
{
if(book[k[i]]==0)
{
a[step]=k[i];
book[k[i]]=1;
dfs(step+1);
book[k[i]]=0;
}
}
}
intmain(void)
{
memset(k,0,sizeof(k));
memset(book,0,sizeof(book));
intn;
scanf("%d",&n);
charbuf[15]="";
sprintf(buf,"%d",n);
l=strlen(buf);
inti=0;
for(i=0;i尺雀族<l;i++)
k[i]=buf[i]-'0';
dfs(1);
system("pause");//如陵弊果通不过编译就试着删除这句话
return0;
}
C++版：
#include<cstdio>
#include<cstdlib>
#include<cstring>
inta[10],book[10],n,k[10],l;
voiddfs(intstep)
{
if(step==l+1)
{
if(a[1]!=0)
{
for(inti=1;i<=l;i++)
{
printf("%d",a[i]);
}
printf(" ");
}
return;
}
for(inti=0;i<l;i++)
{
if(book[k[i]]==0)
{
a[step]=k[i];
book[k[i]]=1;
dfs(step+1);
book[k[i]]=0;
}
}
}
intmain(void)
{
memset(k,0,sizeof(k));
memset(book,0,岁清sizeof(book));
intn;
scanf("%d",&n);
charbuf[15]="";
sprintf(buf,"%d",n);
l=strlen(buf);
for(inti=0;buf[i]!=' ';i++)
k[i]=buf[i]-'0';
dfs(1);
return0;
}
⑻ c语言作业,输出四个数A,B,C,D的全排列
#include<iostream>
#include<stdio.h>
#include<algorithm>
usingnamespacestd;
intmain()
{
哗态做intnum[4]={1,2,3,4};
do
{
printf("%c,%c,%c,%c "乱衡,num[0]+'A'-1,num[1]+'A'-1,num[2]+'A'-1,num[3]+'A'-1);
}while(next_permutation(num,num+4));
return0;
}
可以借助于stl模板中的next_permutation函数，这个函数是按照字典序不停的取该序列的下一个序列，直到结束。然后输出的时候讲数字转化为你要的字母即可。
例如 第一个序列是1,2,3,4,--》闭漏A，B，C，D
⑼ C语言中全排列问题思路
方法1：如果位数不多穷举
方法2：位数多建议递归。
⑽ C语言全排列问题
你的程序在swap()函数中只是将形参进行了值的对调,对实参无任何影响.
解决上述问题有两个方法:
1.正如楼上所说的,在C++环境下,可以将swap的两个参数改成引用类型,这样对它们的操作将实际作用于实参,实现如下:
函数定义:swap(int &a,int &b);
函数调用示例:swap(*(p+k);*(p+i));其中p是指针,k,i是整形偏移量.
2.在纯C环境下,可以将swap的两个参数改为指针类型,而在函数内部使用对其指向的地址中数据的解引用操作,实现对原变量的对调操作,实现如下:
函数定义:
swap(int *a,int *b)
{int t;
t=*a;
*a=*b;
*b=t;
}
函数调用示例:swap(p+k,p+i);其中p是指针,k,i是整形偏移量.
你的程序中还有两处涉及到指针使用的错误,我把改过的程序贴上来,错误已在注释中标注.
#include "stdio.h"
swap(int *a,int *b)
{
int t;
t=*a;
*a=*b;
*b=t;
}
perm(int *p,int k,int n)
{
int i;
if(k==n-1)
{
for(i=0;i<n;i++)
printf("%d",*(p+i));
printf("\n");
}
else
{
for(i=k;i<n;i++)
{
swap((p+k),(p+i));
perm(p,k+1,n); //原为perm(*p,k+1,n).在此应传递的是指针p指向的地址,而不是该地址中的内容.
swap((p+k),(p+i));
}
}
}
main()
{
int i,list[3],*p;
for(i=0;i<3;i++)
list[i]=i+1;
p=list; //原为p=list[0].这里应将数组list的首地址赋值给指针p,所以就写成p=list或p=&list[0].
perm(p,0,3);
}