剑指offer（11-20）

10.我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

    思路：依旧是斐波那契数列

代码：

public class Solution {    public int RectCover(int target) {         if(target<=3)            return target;                int n2=2;        int n3=3;        int t=0;        for(int i=4;i<=target;i++){            t=n2+n3;            n2=n3;            n3=t;        }                return t;    }}

11.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

    思路1：将n与n-1想与会把n的最右边的1去掉，比如1100&1011 = 1000，再让count++即可计算出有多少个1

    思路2：直接调用API

代码：

public class Solution {public int  NumberOf1(int n) {       //第一种解法     int count=0;    while(n!=0){                         n=n&(n-1);            count++;        }        return count;//第二种解法，直接调用API  return Integer.toBinaryString(n).replaceAll("0","").length();         }}

12.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

    思路：传统数学思路求解就行，考虑到exponent的小于0，等于0，大于0多种情况

代码：

public class Solution {    public double Power(double base, int exponent) {                double res=1.0;                if(exponent==0)            res=1;                for(int i=0;i<Math.abs(exponent);i++){            res*=base;        }                 if(exponent<0)            res=1/res;                return res;  }}

13.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

    思路： 首先统计奇数的个数，然后新建一个等长数组，设置两个指针，奇数指针从0开始，偶数指针从奇数个数的末尾开始 遍历，填数

代码：

public class Solution {    public void reOrderArray(int [] array) {        if(array.length==0||array.length==1)            return;                int[] newArray=new int[array.length];        int oddBegins=0; int oddCounts=0;        for(int i=0;i<array.length;i++){            if(array[i]%2==1)                oddCounts++;        }                for(int i=0;i<array.length;i++){            if(array[i]%2==1){              newArray[oddBegins++]=array[i];              }else{               newArray[oddCounts++]=array[i];            }        }                for(int i=0;i<array.length;i++){                        array[i]=newArray[i];        }                        }}

14.输入一个链表，输出该链表中倒数第k个结点。

    思路：两个指针，先让第一个指针和第二个指针都指向头结点，然后再让第一个指正走(k-1)步，到达第k个节点。然后两个指针同时往后移动，当第一个结点到达末尾的时候，第二个结点所在位置就是倒数第k个节点了

代码：

public class ListNode {    int val;    ListNode next = null;    ListNode(int val) {        this.val = val;    }}*/public class Solution {    public ListNode FindKthToTail(ListNode head,int k) {        if(head==null||k<=0)            return null;                ListNode nodePre=head;        ListNode nodeLast=head;                for(int i=1;i<k;i++){            if(nodePre.next!=null){                nodePre=nodePre.next;            }else{                return null;            }        }                while(nodePre.next!=null){            nodePre=nodePre.next;            nodeLast=nodeLast.next;        }        return nodeLast;    }}

15.输入一个链表，反转链表后，输出链表的所有元素。

    思路：反序的过程整个链表分成两个部分，前面的代表已反序，后面的代表待反序，反序和待反序 是断开的，所以要注意保存这两条链表的头节点 ListNode next = null;//用来保存待反序的第一个节点（head 和 next节点） ListNode pre = null;//用来保存已经反序的第一个结点

public class Solution {

    public ListNode ReverseList(ListNode head) {

        if(head==null)

            return null;

        //head为当前节点，如果当前节点为空的话，那就什么也不做，直接返回null； 

        ListNode pre = null;

        ListNode next = null;

        //当前节点是head，pre为当前节点的前一节点，next为当前节点的下一节点

        //需要pre和next的目的是让当前节点从pre->head->next1->next2变成pre<-head next1->next2

        //即pre让节点可以反转所指方向，但反转之后如果不用next节点保存next1节点的话，此单链表就此断开了

        //所以需要用到pre和next两个节点

        //1->2->3->4->5

        //1<-2<-3 4->5

        while(head!=null){

            //做循环，如果当前节点不为空的话，始终执行此循环，此循环的目的就是让当前节点从指向next到指向pre

            //如此就可以做到反转链表的效果

            //先用next保存head的下一个节点的信息，保证单链表不会因为失去head节点的原next节点而就此断裂

            next = head.next;

            //保存完next，就可以让head从指向next变成指向pre了，代码如下

            head.next = pre;

            //head指向pre后，就继续依次反转下一个节点

            //让pre，head，next依次向后移动一个节点，继续下一次的指针反转

            pre = head;

            head = next;

        }

        //如果head为null的时候，pre就为最后一个节点了，但是链表已经反转完毕，pre就是反转后链表的第一个节点

        //直接输出pre就是我们想要得到的反转后的链表

        return pre;

    }

}

代码：

/*public class ListNode {    int val;    ListNode next = null;    ListNode(int val) {        this.val = val;    }}*/public class Solution {    public ListNode ReverseList(ListNode head) {if(head==null)        return null;                ListNode pre=null;        ListNode next=null;                while(head!=null){            next=head.next;            head.next=pre;            pre=head;            head=next;        }        return pre;            }}

16.输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

