有四个互不相同的数字，输出由其中三个不重复数字的全排列

 

/*
有四个互不相同的数字，输出由其中三个不重复数字的全排列
思路：n位数，n%10可以得到最后一位，n/10可得前n-1个数；递归实现全排列
递归：
    退出条件：low>=high；打印
    循环：交换，递归调用函数，交换
*/
#include <stdio.h>
#include<string.h>
void FullPermutation(int a[],int low,int high){
    int i,temp;
    if(low>=high){
        for(i=0;i<high;i++){
            printf("%d",a[i]);
        }
        printf("\n");
    }else{
        for(i=low;i<high;i++){
            if(i!=low){
                temp=a[i];
                a[i]=a[low];
                a[low]=temp;
            }
            FullPermutation(a,low+1,high);
            if(i!=low){
                temp=a[i];
                a[i]=a[low];
                a[low]=temp;
            }
        }
    }
}
void main(int argc,char *argv[])
{
    int num,i;
    int a[4];
    scanf("%d",&num);
    a[3]=num%10;
    num=num/10;
    a[2]=num%10;
    num=num/10;
    a[1]=num%10;
    a[0]=num/10;
    FullPermutation(a, 0, 3);
}

 

main()
{
    int x,i=0,j,k,t;
    int a[4];
    scanf("%d",&x);
    while(x){
        a[i]=x%10;
        i++;
        x=x/10;
    }
    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            if(i!=j){
                for(k=0;k<4;k++){
                    if(k!=i&&k!=j){
                        for(t=0;t<4;t++){
                            if(t!=i&&t!=j&&t!=k){
                                printf("%d%d%d\n",a[j],a[k],a[t]);
                            }
                        }
                    }
                }
            }
        }
    }
}

#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include <iostream>
void dfs(int* nums, int numsSize,int *used,int depth,int** rs,int *path,int *returnSize,int **returnColumnSizes){
    int i;
    if(depth==numsSize){
        rs[*returnSize]=(int*)malloc(sizeof(int)*depth);
        for(i=0;i<depth;i++){
            printf("%d ",path[i]);
            rs[*returnSize][i]=path[i];
        }
        printf("\n");
        returnColumnSizes[0][*returnSize]=depth;
        *returnSize++;
        return;
    }
    for(i=0;i<numsSize;i++){
        if(used[i])
            continue;
        path[depth]=nums[i];
        used[i]=1;
        dfs(nums,numsSize,used,depth+1,rs,path,returnSize,returnColumnSizes);
        used[i]=0;
    }
}
int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    if(nums==NULL){
        return NULL;
    }
    int **rs=(int**)malloc(sizeof(int*)*1000),*path=(int*)malloc(sizeof(int*)*1000);
    int *used=(int*)calloc(sizeof(int),numsSize);
    returnColumnSizes[0]=(int*)malloc(sizeof(int)*1000);
    *returnSize=0;
    dfs(nums,numsSize,used,0,rs,path,returnSize,returnColumnSizes);
    return rs;
}

int main()
{
    int nums[]={1,2,3},target=3,*returnSize,**returnColumnSizes,numsSize=3;
    returnSize=(int*)malloc(sizeof(int)*1000);
    returnColumnSizes=(int**)malloc(sizeof(int*)*1000);
    int **rs=permute(nums, numsSize, returnSize, returnColumnSizes);
    return 0;
}

注意：malloc与calloc的区别：

calloc在分配内存空间后，会被初始化为0；而malloc在分配内存空间后，会被随机初始化。

本题中，如果used数组采用malloc，在if判断句中跳过，这个bug，实在没想到自己能犯。。。

 

#include<stdio.h>
#include<math.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#include <time.h>
void FullPermutation(int *num,int n,int row,int *path,int depth,int *used){
    /*
        num-原数组
        n-原数组长度
        row-回溯的层数
        path-记录回溯的节点
        depth-记录回溯的节点的长度
        used-判断回溯节点是否被使用和释放
    */
    int i;
    if(depth==row){
        for(i=0;i<depth;i++){
            printf("%d ",path[i]);
        }
        printf("\n");
    }
    for(i=0;i<n;i++){
        if(used[i]==1)
            continue;
        used[i]=1;
        path[depth]=num[i];
        FullPermutation(num,n,row,path,depth+1,used);
        used[i]=0;
    }
}
main()
{
    int n=0,a,num[100];
    scanf("%d",&a);
    while(a){
        num[n]=a%10;
        a/=10;
        n++;
    }
    int *path=(int*)malloc(sizeof(int)),depth=0;
    int *used=(int*)calloc(sizeof(int),0);
    FullPermutation(num,n,3,path,depth,used);
}