剑指offer题目--解决面试题的思路

19 二叉树的镜像

递归实现

public class Solution {
    public void Mirror(TreeNode root) {
        if(root == null || 
           (root.left == null && root.right == null)){
            return;
        }
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        if(root.left != null){
            Mirror(root.left);
        }
        if(root.right != null){
            Mirror(root.right);
        }
    }
}

循环实现

import java.util.Stack;
public class Solution {
    public void Mirror(TreeNode root) {
        if(root == null){
            return;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(node.left != null||node.right != null){
                TreeNode temp = node.left;
                node.left = node.right;
                node.right = temp;
            }
            if(node.left!=null){
                stack.push(node.left);
            }
            if(node.right!=null){
                stack.push(node.right);
            }
        }
    }
}

20 顺时针打印矩阵

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> result = new ArrayList<Integer> ();
        if(matrix.length==0) return result;
        int row = matrix.length,col = matrix[0].length;
        if(col==0) return result;
        
         // 定义四个关键变量，表示左上和右下的打印范围
        int left = 0, top = 0, right = col - 1, bottom = row - 1;
        while(left <= right && top <= bottom){
            // left to right
            for (int i = left; i <= right; ++i)  result.add(matrix[top][i]);
            // top to bottom
            for (int i = top + 1; i <= bottom; ++i)  result.add(matrix[i][right]);
            // right to left
            if (top != bottom)
            for (int i = right - 1; i >= left; --i)  result.add(matrix[bottom][i]);
            // bottom to top
            if (left != right)
            for (int i = bottom - 1; i > top; --i)  result.add(matrix[i][left]);
            left++;top++;right--;bottom--;
        }
        return result;    
    }
}

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        int row = matrix.size();
        int col = matrix[0].size();
        vector<int> res;
         
        // 输入的二维数组非法，返回空的数组
        if (row == 0 || col == 0)  return res;
         
        // 定义四个关键变量，表示左上和右下的打印范围
        int left = 0, top = 0, right = col - 1, bottom = row - 1;
        while (left <= right && top <= bottom)
        {
            // left to right
            for (int i = left; i <= right; ++i)  res.push_back(matrix[top][i]);
            // top to bottom
            for (int i = top + 1; i <= bottom; ++i)  res.push_back(matrix[i][right]);
            // right to left
            if (top != bottom)
            for (int i = right - 1; i >= left; --i)  res.push_back(matrix[bottom][i]);
            // bottom to top
            if (left != right)
            for (int i = bottom - 1; i > top; --i)  res.push_back(matrix[i][left]);
            left++,top++,right--,bottom--;
        }
        return res;
    }
};

21 包含min函数的栈

Stack实现

import java.util.Stack;
public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    public void push(int node) {
        stack1.push(node);
        if(stack2.isEmpty() || node < stack2.peek()){
            stack2.push(node);
        }else{
            stack2.push(stack2.peek());
        }
    }
    
    public void pop() {
        assert(!stack1.isEmpty() && !stack2.isEmpty());
        stack1.pop();
        stack2.pop();
    }
    
    public int top() {
        return stack1.peek();
    }
    
    public int min() {
        return stack2.peek();
    }
}

ArrayList实现

import java.util.ArrayList;
 
public class Solution {
 
    ArrayList<Integer> list = new ArrayList<Integer>();
     
    public void push(int node) {
        list.add(0,node);
    }
     
    public void pop() {
        list.get(0);
        list.remove(0);
    }
     
    public int top() {
        return list.get(0).intValue();
    }
 
    public int min() {
        int temp = top();
        for(int i=1;i<list.size();i++){
            if(temp>list.get(i).intValue()){
                temp = list.get(i).intValue();
            }
        }
        return temp;
    }
}

22 栈的压入、弹出序列

 Stack实现

import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
      boolean bResult = false;
      int nLength = pushA.length;
      if(pushA != null && popA != null &&  nLength>0){
          int nextpush =0;
          int nextpop = 0;
          Stack<Integer> stackData = new Stack<Integer>();
          while(nextpop < nLength){
              while(stackData.empty() || stackData.peek() != popA[nextpop]){
                  if(nextpush == nLength){
                      break;
                  }
                  stackData.push(pushA[nextpush]);
                  nextpush++;
              }
              if(stackData.peek() != popA[nextpop]){
                  break;
              }
              stackData.pop();
              nextpop++;
          }
          if(stackData.empty() && nextpop == nLength){
              bResult = true;
          }
      }
        return bResult;
    }
}

23 从上往下打印二叉树

按层打印，实际就是广度优先搜索 BFS, 借助一个队列就可以实现.

广度优先搜索 BFS：主要借助一个队列、一个布尔类型数组、邻接矩阵完成（判断一个点是否查看过，用于避免重复到达同一个点，造成死循环等），先将各点以及各点的关系存入邻接矩阵。

