字符操作编程题（不断更新）

一、给定一个字符串，找出最长的没有重复成员的字串，并返回长度

第一个方法就是最老实的版本，逐步遍历所有子串，判断子串中有没有重复元素，记录全部遍历过程的最长子串长度。时间复杂度

为O(n^3)。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        int ans = 0;
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j <= n; j++)
                if (allUnique(s, i, j)) ans = Math.max(ans, j - i);
        return ans;
    }

    public boolean allUnique(String s, int start, int end) {
        Set<Character> set = new HashSet<>();
        for (int i = start; i < end; i++) {
            Character ch = s.charAt(i);
            if (set.contains(ch)) return false;
            set.add(ch);
        }
        return true;
    }
}

第二个方法稍微高级点，因为上述方法有很多无用的遍历，浪费时间。所以改进的方法用到了Sliding Windows的方法：

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();
        int ans = 0, i = 0, j = 0;
        while (i < n && j < n) {
            // try to extend the range [i, j]
            if (!set.contains(s.charAt(j))){
                set.add(s.charAt(j++));
                ans = Math.max(ans, j - i);
            }
            else {
                set.remove(s.charAt(i++));
            }
        }
        return ans;
    }
}

即发现了重复元素之 后 ，将下次开始遍历的起点重置，从发现重复元素的位置开始。

二、找到字符串中的最长回文子串

public class Solution {
    public String longestPalindrome(String s) {
        int start = 0;
        int end = 0;
        int length = s.length();
        for(int i = 0; i < length; i++){
            int len1 = getLength(s,i,i);
            int len2 = getLength(s,i,i+1);
            int len = len1>len2?len1:len2;
            if(len > end - start + 1){
                start = i - (len - 1)/2;
                end = i + len/2;
            }
        }
        return s.substring(start,end+1);

    }
    
    private int getLength(String s, int st1, int st2){
        while(st1>=0 && st2<s.length() && s.charAt(st1)==s.charAt(st2)){
            st1--;
            st2++;
        }
        return st2-st1-1;
    }
}

思路很简单，就是找到center中心点，逐步expand，判断是否满足回文性质。

三、找到最长不重复子串

我的本方法：。。。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int len = s.length();
        int max = 0;
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < len; i++){
            if(findReplica(sb.toString(),String.valueOf(s.charAt(i)))==-1){
                sb.append(String.valueOf(s.charAt(i)));
                max = (max < sb.toString().length())? (sb.toString().length()):max;
                continue;                
            }
            sb = new StringBuffer(sb.substring(findReplica(sb.toString(),String.valueOf(s.charAt(i)))+1));
            sb.append(String.valueOf(s.charAt(i)));
        }
        return max;
    }
    
    private int findReplica(String tmp, String s){
        return tmp.indexOf(s);
    }
}

短一点的方法：

public int lengthOfLongestSubstring(String s) {
        if (s.length()==0) return 0;
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        int max=0;
        for (int i=0, j=0; i<s.length(); ++i){
            if (map.containsKey(s.charAt(i))){
                j = Math.max(j,map.get(s.charAt(i))+1);
            }
            map.put(s.charAt(i),i);
            max = Math.max(max,i-j+1);
        }
        return max;
    }

用一个map来存储遍历到的字符和位置，一个指针用来遍历，另一个指针用来记录遇到重复字符时候应该的起始位置。这里在修改j时进行了一个max的比较，这是因为有一种情况时新的起始位置已经超过了当下遇到的重复字符的存储位置，此时既需要更新map也需要检查一下新起始位置指针是否正确。

四、全排列问题

全排列即找到给定数组的所有排列结果，其中又分为包含重复元素和不包含重复元素的问题。基本思想就是递归。

下面直接列出找到去重全排列的代码：

	public void getAllPermutation(List<List<String>> result, String[] words, int start) {
		if (start == words.length) {
			List<String> per = new ArrayList<>();
			for (int j = 0; j < words.length; j++) {
				per.add(words[j]);
			}
			if (result.indexOf(per) < 0) {
				result.add(per);
			}
			return;
		}

		for (int i = start; i < words.length; i++) {
			swap(words, start, i);
			getAllPermutation(result, words, start + 1);
			swap(words, start, i);
		}
	}

	public void swap(String[] words, int st, int en) {
		String temp = new String();
		temp = words[st];
		words[st] = words[en];
		words[en] = temp;
	}

五、找到给定整型数组的逻辑上下一个比他大的整型数组排列，如果他是最大的排列则将他置为最小的排列

eg：{1,2,3}→{1,3,2}，{1,4,2,5}→{1,4,5,2}，{3,2,1}→{1,2,3}

首先来分析一下。要找到下一个比他大的排列方式，则要从数组尾端开始，找到第一个不满足降序排列的位置点，做一下标记；然后再从数组尾端找起，找到第一个比前面标记位点值大的，则由于之前的降序条件，这个值是最小的比标记位点值大的位点，二者交换，再将标记位点之后到数组结束的所有元素翻转，即为满足题目条件的排列方式。

public void nextPermutation(int[] A) {
    if(A == null || A.length <= 1) return;
    int i = A.length - 2;
    while(i >= 0 && A[i] >= A[i + 1]) i--; // Find 1st id i that breaks descending order
    if(i >= 0) {                           // If not entirely descending
        int j = A.length - 1;              // Start from the end
        while(A[j] <= A[i]) j--;           // Find rightmost first larger id j
        swap(A, i, j);                     // Switch i and j
    }
    reverse(A, i + 1, A.length - 1);       // Reverse the descending sequence
}

public void swap(int[] A, int i, int j) {
    int tmp = A[i];
    A[i] = A[j];
    A[j] = tmp;
}

public void reverse(int[] A, int i, int j) {
    while(i < j) swap(A, i++, j--);
}

六、完成数独填空（回溯法）

public class Solution {
    public void solveSudoku(char[][] board) {
        if(board == null || board.length == 0)
            return;
        solve(board);
    }
    
    public boolean solve(char[][] board){
        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board[0].length; j++){
                if(board[i][j] == '.'){
                    for(char c = '1'; c <= '9'; c++){//trial. Try 1 through 9
                        if(isValid(board, i, j, c)){
                            board[i][j] = c; //Put c for this cell
                            
                            if(solve(board))
                                return true; //If it's the solution return true
                            else
                                board[i][j] = '.'; //Otherwise go back
                        }
                    }
                    
                    return false;
                }
            }
        }
        return true;
    }
    
    private boolean isValid(char[][] board, int row, int col, char c){
        for(int i = 0; i < 9; i++) {
            if(board[i][col] != '.' && board[i][col] == c) return false; //check row
            if(board[row][i] != '.' && board[row][i] == c) return false; //check column
            if(board[3 * (row / 3) + i / 3][ 3 * (col / 3) + i % 3] != '.' && 
board[3 * (row / 3) + i / 3][3 * (col / 3) + i % 3] == c) return false; //check 3*3 block
        }
        return true;
    }
}