    思路：比较两个链表的首结点，哪个小的的结点则合并到第三个链表首结点，并向  前移动一个结点。

               步骤一结果会有一个链表先遍历结束，或者没有

               第三个链表尾结点指向剩余未遍历结束的链表

               返回第三个链表首结点

    代码：

/*public class ListNode {    int val;    ListNode next = null;    ListNode(int val) {        this.val = val;    }}*/public class Solution {    public ListNode Merge(ListNode list1,ListNode list2) {                if(list1==null)            return list2;        if(list2==null)            return list1;        if(list1==null&&list2==null)            return null;                ListNode head=null;        ListNode p=null;         //取较小值作头结点        if(list1.val<=list2.val){            head=list1;                list1=list1.next;        }else{            head=list2;                     list2=list2.next;        }        p=head;   //链表head的工作指针            //开始遍历合并         while(list1!=null&&list2!=null){             if(list1.val<=list2.val){                  p.next=list1;                 list1=list1.next;                 p=p.next;             }else{                           p.next=list2;                 list2=list2.next;                 p=p.next;             }                      }        if(list1==null)            p.next=list2;    if(list2==null)            p.next=list1;        return head;         }    }

17.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

    思路：第一步，在树A中找到和树B的根结点的值相同的结点R

               结点R的子树是否和树B的子树有一样的结构（值也要相同）

代码：

/**public class TreeNode {    int val = 0;    TreeNode left = null;    TreeNode right = null;    public TreeNode(int val) {        this.val = val;    }}*/public class Solution {    public boolean HasSubtree(TreeNode root1,TreeNode root2) {                if(root1==null||root2==null)            return false;            if(root1.val==root2.val&&isSubTree(root1,root2)){            return true;                    }            //如果根节点不相同，则判断root1的左子树和root2是否相同，再判断右子树和root2是否相同        return HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);    }        private boolean isSubTree(TreeNode a,TreeNode b){        // B树遍历完，无论A树有没有遍历结束，A树都已经包含了B树        if(b==null)            return true;        // B树还没遍历完，A树先遍历结束，肯定不包含        if(a==null)            return false;        if(a.val!=b.val){            return false;        }        return isSubTree(a.left,b.left)&&isSubTree(a.right,b.right);    }        }

18.操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树         8       /  \      6   10     / \  / \    5  7 9 11    镜像二叉树        8       /  \      10   6     / \  / \    11 9 7  5

思路：1.防御式编程，判断根节点及左右节点是否为空？；

           2.交换左右节点的值；

           3.递归判断左右节点的值，循环执行1，2过程，直到程序结束。

代码：

/**public class TreeNode {    int val = 0;    TreeNode left = null;    TreeNode right = null;    public TreeNode(int val) {        this.val = val;    }}*/public class Solution {    public void Mirror(TreeNode root) {        if(root==null)            return;        if(root.left!=null||root.right!=null){            TreeNode temp=null;            temp=root.left;            root.left=root.right;            root.right=temp;            Mirror(root.left);            Mirror(root.right);        }    }}

19.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

    思路：使用一个栈和一个最小栈

               入栈时：当压人一个比当前最小值还小的值，压入最小栈；

               出栈时：如果弹出的值比当前最小值还小，最小栈弹出；

代码：

import java.util.Stack;public class Solution {    Stack<Integer> s=new Stack<Integer>();    Stack<Integer> m=new Stack<Integer>();    public void push(int node) {        if(m.empty()){            m.push(node);            return;        }        if(node<=min())            m.push(node);        s.push(node);    }    public void pop() {        int ele=s.pop();        if(ele==min())            m.pop();    }    public int top() {        return s.peek();    }    public int min() {        return m.peek();    }}

20.定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

    思路：使用一个栈和一个最小栈

               入栈时：当压人一个比当前最小值还小的值，压入最小栈；

               出栈时：如果弹出的值比当前最小值还小，最小栈弹出；

代码：

import java.util.Stack;public class Solution {    Stack<Integer> s=new Stack<Integer>();    Stack<Integer> m=new Stack<Integer>();        public void push(int node) {        if(m.empty()){            m.push(node);            return;        }        if(node<=min())            m.push(node);        s.push(node);    }        public void pop() {        int ele=s.pop();        if(ele==min())            m.pop();    }        public int top() {        return s.peek();    }        public int min() {        return m.peek();    }}