再从第一个点开始，将一个点存入队列，然后在邻接表中找到他的相邻点，存入队列，每次pop出队列头部并将其打印出来（文字有些抽象，实际过程很简单），整个过程有点像往水中投入石子水花散开。

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        ArrayList<TreeNode> queue = new ArrayList<>();
        if (root == null) {
            return list;
        }
        queue.add(root);
        while (queue.size() != 0) {
            TreeNode temp = queue.remove(0);
            if (temp.left != null){
                queue.add(temp.left);
            }
            if (temp.right != null) {
                queue.add(temp.right);
            }
            list.add(temp.val);
        }
        return list;
    }
}

扩展：

广度优先遍历一个有向图，同样可以基于队列实现。树是图的一种特殊退化形式，从上到下按层遍历二叉树，本质上就是广度优先遍历二叉树。

24 二叉搜索树的后序遍历序列

后序遍历：先遍历子结点，再遍历父结点。在后序遍历得到的序列中，最后一个数字是树的根结点。

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence == null || sequence.length <= 0){
            return false;
        }
        int root = sequence[sequence.length-1];
        
        int[] sequenceleft = new int[sequence.length];
        int[] sequenceright = new int[sequence.length];
        
        //在二叉搜索树中左子树的结点小于结点
        int i=0;
        for(;i<sequence.length -1;++i){
            if(sequence[i] > root){
                break;
            }
            sequenceleft[i] = sequence[i];
        }
        
        //早二叉搜索树中右子树的结点大于根结点
        int j=i;
        int k=0;
        for(;j < sequence.length -1;++j){
            if(sequence[j] < root){
                return false;
            }
            k++;
            sequenceright[k] = sequence[j];
        }
        
        //判断左子树是不是二叉搜索树
        boolean left = true;
        if(i>0){
            left = VerifySquenceOfBST(sequenceleft);
        }
        
        boolean right = true;
        if(i<sequence.length-1){
            right = VerifySquenceOfBST(sequenceright);
        }
        return (left && right);        
    }
}

 前中后序遍历

前、中、后指的是根节点的顺序。前序遍历有根节点开始。

前序遍历：ABCDEFGHK

中序遍历：BDCAEHGKF

后序遍历：DCBHKGFEA

中序排列思想：

25 二叉树中和为某一值的路径

public class Solution {
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        ArrayList<ArrayList<Integer>> paths=new ArrayList<ArrayList<Integer>>();
        if(root==null)return paths;
        find(paths,new ArrayList<Integer>(),root,target);
        return paths;
    }
    
    public void find(ArrayList<ArrayList<Integer>> paths,ArrayList<Integer> path,TreeNode root,int target){
            path.add(root.val);
            if(root.left==null&&root.right==null){
                if(target==root.val){
                    paths.add(path);
                }
                return;
            }
            ArrayList<Integer> path2=new ArrayList<>();
            path2.addAll(path);
            if(root.left!=null)find(paths,path,root.left,target-root.val);
            if(root.right!=null)find(paths,path2,root.right,target-root.val);
        }
}

import java.util.ArrayList;
import java.util.Stack;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        ArrayList<ArrayList<Integer>> pathList=
                new ArrayList<ArrayList<Integer>>();
        if(root==null)
            return pathList;
        Stack<Integer> stack=new Stack<Integer>();
        FindPath(root,target,stack,pathList );
        return pathList;
    }
    
    private void FindPath(TreeNode root, int target,
            Stack<Integer> path,
            ArrayList<ArrayList<Integer>> pathList) {
        if(root==null)
            return;
        if(root.left==null&&root.right==null){
            if(root.val==target){
                ArrayList<Integer> list=
                        new ArrayList<Integer>();
                for(int i:path){
                    list.add(new Integer(i));
                }
                list.add(new Integer(root.val));
                pathList.add(list);
            }
        }
        else{
            path.push(new Integer(root.val));
            FindPath(root.left, target-root.val, path, pathList);
            FindPath(root.right, target-root.val, path,  pathList);
            path.pop();
        }
    }
}

26 复杂链表的复制

分治法，通常分治法的思路都可以用递归实现

在复杂链表的结点中，除了有指向下一个结点的指针，还有指向任意结点的指针。、

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        CloneNodes(pHead);
        ConnectSiblingNodes(pHead);
        return ReconnectNodes(pHead);
    }
    
    void CloneNodes(RandomListNode pHead){
        RandomListNode pNode = pHead;
        while(pNode != null){
            RandomListNode pCloned = new RandomListNode(pNode.label);
            pCloned.next = pNode.next;
            pCloned.random = null;
            
            pNode.next = pCloned;
            pNode = pCloned.next;
        }
    }
    
    void ConnectSiblingNodes(RandomListNode pHead){
        RandomListNode pNode = pHead;
        while(pNode!= null){
            RandomListNode pCloned = pNode.next;
            if(pNode.random != null){
                pCloned.random = pNode.random.next;
            }
            pNode = pCloned.next;
            
        }
    }
    
    RandomListNode ReconnectNodes(RandomListNode pHead){
        RandomListNode pNode = pHead;
        RandomListNode pClonedHead = null;
        RandomListNode pClonedNode = null;
        
        if(pNode != null){
            pClonedNode = pNode.next;
            pClonedHead = pClonedNode;
            pNode.next = pClonedNode.next;
            pNode = pNode.next;
        }
        
        while(pNode != null){
            pClonedNode.next = pNode.next;
            pClonedNode = pClonedNode.next;
            pNode.next = pClonedNode.next;
            pNode = pNode.next;
        }
        return pClonedHead;
    }
}

