A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 刘晶 中级黑马   /  2014-4-10 18:46  /  7250 人查看  /  17 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

这个程序没有看明白,哪位大神给我加上注释呀,主要是 recursionSub不知道怎么运行的,有单步调试看着也很乱,帮帮忙
package com.itheima;
/**
* 第七题 编程列出一个字符串的全字符组合情况,原始字符串中没有重复字符
例如:
原始字符串是"abc",打印得到下列所有组合情况
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"
*/
import java.util.*;
public class Test11 {
         static int n,count = 0;
         static char[] array = { 'a', 'b', 'c' };
         static LinkedList <char[]> list = new LinkedList<char[]> ();//转化为集合
         static int[] indexs = new int[3];  
         static int len = array.length;

         public static void main(String[] args){
                                 getSub ();
                                
                 for ( char[] cs : list )     //遍历list
                 {       
                         //n++;
                        // if(n%3!=0)
                         
                    System.out.println(cs);
                        // else System.out.println(cs);
               }
             }

             private static LinkedList<char[]> getSub ()      //获取
             {
                 while (count <= len){
                     recursionSub (-1);
                     count++;
                 }
                 return list;
             }
             
             private static LinkedList <char[]> recursionSub ( int start )
             {
                             start++;
                            
                             if (start > count - 1)
                                     {
                                     return null;
                                     }
                             for ( indexs[start] = 0; indexs[start] < len; indexs[start]++ )
                                     {
                                             recursionSub (start);
                                             if (start == count - 1)
                                                     {
                                                             char[] temp = new char[count];
                                                             for ( int i = count - 1; i >= 0; i-- )
                                                                     {
                                                                             temp[start - i] = array[indexs[start - i]];
                                                                     }
                                                             boolean flag = true;
                                                             for ( int i = 0; i < temp.length; i++ )
                                                                     {
                                                                             for ( int j = i+1; j < temp.length; j++ )
                                                                                     {
                                                                                             if (temp[i] == temp[j])
                                                                                                     {
                                                                                                             flag = false;
                                                                                                             break;
                                                                                                     }
                                                                                     }
                                                                     }
                                                             if (flag)
                                                             {
                                                                     list.add (temp);
                                                             }
                                                     }       
                                     }
                             return list;
         }

}

评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1

查看全部评分

17 个回复

倒序浏览
亲,我也没看懂~~~同求啊……
回复 使用道具 举报
这个函数好像是吧所有情况都列出来。
回复 使用道具 举报
好麻烦啊
回复 使用道具 举报
又学习了
回复 使用道具 举报
表示木有看懂哦
回复 使用道具 举报
幸好字符的长度是3,要是多点 我估计你的电脑内存都装不下你的代码
回复 使用道具 举报
  1. class AbcTest
  2. {
  3.         public static void main(String[] args){
  4.                 math1();
  5.         }
  6.         public static void math1(){
  7.                 String str = "abc";
  8.                 char[] ch = str.toCharArray();//变成字符形式,
  9.                
  10.                 for (int i = 0; i<str.length(); i++)
  11.                 {
  12.                         String str1 = "";//所有可能字符的变量
  13.                         str1 = str1 + ch[i];//取第一个字符
  14.                         System.out.print(str1+" ");
  15.                         for (int j = 0; j<str.length(); j++)
  16.                         {
  17.                                 //当第三层循环返回来的时候,字符串的长度是两个,需要给其重新赋值,保持第一个字符不变,其他两个在取值
  18.                                 if (str1.length() == 2)
  19.                                         str1 = "" + ch[i];

  20.                                 if (!math(str1,ch[j]))
  21.                                 {
  22.                                         continue;
  23.                                 }else{
  24.                                         str1 = str1 + ch[j];
  25.                                         System.out.print(str1+" ");
  26.                                 }
  27.                                 for (int k = 0; k<str.length(); k++)
  28.                                 {
  29.                                         if (!math(str1,ch[k]))
  30.                                         {
  31.                                                 continue;
  32.                                         }else{
  33.                                                 str1 = str1 + ch[k];
  34.                                                 System.out.print(str1 + " ");
  35.                                                 //保持前两个数不变,变换第三个字符
  36.                                                 str1 = "" + ch[i] + ch[j];
  37.                                         }
  38.                                 }
  39.                         }
  40.                 }
  41.         }
  42. //判断这个字符串里面是否存在这个字符,存在返回false,不存在返回true
  43.         public static boolean math(String str,char ch){
  44.                 char[] ca = str.toCharArray();
  45.                 boolean b = true;
  46.                 for (int i = 0; i<ca.length; i++)
  47.                 {
  48.                         if (ca[i]==ch)
  49.                                 b = false;
  50.                 }
  51.                 return b;
  52.         }
  53. }
