剑指offer(11-20)

原创 2016年08月28日 15:46:49
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();
    }
}



版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

剑指offer学习笔记(Java实现)(11-20)

题目11:数值的整数次方 书中方法:这道题要注意底数为0的情况。double类型的相等判断。乘方的递归算法。 public double power(double base, int expo...

剑指Offer(面试题19-20)

面试题19:二叉树的镜像题目:请完成一个函数,输入一个二叉树,该函数输出它的镜像。 二叉树结点的定义如下:struct BinaryTreeNode { int m_...

剑指offer之面试题20顺时针打印矩阵

问题描述:输入一个矩阵,按照从外向内以顺时针的顺序一次打印出每一个数字。

《剑指offer》面试题20 顺时针打印矩阵

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

剑指offer 20. 顺时针打印矩阵

按照此顺序进行输出 // 题目:输入一个二维矩阵,顺时针打印这个矩阵 // 解法:设置最大最小值,判断 public class Main { public static void main(S...

剑指offer面试题20-顺时针打印矩阵

题目: 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字。 如: 1-2-3-4 5-6-7-8 9-10-11-12 13-14-15-16 的矩阵,打印结果为:1,2,3...

【剑指offer】面试题20:顺时针打印矩阵

//题目:输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字. // 例如矩阵: 1 2 3 4 // 5 6 7 8 // ...

剑指offer--面试题20:顺时针打印矩阵

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

剑指offer-面试题20-顺时针打印矩阵

题目描述:输入一个矩阵,按照从外向里以顺时针的顺序依次扫印出每一个数字。题目解析:主要是对行号和列号的控制//顺时针打印矩阵 public static void printMatrix(in...

剑指offer 面试题20:顺时针打印矩阵及其变形(LeetCode54. Spiral Matrix旋转矩阵) 题解

剑指offer 面试题20:顺时针打印矩阵 题目描述: 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下矩阵: 1 2 3 4 5 6 7 8 9 10 11 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)