剑指offer刷题

JZ5 对称的二叉树

题目：请实现一个函数，用来判断一棵二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
思路： 理解镜像的概念，进行就是一棵二叉树左右节点反转过后形成的二叉树和原来的二叉树是一样的。
代码：

package com.cc.jianzhi;
//对称的二叉树
public class BinaryTreeSymmetric {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(0);
        TreeNode left = new TreeNode(1);
        TreeNode right = new TreeNode(2);
        root.left = left;
        root.right = right;
        left.left = new TreeNode(4);
        left.right = new TreeNode(5);
        System.out.println(isSymmetrical(root));
    }


    public static boolean isSymmetrical(TreeNode pRoot){
        if(pRoot==null)
            return true; //根结点为null时，认为是对称二叉树
        return isEqual(pRoot.left,pRoot.right);
    }

    private static boolean isEqual(TreeNode pRoot1,TreeNode pRoot2){
        if(pRoot1==null && pRoot2==null)
            return true;
        if(pRoot1==null || pRoot2==null)
            return false;
        return pRoot1.val==pRoot2.val
                && isEqual(pRoot1.left, pRoot2.right)
                && isEqual(pRoot1.right, pRoot2.left);
    }
}

---

JZ5 用两个栈实现队列

题目：用两个栈stack1和stack2来实现一个队列Quene，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：这道题的意图是操作两个“先进后出”的栈实现一个“先进先出”的队列。首先插入一个元素a,不访先把它插入到stack1，此时stack1中的元素有{a}，stack2为空，再压入两个元素b和c，还是插入到stack1中，此时stack1中的元素有{a,b,c}，其中c位于栈顶，而stack2仍然为空，若这时试着从队列中删除一个元素，按着队列先入先出的的规则，由于a比b、c先插入到队列中，最先被删除的元素应是a，但元素a存储在stack1中，并不在栈顶上，不能直接删除，注意stack2还一直没使用过，我们把stack1中的元素逐个弹出并压入stack2,元素在stack2的顺序刚好和在stack1中顺序相反，因此经过3次弹出stack1和压入stack2操作后，stack1为空，而stack2的元素为{c,b,a}，这时候就可以弹出stack2的栈顶a了，此时stack1为空，而stack2的元素为{c,b},其中b在栈顶。
代码：

package com.cc.jianzhi;

import java.util.Stack;
/*
用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。
 */
public class StackImpQuene {

    public static void main(String[] args) {
        int n1=1;
        int n2=2;
        int n3=3;
        int n4=4;
        StackImpQuene sq=new StackImpQuene();
        sq.push(n1);
        sq.push(n2);
        sq.push(n3);
        sq.push(n4);
        System.out.println(sq.pop());
    }
        Stack<Integer> stack1 = new Stack<Integer>();
        Stack<Integer> stack2 = new Stack<Integer>();
        int n=1;
        public void push(int node) {
            stack2.push(node);
        }

        public int pop() {
            if(stack1.isEmpty()){
                while(!stack2.isEmpty()){
                    stack1.push(stack2.pop());
                }
            }
            return stack1.pop();
        }
    }
    #1

---

JZ6旋转数组的最小数字

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
**思路：**这道题最直观的解法是从头到尾遍历数组一次，就能找出最小的元素，这种思路的时间复杂度为O(n)，该思路没有利用旋转数组的特性，达不到面试官的要求。注意旋转之后的数组实际可划分为两个排序的子数组，而且前面的子数组元素都大于或者等于后面子数组的元素，还可以发现最小的元素刚好是这两个子数组的分界线，在排序的数组中我们还可以用二分查找法实现O(logn)的查找。
代码：

package com.cc.jianzhi;

public class RotateArrayMin {
    public static void main(String[] args) {
        int[] a={3,4,5,1,2};
        RotateArrayMin ra=new RotateArrayMin();
        System.out.println(ra.minNumberInRotateArray(a));
    }

        public int minNumberInRotateArray(int [] array) {
            if(array.length == 0) return 0;
            int hi = array.length-1, lo = 0;
            while(lo <= hi){
                int mid = lo + (hi - lo) / 2;
                if(array[mid] > array[hi]){
                    if(array[mid] > array[mid+1])
                        return array[mid+1];
                    lo = mid + 1;
                }
                //else if(array[mid] == array[lo])
                else if(array[mid] < array[lo]){
                    if(array[mid] < array[mid-1])
                        return array[mid];
                    hi = mid - 1;
                }
            }
            return 0;
        }

}
#1