复制代码
回复 使用道具 举报 2 0
怎么会有这么复杂
回复 使用道具 举报
黄宽 中级黑马 2014-10-18 13:13:21
10#
我也碰到这题啊,赶脚有难度啊:L
回复 使用道具 举报
package com.itheima;

import java.awt.List;
import java.util.ArrayList;

/**
* 第七题 编程列出一个字符串的全字符组合情况,原始字符串中没有重复字符
例如:
原始字符串是"abc",打印得到下列所有组合情况
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"

思路:1 每行字符个数都是递增 2 下一行的字符是建立在上一行的基础上得到的
即在将第一行字符串长度限定为1,第二行为2....,在第一行数据基础上{a,b,c},创建第二行数据,遍历字符串中所字符,并与第一行数据组合。注意每行字符串长度限制
*/

public class Test12 {
        public static void main(String[] args){
                print("abcd");
        }
       
        //接收一个字符串返回全字符组合情况
        public static void print(String str){
                //将字符串转化为字符数组
                char[] ch = str.toCharArray();
                //建立一个存有{"a","b","c"}的集合list1
                ArrayList<String> list1 = new ArrayList<String>();
                for(int i = 0; i < ch.length; i++){
                        list1.add(ch[i]+"");
                }
               
                for(int i = 0; i < ch.length; i++){
                       
                        //取得每一行要输出的list集合
                        list1 = getList(list1, i+1,ch);
                       
                        //遍历输出集合
                        for(String s:list1){
                                System.out.print("\"" + s + "\" ");
                        }
                        System.out.println("");
                }
        }
       
        //取得每一行要输出的list集合
        public static ArrayList<String> getList(ArrayList<String> list,int len,char[] ch){
                //newList 用来装下一行要遍历的元素,list则代表上一行的元素集合
                ArrayList<String> newList  = new ArrayList<String>();
       
                //该循环用来取得上一行的元素
                for(String s:list){
                        String str = s;       
                               
                                for(int j = str.length();j < len ;j++){
                                        //遍历字符串中没个元素
                                        for(int i = 0; i < ch.length; i++){
                                                //字符不重复则将Str+ch[i]添加进集合,
                                                if(str.indexOf(ch[i]) == -1){
                                                        newList.add(str + ch[i]);
                                                }
                                        }
                                }
                               
                }
               
                return newList.size() == 0 ? list:newList;
        }

}
回复 使用道具 举报
看着头疼,好难的样子~
回复 使用道具 举报
:(好复杂
回复 使用道具 举报
看题看的是思想
回复 使用道具 举报
壹贰叁 发表于 2014-11-21 23:25
package com.itheima;

import java.awt.List;

"a" "b" "c"
"ab" "ac" "ba" "bc" "ca" "cb"
"abc" "acb" "bac" "bca" "cab" "cba"
运行结果不对啊
回复 使用道具 举报
这个字符串的长度也不一定就是3啊,是任意长度的吧?
回复 使用道具 举报
看不太懂
回复 使用道具 举报

你这只能取三个字符的
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马