剑指offer（11-20）-优快云博客

本文链接：https://blog.youkuaiyun.com/qq1274781334/article/details/52346007

本文集解答了多个经典的编程题目，包括矩形覆盖、二进制位计数、幂的计算、链表操作、二叉树镜像转换等，涵盖了算法、数据结构、链表和二叉树等核心知识点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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();
    }
}