27 二叉搜索树与双向链表

二叉搜索树：左子结点的值小于父结点的值，右子节点的值大于父结点的值。

直接递归

public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null) return pRootOfTree;
        pRootOfTree = ConvertNode(pRootOfTree);
        while(pRootOfTree.left!= null) pRootOfTree = pRootOfTree.left;
        return pRootOfTree;
    }
    
    TreeNode ConvertNode(TreeNode root)
    {
        if(root == null) return root;
        if(root.left != null)
        {
            TreeNode left = ConvertNode(root.left);
            while(left.right!= null) left = left.right;
            left.right = root;
            root.left = left;
        }
         
        if(root.right != null)
        {
            TreeNode right = ConvertNode(root.right);
            while(right.left!= null) right = right.left;
            right.left = root;
            root.right = right;
        }
        return root;
    }
}

此解法暂时未通过

public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {
        TreeNode pLastNodeInList = null;
        ConvertNode(pRootOfTree, pLastNodeInList);
        
        //pLastNodeInList双向链表尾结点
        //需要返回头结点
        TreeNode pHeadOfList = pLastNodeInList;
            while(pHeadOfList != null && pHeadOfList.left != null){
                pHeadOfList = pHeadOfList.left;
            }
        return pHeadOfList;
    }
    
    void ConvertNode(TreeNode pNode, TreeNode pLastNodeInList){
        if(pNode == null){
            return;
        }
        TreeNode pCurrent = pNode;
        if(pCurrent.left != null){
           ConvertNode(pCurrent.left, pLastNodeInList);
        }
        
        pCurrent.left = pLastNodeInList;
        if(pLastNodeInList != null){
            pLastNodeInList.right = pCurrent;
        }
        
        pLastNodeInList = pCurrent;
        
        if(pCurrent.right != null){
            ConvertNode(pCurrent.right,pLastNodeInList);
        }
    }
}

28 字符串的排列

 解法一：递归

import java.util.ArrayList;
import java.util.Collections;
import java.util.Set;
import java.util.HashSet;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> list = new ArrayList<String>();
        if(str!=null && str.length()>0){
            PermutationHelper(str.toCharArray(),0,list);
            Collections.sort(list);
        }
        return list;
    }

    private void PermutationHelper(char[] chars,int i,ArrayList<String> list){
        if(i == chars.length-1){
            list.add(String.valueOf(chars));
        }else{
            Set<Character> charSet = new HashSet<Character>();
            for(int j=i;j<chars.length;++j){
                if(j==i || !charSet.contains(chars[j])){
                    charSet.add(chars[j]);
                    swap(chars,i,j);
                    PermutationHelper(chars,i+1,list);
                    swap(chars,j,i);
                }
            }
        }
    }
 
    private void swap(char[] cs,int i,int j){
        char temp = cs[i];
        cs[i] = cs[j];
        cs[j] = temp;
    }
}

解法二：字典序排列算法

import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> list = new ArrayList<String>();
        if(str==null || str.length()==0){
            return list;
        }
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        list.add(String.valueOf(chars));
        int len = chars.length;
        while(true){
            int lIndex = len-1;
            int rIndex;
            while(lIndex>=1 && chars[lIndex-1]>=chars[lIndex]){
                lIndex--;
            }
            if(lIndex == 0)
                break;
            rIndex = lIndex;
            while(rIndex<len && chars[rIndex]>chars[lIndex-1]){
                rIndex++;
            }
            swap(chars,lIndex-1,rIndex-1);
            reverse(chars,lIndex);
 
            list.add(String.valueOf(chars));
        }
 
        return list;
    }
    
    private void reverse(char[] chars,int k){
        if(chars==null || chars.length<=k)
            return;
        int len = chars.length;
        for(int i=0;i<(len-k)/2;i++){
            int m = k+i;
            int n = len-1-i;
            if(m<=n){
                swap(chars,m,n);
            }
        }
 
    }
 
    private void swap(char[] cs,int i,int j){
        char temp = cs[i];
        cs[i] = cs[j];
        cs[j] = temp;
    }
}

参考：

https://www.cnblogs.com/cxjchen/p/3932949.html

https://www.cnblogs.com/pmars/archive/2013/12/04/3458289.html