字符排序

版权声明:版权所有 Mr.Jiang https://blog.csdn.net/jmj18756235518/article/details/79965835

问题描述:
算法是这样的,如果给定N个不同字符,将这N个字符全排列,最终的结果将会是N!种。如:给定 A、B、C三个不同的字符,则结果为:ABC、ACB、BAC、BCA、CAB、CBA一共3!=3*2=6种情况。

核心代码:
方法一:

import java.util.Scanner;
import java.util.Vector;

public class Main {
    public static long count=0;
    private void fullPermutation(Vector<Character>sourse, Vector<Character> result) 
    {
        if(sourse.size()==0){
            for (int i = 0; i < result.size(); i++) {
                System.out.print(result.elementAt(i));
            }
            System.out.print("\n");
            count++;
            return;
        }
                for (int i = 0; i < sourse.size(); i++) {
            Vector<Character>tsourse=new Vector<Character>(sourse);
            Vector<Character>tresult=new Vector<Character>(result);
            tresult.add(sourse.elementAt(i));
            tsourse.remove(i);
            new Question1().fullPermutation(tsourse, tresult);
        }
    }

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        Vector<Character> sourse=new Vector<Character>();
        Vector<Character> result=new Vector<Character>();
        for (int i = 0; i < n; i++) {
            sourse.add((char)('A'+i));
        }

        new Question1().fullPermutation(sourse, result);
        System.out.println(Question1.count);
    }


    方法二:
import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.LinkedHashSet;  
import java.util.List;  
import java.util.Scanner;  
import java.util.Set;  

public class Demo03 {  
    // 去掉重复元素,放入lis   
    public static void removeDuplicate(String s,Set<Character> lis){  
        for(char x:s.toCharArray()){  
            lis.add(x);  
        }  
    }  
    // 为方便操作 将 sets 转 lis    
    public static void convert(List<Character> lis,Set<Character> sets){  
        Iterator<Character> iter = sets.iterator();  
        while(iter.hasNext()){  
            lis.add(iter.next());  
        }  
    }  
    // 检测符合条件的元素组合   
    public static void check(Set<Character> sets){  
        List<Character> lis = new ArrayList<Character>();  
        convert(lis,sets);  // 为方便操作 将 sets 转 lis    
        StringBuffer sb = new StringBuffer();  
        for(int i=0;i<lis.size()-2;i++){  
            for(int j=i+1;j+1<lis.size();j++){   // 向后添加两位,所以 j+1<lis.size()   
                for(int k=j+1;k<lis.size();k++){  
                    sb.append(lis.get(i));  
                    sb.append(lis.get(j));  
                    sb.append(lis.get(k));  
                    System.out.println(sb); // 输出组合   
                    sb.setLength(0);    // 清空   
                }  
            }  
        }  

    }  
    public static void main(String[] args){  
        Scanner scan = new Scanner(System.in);  
        System.out.println("输入串(不大于30个字符)。");  
        String s = scan.nextLine();  
        Set<Character> sets = new LinkedHashSet<Character>();  
        removeDuplicate(s,sets);    // 去掉重复元素,放入lis   
        check(sets);    // 检测符合条件的元素组合   
    }  
}  

小结:哎,写完之后,看了上面的代码我头都晕,把一个简单的问题太过于复杂化了,在小编的专栏主页里面有个“Java实现深度优先算法”这个专栏里面如果大家没看可以进去看看,看完大家就知道如何来更快捷更简单的来解决这个问题了。所以用深度优先算法来解决就更加的简单方便了。

那么我们就引出了第三种方法:
public class  Main {

public static int n=3;       
public static char a[]=new char[5];   
public static int book[]=new int[95];    //大写字母的ASCII码值在65-91
public static void main(String[] args) 
{
    dfs(1);    
}

private static void dfs(int temp) 
{   
    if(temp==n+1)
    {
        System.out.printf("%c%c%c  \n",a[1],a[2],a[3]);
        return;
    }
    for(int i='A';i<='C';i++)
    {
        if(book[i]==0)
        {
            a[temp]=(char)i;
            book[i]=1;
            dfs(temp+1);
            book[i]=0;
        }
    }
    return;
}

}

运行结果:
ABC
ACB
BAC
BCA
CAB
CBA

阅读更多

没有更多推荐了,返回首页