groovy if 判断字符串_剑指Offer-面试题38-字符串的排列

字符串的排序

题目：输入一个字符串，打印出该字符串中字符的所有排列。
例如，输入字符串abc，则打印出由字符a、b、c所能排列出来的所有字符串abc、acb、bac、bca、cab和cba。

如何求出几个字符的所有排列，很多人都不能一下子想出解决方案。那我们是不是可以考虑把这个复杂的问题分解成小问题呢？比如，我们把一个字符串看成由两部分组成：第一部分是它的第一个字符；第二部分是后面的所有字符。如下图中，我们用两种不同的背景颜色区分字符串的两个部分。

我们求整个字符串的排列，可以看成两步。 第一步求所有可能出现在第一个位置的字符，即把第一个字符和后面所有的字符交换。 第二步固定第一个字符，求后面所有字符的排列。这时候我们仍然把后面的所有字符分成两部分：后面字符的第一个字符，以及这个字符之后的所有字符。然后把第一个字符逐一和它后面的字符交换

下面看代码

import java.util.Arrays;

public class Solution {

    public void Permutation(String pStr){
        if (pStr == null || pStr.equals("")){
            // 如果字符串为空，则没有排列
            return ;
        }
        char[] pChar = pStr.toCharArray(); // 将字符串转成字符数组
        Permutation(pChar,0);
    }

    /**
     *
     * @param pChar 传入的字符数组->注意数组的传递是引用传递
     * @param start 交换的起始位置,start之前的字符都是固定的值，start是等待与后面交换的值
     */
    private void Permutation(char[] pChar,int start){
        // 递归截止条件 -> 当start 等于字符数组的长度时，递归结束
        if (start == pChar.length-1){
            System.out.println(Arrays.toString(pChar));
        } else {
            // 令pChar依次与后面的值交换
            // 注意几点细节：
            // 1. start与自己交换的情况，这种情况是为了包括打印数组自身的排列。
            // 2. 交换完后需要在换回来。因为可能有以下这种情况
            // 当a**-> b**后，递归回来的时候，还有一种情况是a**->c**.如果不换回来就会变成a**->b**->a**
            // 交换回来的目的就是为了确保本次循环中pChar是不变的。
            // 所以，如果我们是使用了拷贝一个数组的方式，应该也是对的。
            for (int i = start; i < pChar.length; i++) {
//                char[] tempPchar = Arrays.copyOf(pChar,pChar.length);
//                char temp = tempPchar[start];
//                tempPchar[start] = tempPchar[i];
//                tempPchar[i] = temp;
//
//                Permutation(tempPchar,start+1);
                char temp = pChar[start];
                pChar[start] = pChar[i];
                pChar[i] = temp;

                Permutation(pChar,start+1);

                temp = pChar[start];
                pChar[start] = pChar[i];
                pChar[i] = temp;
            }
        }
    }
    public static void main(String[] args) {
       Solution s = new Solution();
       s.Permutation("abc");

    }
}

类似但又不同

题目：给定两个字符串s1和s2，写一个函数来判断s2是否包含s1的排列。
换句话说，第一个字符串的排列是第二个字符串的子串。

示例1：

输入：s1 = "ab" s2="eidbaooo"
输出：True
解释：s2包含s1的排列之一("ba")

这个题目看似与上题差不多，但是使用的思路却毫不相同，如果要先列出来所有的全排列，再去比较是否是s2的子串，那耗时太多。

可以利用令一种思路，这里说一个字符串的排列是第二个字符串的子串。其实这里说是排列，可以换个想法，排列=两个字符串的长度相同，且字符内容一致，至于是怎么个排列法，不用管。

那么只要让s1在s2上滑动，只要在当前的滑动窗口中，s2中的字符内容与s1中的字符内容一致，我们就可以说s2中存在s1的排列。

看下面代码

class Solution {
     public boolean checkInclusion(String s1,String s2){
        // 判断s2是否包含s1的排列
         if (s1==null||s2==null||s1.equals("")||s2.equals("")||s2.length()<s1.length()){
             return false;
         }
        // 思路：使用s1大小的滑动窗口在s2上滑动，如果s2窗口中字符的内容与s1相同，则认为包含

         int[] s1Count = new int[26];// 用于统计窗口内的内容
         int[] s2Count = new int[26];

         int winLength = s1.length(); //窗口的大小
         // 初始化s1Count与s2Count,其中s1Count初始化后就不会在变动了
         for(int i =0;i<winLength;i++){
             s1Count[s1.charAt(i)-'a']++;
             s2Count[s2.charAt(i)-'a']++;
         }
         if(compare(s1Count,s2Count)){
             return true;
         }
         // 在s2上滑动窗口,注意start=1，因为在上一步，已经判断过start=0了
         // 注意2：循环终止的条件式s2.length-winLength = 窗口起点可以到达的位置
         for(int start=1;start<=s2.length()-winLength;start++){
             s2Count[s2.charAt(start+winLength-1)-'a']++;
             s2Count[s2.charAt(start-1)-'a']--;
             if (compare(s1Count,s2Count)){
                 return true;
             }
         }
         return false;
     }
    // 比较两个数组中内容是否相同
    private boolean compare(int[] s1Count,int[] s2Count){
        for(int i = 0;i<s1Count.length;i++){
            if (s1Count[i]!=s2Count[i]){
                return false;
            }
        }
        return true;
    }
}