字符串的几种特殊操作

首先让我傻傻分不清的是这个子序列和子串的问题。特地google了一下。

一个字符串   awbcdewgh

子串：  awbc.   awbcd   awbcde   ....很多个子串  但是都是连续在一起 

子序列： abc  .  abcd    abcde  ...  子序列中的字符在字符串中不一定是连在一起的

同样这里全排列和子序列也是很容易搞混的

在最近我遇到了这样的几个问题

1.给定一个字符串，求出其字符串的全部子序列（注意是否包括空字符串）

2.给定一个字符串，求出其所有的子串（字符串常考题型）

3.给定一个字符串，输出其全排列（分为可重复和不可重复两个版本）

首先来看第一个问题

1.求出字符串的全部子序列。首先要明白子序列是啥。看咱们上面的例子。我们可以看出子序列其实就像老鹰抓一群排成一行的小鸡一样。如果题目要求中提出包括空字符串，那么老鹰可以空手而归，如果不包含，那么就很容易懂了。首先我们会想到暴力递归的方法，将这个字符串转化为字符数组Arr[]，对应数组下标0~length-1的下标i，我们可以选择Arr[i]是否在我们要 求得的子序列中。递归结束的条件那么就是i==length-1.附上相关的代码一份

/**
 * Created by ql on 2018/5/3.
 */
public class Print_All_SubString {
    public static void print_all_substring(String str){
        if(str==null){
            return ;
        }
        //转化为字符数组
        char[] ch=str.toCharArray();
        process(ch,0,"");
    }
    public static void process(char[] ch, int i, String result){
        if(i==ch.length){
            System.out.println(result);
        }
        //result中不存在第i个字符
        process(ch,i+1,result);
        //result中存在第i个字符
        process(ch,i+1,result+String.valueOf(ch[i]));
    }
}

也许你会思考这个问题有没有非递归的方法呢。好吧，其实我也这么想过。

经过查阅资料，发现了一个很6的思路，使用数字来表示这个位置可取不可取。比如对于一个字符串 abcd，现在我们要去求它的所有子序列。首先可以确定它的字符串长度为4.4位2进制数表示范围为0~15.即二进制表示为0000~1111.这样我们可以首先将字符串转化为字符数组。然后根据0~15的二进制表示形式来确定字符串中是否存在这个字符，如果下标对应的位置为‘0’，则表示该字符子序列中是不包含这一字符的，相对应的如果下标对应的位置为‘1’，我们可以认为子序列中包含这个字符。当然还需要看清题目要求是否包含空字符串，如果包含，我们表示范围为0~15，否则为1~15.

 public static List<List<Character>> print_all_substring2(String str){
        List<Character> substring=new LinkedList<>();
        List<List<Character>>result=new LinkedList<>();
        int n=str.length();
        int len= (int) Math.pow(2,n);
        int [] masks=new int [len];
        for(int i=0;i<len;i++){
            masks[i]=i;
        }
        for(int i=0;i<len;i++){
            for(int j=0;j<len;j++){
                if((masks[j]&i)!=0){
                    substring.add((char) masks[j]);
                }
            }
            result.addAll(substring);
        }

        return result;
    }

2.字符串的所有子串问题

子串一般都是连续的。比如abc，对应的子串分别为 a,ab,b,bc,c,abc.''。个数为n+(n-1)+...+1+1(最后一个+1是加上空串)

我的思路比较复杂，就是简单的复杂度是O(n^2)的情况。

先附上大神的递归方法的结题思路：

可能时间复杂度比较高吧。它的代码如下：

 public static String subsequences(String word) {
      if (word.isEmpty()) {
          return ""; // base case
      } else {
         char firstLetter = word.charAt(0);
         String restOfWord = word.substring(1);

         String subsequencesOfRest = subsequences(restOfWord);

         String result = "";
         for (String subsequence : subsequencesOfRest.split(",", -1)) {
             result += "," + subsequence;
             result += "," + firstLetter + subsequence;
         }
         result = result.substring(1); // remove extra leading comma
         return result;
     }
 }

我的思路主要是利用String的subString（i,j）的方法。

/**
 * Created by ql on 2018/5/3.
 */
public class SubSequence {
    public static List<String> sub_sequence(String str){
        List<String> result=new ArrayList<>();
        String resultstr="";
        if(str==null||str.length()==0)return result;
        for (int i=0;i<str.length();i++){
            for (int j=i;j<str.length();j++){
                resultstr=str.substring(i,j);
                result.add(resultstr);
            }
        }
        return result;
    }
   
}

第三个问题：输出字符的全排列。

 输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

这种题分为两种题型，第一种是允许出现重复，比如给定字符串是abcc。这时候输出全排列的过程中将后面两个c视为不同的c。

第二种就是不允许出现重复的排列。

首先看第一种。整体思路就是对应字符串中，0~len-1上的元素进行全排列。每一步的策略就是确定好前i-1个位置的元素，第i个位置的元素分别与后面的len-i个元素交换位置。一直到i到字符数组的末尾时结束。

/**
 * Created by ql on 2018/5/3.
 */
public class Solution {
    public static void Solution(String str){
        if (str==null)return ;
        char[] ch=str.toCharArray();
        process(0,ch);
    }
    public static void process(int index,char[] ch){
        if(index==ch.length){System.out.println(String.valueOf(ch));

 for (int j=index;j<ch.length;j++){

            swap(ch,index,j);
            process(index+1,ch);
            swap(ch,index,j);
        }
    }
    public static void swap(char[] ch,int i,int j){
        char temp=ch[j];
        ch[j]=ch[i];
        ch[i]=temp;
    }
}

若是不允许出现重复的情况，增加一个HashSet即可。用来排除重复的情况即可。

import java.util.HashSet;

/**
 * Created by ql on 2018/5/3.
 */
public class Solution {
    public static void Solution(String str){
        if (str==null)return ;
        char[] ch=str.toCharArray();
        process2(ch,0);
    }
    public static void process2(char[] chs, int i) {
        if (i == chs.length) {
            System.out.println(String.valueOf(chs));
        }
        HashSet<Character> set = new HashSet<>();
        for (int j = i; j < chs.length; j++) {
            if (!set.contains(chs[j])) {
                set.add(chs[j]);
                swap(chs, i, j);
                process2(chs, i + 1);
                swap(chs, i, j);
            }
        }
    }
    public static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }
}