求n个数的全排列，n不定。用c语言。用于银行家算法中求安全序列

C语言 现在想要打印一列数字的全排列，这列数字位数不定，该怎么弄？~

用结构体怎么做我也不知道 不过蠢一点的办法还是有的
int b；
char a；
scanf（"%c",&a）;
switch（a）
{
case'1':b=10;xxxx(b)；break；//一位的时候是循环10次对吧0~9
case'2':b=100;xxxx(b)；break;
.
.
.
.
case'32':..........;xxxx(b);break;
}

void xxxx(int b)//定义一个循坏函数
{
int c =0;
for（;b>0;b--）
{

printf("%d.",c);
c++;
}
}

银行家算法
银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。不安全状态不一定导致死锁。
那么什么是安全序列呢？
安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
银行家算法：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
算法：
n：系统中进程的总数
m：资源类总数
Available: ARRAY[1..m] of integer;
Max: ARRAY[1..n,1..m] of integer;
Allocation: ARRAY[1..n,1..m] of integer;
Need: ARRAY[1..n,1..m] of integer;
Request: ARRAY[1..n,1..m] of integer;
符号说明：
Available 可用剩余资源
Max 最大需求
Allocation 已分配资源
Need 需求资源
Request 请求资源
当进程pi提出资源申请时，系统执行下列
步骤：(“=”为赋值符号，“==”为等号)
step（1）若Request<=Need, goto step（2）；否则错误返回
step（2）若Request<=Available, goto step（3）；否则进程等待
step（3）假设系统分配了资源，则有：
Available=Available-Request;
Allocation=Allocation+Request;
Need=Need-Request
若系统新状态是安全的，则分配完成
若系统新状态是不安全的，则恢复原状态，进程等待
为进行安全性检查，定义数据结构：
Work:ARRAY[1..m] of integer;
Finish:ARRAY[1..n] of Boolean;
安全性检查的步骤：
step (1):
Work=Available;
Finish=false;
step (2) 寻找满足条件的i：
a.Finish==false;
b.Need<=Work;
如果不存在，goto step(4)
step(3)
Work=Work+Allocation;
Finish=true;
goto step(2)
step (4) 若对所有i,Finish=true,则系统处于安全状态，否则处于不安全状态
/* 银行家算法，操作系统概念(OS concepts Six Edition)
reedit by Johnny hagen，SCAU，run at vc6.0
*/
#include "malloc.h"
#include "stdio.h"
#include "stdlib.h"
#define alloclen sizeof(struct allocation)
#define maxlen sizeof(struct max)
#define avalen sizeof(struct available)
#define needlen sizeof(struct need)
#define finilen sizeof(struct finish)
#define pathlen sizeof(struct path)
struct allocation
{
int value;
struct allocation *next;
};
struct max
{
int value;
struct max *next;
};
struct available /*可用资源数*/
{
int value;
struct available *next;
};
struct need /*需求资源数*/
{
int value;
struct need *next;
};
struct path
{
int value;
struct path *next;
};
struct finish
{
int stat;
struct finish *next;
};
int main()
{
int row,colum,status=0,i,j,t,temp,processtest;
struct allocation *allochead,*alloc1,*alloc2,*alloctemp;
struct max *maxhead,*maxium1,*maxium2,*maxtemp;
struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1;
struct need *needhead,*need1,*need2,*needtemp;
struct finish *finihead,*finish1,*finish2,*finishtemp;
struct path *pathhead,*path1,*path2;
printf("
请输入系统资源的种类数:");
scanf("%d",&colum);
printf("请输入现时内存中的进程数:");
scanf("%d",&row);
printf("请输入已分配资源矩阵:
");
for(i=0;i<row;i++)
{
for (j=0;j<colum;j++)
{
printf("请输入已分配给进程 p%d 的 %c 种系统资源:",i,'A'+j);
if(status==0)
{
allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);
alloc1->next=alloc2->next=NULL;
scanf("%d",&allochead->value);
status++;
}
else
{
alloc2=(struct allocation *)malloc(alloclen);
scanf("%d,%d",&alloc2->value);
if(status==1)
{
allochead->next=alloc2;
status++;
}
alloc1->next=alloc2;
alloc1=alloc2;
}
}
}
alloc2->next=NULL;
status=0;
printf("请输入最大需求矩阵:
");
for(i=0;i<row;i++)
{
for (j=0;j<colum;j++)
{
printf("请输入进程 p%d 种类 %c 系统资源最大需求:",i,'A'+j);
if(status==0)
{
maxhead=maxium1=maxium2=(struct max*)malloc(maxlen);
maxium1->next=maxium2->next=NULL;
scanf("%d",&maxium1->value);
status++;
}
else
{
maxium2=(struct max *)malloc(maxlen);
scanf("%d,%d",&maxium2->value);
if(status==1)
{
maxhead->next=maxium2;
status++;
}
maxium1->next=maxium2;
maxium1=maxium2;
}
}
}
maxium2->next=NULL;
status=0;
printf("请输入现时系统剩余的资源矩阵:
");
for (j=0;j<colum;j++)
{
printf("种类 %c 的系统资源剩余:",'A'+j);
if(status==0)
{
avahead=available1=available2=(struct available*)malloc(avalen);
workhead=work1=work2=(struct available*)malloc(avalen);
available1->next=available2->next=NULL;
work1->next=work2->next=NULL;
scanf("%d",&available1->value);
work1->value=available1->value;
status++;
}
else
{
available2=(struct available*)malloc(avalen);
work2=(struct available*)malloc(avalen);
scanf("%d,%d",&available2->value);
work2->value=available2->value;
if(status==1)
{
avahead->next=available2;
workhead->next=work2;
status++;
}
available1->next=available2;
available1=available2;
work1->next=work2;
work1=work2;
}
}
available2->next=NULL;
work2->next=NULL;
status=0;
alloctemp=allochead;
maxtemp=maxhead;
for(i=0;i<row;i++)
for (j=0;j<colum;j++)
{
if(status==0)
{
needhead=need1=need2=(struct need*)malloc(needlen);
need1->next=need2->next=NULL;
need1->value=maxtemp->value-alloctemp->value;
status++;
}
else
{
need2=(struct need *)malloc(needlen);
need2->value=(maxtemp->value)-(alloctemp->value);
if(status==1)
{
needhead->next=need2;
status++;
}
need1->next=need2;
need1=need2;
}
maxtemp=maxtemp->next;
alloctemp=alloctemp->next;
}
need2->next=NULL;
status=0;
for(i=0;i<row;i++)
{
if(status==0)
{
finihead=finish1=finish2=(struct finish*)malloc(finilen);
finish1->next=finish2->next=NULL;
finish1->stat=0;
status++;
}
else
{
finish2=(struct finish*)malloc(finilen);
finish2->stat=0;
if(status==1)
{
finihead->next=finish2;
status++;
}
finish1->next=finish2;
finish1=finish2;
}
}
finish2->next=NULL; /*Initialization compleated*/
status=0;
processtest=0;
for(temp=0;temp<row;temp++)
{
alloctemp=allochead;
needtemp=needhead;
finishtemp=finihead;
worktemp=workhead;
for(i=0;i<row;i++)
{
worktemp1=worktemp;
if(finishtemp->stat==0)
{
for(j=0;jnext,worktemp=worktemp->next)
if(needtemp->valuevalue)
processtest++;
if(processtest==colum)
{
for(j=0;j<colum;j++)
{
worktemp1->value+=alloctemp->value;
worktemp1=worktemp1->next;
alloctemp=alloctemp->next;
}
if(status==0)
{
pathhead=path1=path2=(struct path*)malloc(pathlen);
path1->next=path2->next=NULL;
path1->value=i;
status++;
}
else
{
path2=(struct path*)malloc(pathlen);
path2->value=i;
if(status==1)
{
pathhead->next=path2;
status++;
}
path1->next=path2;
path1=path2;
}
finishtemp->stat=1;
}
else
{
for(t=0;t<colum;t++)
alloctemp=alloctemp->next;
finishtemp->stat=0;
}
}
else
for(t=0;t<colum;t++)
{
needtemp=needtemp->next;
alloctemp=alloctemp->next;
}
processtest=0;
worktemp=workhead;
finishtemp=finishtemp->next;
}
}
path2->next=NULL;
finishtemp=finihead;
for(temp=0;temp<row;temp++)
{
if(finishtemp->stat==0)
{
printf("
系统处于非安全状态!
");
exit(0);
}
finishtemp=finishtemp->next;
}
printf("
系统处于安全状态.
");
printf("
安全序列为:
");
do
{
printf("p%d ",pathhead->value);
}
while(pathhead=pathhead->next);
printf("
");
return 0;
}

好久没用c了，所以代码可能要用到伪代码
先定义a[maxn]
用子函数递归
void p(int x)
{
if (n == x+1)
{
//foreach a print
//输出数组a
}
for (int i=1 to n)
{
a[x] = i;
p(x+1);
a[x] = 0;
}
}
主函数main调用p(n)

源代码：
#include<stdio.h>
#include<stdlib.h>
#defineN 100
#defineM 100
intavailable[M];
intmax[N][M];
intallocation[N][M];
intneed[N][M];
intn,m;

intv[N];
intflag_security=0;
/*
all_security函数为银行家算法的子算法：安全性算法
@work 系统可提供给进程继续运行的所需的各类资源数目，含m个元素
@num 进行试探性分配时，已得到资源分配的进程个数 为num-1
@s 存放已得到资源分配的进程个数，当num-1==n时即得到一个安全序列。
*/
voidall_security(int work[],int num,int s[]){
int i,j;
if(num==n+1){
flag_security=1;
int j;
printf("安全序列:");
for(j=1;j<num;j++)
printf("%d ",s[j]-1);
printf("\n");
}
int flag_error=0;
for(i=1;i<=n;i++){ //注意回溯时，同层节点的控制
flag_error=0; //之前flag_error声明在for外，导致剪枝失败
for(j=1;j<=m;j++){
if(need[i][j]>work[j]){
flag_error=1;
break;
}
}
if(!v[i]&&!flag_error){
v[i]=1;
s[num]=i;
int work2[M];
for(j=1;j<=m;j++){
work2[j]=work[j];
}
for(j=1;j<=m;j++){
work2[j]+=allocation[i][j];
}
all_security(work2,++num,s);
num--;
v[i]=0;
}
}
}
/*
bank为银行家算法
@pid 进程的pid,范围在0 ~ n-1
@request 进程pid的资源请求向量
@return 若可分配资源给进程pid,则return 1，否则return 0
*/
intbank(int pid,int request[]){
int i,j;
for(i=1;i<=m;i++){
if(request[i]>need[pid][i]){
printf("error:进程%d请求的资源数量>所需的资源数量！\n",pid-1);
exit(0);
}
if(request[i]>available[i]){
printf("error:系统无足够资源，进程%d等待中。。。\n",pid-1);
return 0;
}
}
for(i=1;i<=m;i++){
available[i]-=request[i];
allocation[pid][i]+=request[i];
need[pid][i]-=request[i];
}
int work[M];
for(j=1;j<=m;j++){
work[j]=available[j];
}
int s[N];
for(i=0;i<=n;i++){
v[i]=0;
}
flag_security=0;
all_security(work,1,s);
if(!flag_security){
printf("error:系统执行安全性算法，结果为此次资源分配后系统不处于安全状态!\n");
available[i]+=request[i];
allocation[pid][i]-=request[i];
need[pid][i]+=request[i];
return 0;
}
return 1;
}

intmain(){
int s[10];
int i,j,pid,request[M];;
printf("输入进程数和资源种类数：\n");
scanf("%d%d",&n,&m);

printf("输入各类资源的可分配资源数向量available：\n");
for(i=1;i<=m;i++){
scanf("%d",&available[i]);
}
printf("输入各个进程所需最大资源数量（矩阵max：行为进程，列为资源量）：\n");
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
scanf("%d",&max[i][j]);
}
}
printf("输入各个进程已分配的各类资源的数量（矩阵allocation：行为进程，列为资源量）:\n");
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
scanf("%d",&allocation[i][j]);
}
}
printf("输入各个进程还需要各类资源的数量（矩阵need：行为进程，列为资源量）:\n");
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
scanf("%d",&need[i][j]);
}
}
int work[M];
printf("\n\n输出系统当前时刻的可利用资源向量:\n");
for(j=1;j<=m;j++){
work[j]=available[j];
printf("%d ",available[j]);
}
printf("\n");
printf("输出当前时刻n个进程的还需要资源矩阵\n");
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
printf("%d ",need[i][j]);
}
printf("\n");
}
for(j=1;j<=m;j++){
work[j]=available[j];
}
all_security(work,1,s);
if(flag_security){
printf("\n此刻t0处于安全状态！\n\n");
} else{
printf("\n此刻t0处于不安全状态，接下来可能会发生死锁！程序关闭\n\n");
return 0;
}

