算法-全排列：递归输出/字典序输出/冒泡排序

递归不查重的全排列输出

https://blog.csdn.net/sinat_36215255/article/details/78197129

输入一个数字 输出从1至该数字的所有全排列的结果

剑指offer38同款

    #include <cstdio>  
    #include<cstring>  
    #include<algorithm>  
    #include<iostream>  
    #include<string>  
      
    using namespace std;  
    int   arr[100];  
    void perm(int m,int n)  
    {  
        if(m==0)  
        {  
            for(int i=0;i<n;i++)  
            {  
                printf("%d",arr[i]);  
            }  
            printf("\n");  
            return;  
        }  
        else  
        {  
            for(int i=0;i<n;i++)  
            {  
                if(arr[i]==0)  
                {  
                    arr[i]=m;  
                    perm(m-1,n);  
                    arr[i]=0;  
                }  
            }  
        }  
    }  
    int main()  
    {  
        int n;  
        cin>>n;  
        perm(n,n);  
        return 0;  
    }  

字典序的全排列输出

https://blog.csdn.net/simatongming/article/details/50323019

输出一个字符串 通过ascii码比较其大小 初始排序方式为冒泡排序

先将原数组排序，当前序列即就是最小序列，然后找下一个较大的，下一个也就是要求前面的尽可能长（相同），再加上一个大的序列，比如：1，2，3，4，5；1，2，3，4，5就是这五个数的最小字典序，下一个就是1，2，3，5，4；就是让前面的尽可能的相同（1，2，3），改变后面的，让它变大（4，5；变为5，4），大概思路是从后往前找一个最短的升序序列，然后交换序列的首尾，将序列的首的下一个到最后逆序，这就能得到一个较大的；为什么是这么弄，因为从后往前找到的那个升序，也就说明这个序列的中间元素不是升序，是降序或者相等，那么那个降序的逆序以后就是降序（字典序较小的），而那个首尾元素的交换就找到了整个序列的下一个较大的

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

void swap(char *p, char *q)
{
    char m;
    m = *p;
    *p = *q;
    *q = m;
}

void sort(char s[], int n)
{
    int i,j,flag=1;
    char ch;
    for(i=0; i<n-1 && flag ==1; i++)
    {
        flag=0;
        for(j=0; j<n-i-1; j++)
        {
            if(s[j] > s[j+1])
            {
                ch = s[j];
                s[j] = s[j+1];
                s[j+1] = ch;
                flag = 1;
            }
        }
    }

}

int main()
{
    char s[10];
    int len, i, j;
    scanf("%s",s);
    getchar();
    len = strlen(s);
    sort(s,len);
    while(1)
    {
        printf("%s\n",s);
        for(i=len-2;i>=0 && s[i]>=s[i+1]; i--)
        {
        }           //目前最后几个可能不是升序的，从后向前找到相邻之间第一个（从左到右的升序）的部分的头的位置i
        if(i<0)
            break; //biggest and last one
        for(j=len-1;i<j && s[j]<=s[i];j--) //在区间i,len-1上找一个j
        {
        }           //从后向前找到第一个比i位置上值大的位置j

        swap(&s[i], &s[j]);//大很多
        i++;
        j=len-1;
        while(i<j)  //处理尾部 使之升序 保证只比之前大一点 
        {
            swap(&s[i++], &s[j--]);
        }
    }
    getchar();
    return 0;

}