printf("请输入请求进程标志pid(0~n-1):\n");
while(~scanf("%d",&pid)){
printf("请输入请求进程%d的资源请求向量：\n",pid);
for(i=1;i<=m;i++){
scanf("%d",&request[i]);
}
printf("输出系统当前时刻的可利用资源向量:\n");
for(j=1;j<=m;j++){
work[j]=available[j];
printf("%d ",available[j]);
}
printf("\n\n");
printf("输出当前时刻n个进程的还需要资源矩阵\n");
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
printf("%d",need[i][j]);
}
printf("\n");
}
int flag_request=bank(pid+1,request);
if(flag_request){
printf("进程%d请求资源成功！\n\n",pid);
}else{
printf("进程%d请求资源失败!\n\n",pid);
}
printf("请输入进程标志pid(0~n-1):\n");
}
return 0;
}

---

城固县13238305841： 求n个数的全排列,n不定.用c语言.用于银行家算法中求安全序列 - ？
满罚通用： 好久没用c了,所以代码可能要用到伪代码 先定义a[maxn] 用子函数递归 void p(int x) {if (n == x+1){//foreach a print//输出数组a}for (int i=1 to n){a[x] = i;p(x+1);a[x] = 0;} } 主函数main调用p(n)

城固县13238305841： C语言中《计算出n个整数的全排列种数,并输出这所有的排列》怎样写?求大神帮助!!!!! - ？
满罚通用： 源程序如下:#include <stdio.h> #include <string.h> char string[9]=＂12345678＂; int used[9]={0}; char output[9]; int length; void F(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++)...

城固县13238305841： 急!!!如何用C语言编写打出1~n个数的全排. - ？
满罚通用： 递归,比较简单,10个数全排如下#include<stdio.h> void swap(int k,int i,int a[]) { int t; t=a[k]; a[k]=a[i]; a[i]=t; } void pailie(int a[],int i,int n) {int k,t; if(i==n) { for(t=0;t<n;t++) printf(＂%3d＂,a[t]); printf(＂\n＂); } elsefor(k=i;k<n;k++) { swap(i,k,a); pailie(a...

城固县13238305841： C语言对N个数进行排序 - ？
满罚通用： #define N=10;//对10个数排序 main() { int a[N]; int i,j,t; printf(＂input 10 numbers:\n＂); for(i=1;i<=10;i++) scanf(＂%d＂,&a[i]); printf(＂\n＂); for(j=1;j<=9;j++) for(i=1;i<=10-j;i++) if(a[i]>a[i+1]) {t=a[i];a[i]=a[i+1];a[i+1]=t;} printf(＂the sorted numbers is:\n＂); for(i=1;i<=10;i++) printf(＂%d＂,a[i]); }

城固县13238305841： c语言中怎样把n个数排列 得到所有排列情况 - ？
满罚通用： #includeinline void Swap(char& a, char& b) {// 交换a和b char temp = a; a = b; b = temp; } void Perm(char list[], int k, int m) { //生成list [k:m ]的所有排列方式 int i; if (k == m) {//输出一个排列方式 for (i = 0; i putchar(list[i]); putchar('\n'); } else // list[k:m ]有...

城固县13238305841： c语言,如何得到n个数所有的排列？
满罚通用： #include <vector> #include <iostream> #include <conio.h> using namespace std; int contain(vector<int> & paraPath, int paraVal, int paraCount) {for(int i=0; i<paraCount; i++){if(paraPath[i] == paraVal)return 1;}return 0; } void ...

城固县13238305841： C语言数字全排列的问题(急!!)求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]=...

城固县13238305841： c语言 输入n个数进行排序 - ？
满罚通用： 你将输入写成一个循环,不要将下面放入到while循环里面while(a[i]!='\n'){scanf(＂%d＂,&a[i]);i++;t=i;} 这样就可以了!

城固县13238305841： c语言求全排列 - ？
满罚通用： 用迭代算法简单些, 就是速度慢许.算法为: 为求1 ~ n个整数的函数 permutation, * 如果n = 2, 只有两种排列方式, 即 (1, 2) (2, 1)* 迭代计算1 ~ n-1个整数的全排列* 将n插入所得到的1 ~ n-1的全排列的任意位置得到1 ~ n的全排列.

城固县13238305841： C语言编程,利用对n个整数进行排序 - ？
满罚通用： 最后循环改为:for( i=0;i