【牛客网】剑指Offer题解

最新推荐文章于 2022-08-13 06:00:00 发布
最新推荐文章于 2022-08-13 06:00:00 发布
阅读量393 收藏
点赞数 1
分类专栏： 剑指Offer 算法 文章标签： 数据结构 java 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DNMTOOBA/article/details/104714450
版权

目录

1.二维数组中的查找【数组】

题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

题解：
从左到右逐渐增大，从上到下逐渐增大。右边的一定比左边的大，下边的一定比上面大。所以我们选择第一行最后一个元素与目标值target比较，若target大于当前元素，说明与target相等的元素在下面，此时i++，访问下面的元素。若target小于当前元素，说明与target相等的元素在左侧，此时j–，访问左侧的元素。若相等，则找到匹配值，返回true；若整个过程并未找到匹配值，则返回false。最多遍历r+c次（即行数+列数）。

代码如下：

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int r=array.size();
        int c=array[0].size();
        
        int i=0;
        int j=c-1;
        while(i<r && j>=0){
            if(target > array[i][j]){
                i++;
            }else if(target < array[i][j]){
                j--;
            }else{
                return true;
            }
        }
        return false;
        
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

2.替换空格【字符串】

题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

代码如下：

public class Solution {
    public String replaceSpace(StringBuffer str) {
        StringBuffer newStr = new StringBuffer();
    	int len=str.length();
        for(int i=0;i<len;i++){
            if(str.charAt(i)==' '){
                newStr.append("%20");
            }else{
                newStr.append(str.charAt(i));
            }
        }
        return newStr.toString();
    }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

3.从尾到头打印链表【链表】

题目描述
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

代码如下：

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> sta = new Stack<>();
        while(listNode!=null){
            sta.push(listNode.val );
            listNode = listNode.next ;
        }
        ArrayList<Integer > res = new ArrayList<>();
        while(!sta.isEmpty()){
            res.add(sta.pop());
        }
        return res;
    }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

4.重建二叉树【树】

题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

知识补充：

先序遍历：
若二叉树为空，则什么也不做；否则，
1）访问根节点；
2）先序遍历左子树；
3）先序遍历右子树。
中序遍历：
若二叉树为空，则什么也不做；否则，
1）中序遍历左子树；
2）访问根节点；
3）中序遍历右子树。
后序遍历：
若二叉树为空，则什么也不做；否则，
1）后序遍历左子树；
2）后序遍历右子树；
3）访问根节点。

由二叉树的先序序列和中序序列可以唯一确定一颗二叉树。
由二叉树的后序序列和中序序列也可以唯一确定一颗二叉树。

在先序遍历序列中，第一个结点一定是二叉树的根节点；
在后序遍历序列中，最后一个结点也一定是二叉树的根节点；
而在中序遍历中，根节点必然将中序序列分割成两个子序列，前一个子序列是根节点的左子树的中序序列，后一个子序列是根节点的右子树的中序序列。
根据这两个子序列，在先序序列(或后序序列)中找到对应的左子序列和右子序列。在先序序列中，左子序列的第一个结点是左子树的根节点，右子序列的第一个结点是右子序列的根节点。后序序列同理。如此递归地进行下去，便能唯一地确定这颗二叉树。

代码如下：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.Arrays;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre.length == 0 || in.length == 0) {
            return null;
        }
        //在先序序列的第一个元素即为二叉树的根
        TreeNode theRoot = new TreeNode(pre[0]);
        // 在中序序列中找到前序的根
        for (int i = 0; i < in.length; i++) {
            if (in[i] == pre[0]) {
                // 左子树， copyOfRange 数组复制函数，范围左闭右开
                theRoot.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
                // 右子树， copyOfRange 数组复制函数，范围左闭右开
                theRoot.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
                break;
            }
        }
        return theRoot;
    }
}

补充：
copyOfRange用法链接：点此查看

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

5.用两个栈实现队列【栈和队列】

题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

题解：
首先，明确栈与队列的区别：
栈：先入后出；
队列：先入先出；
然后，
所有进入的都存到stack1中，在需要弹出时，把stack1中的元素都存到stack2中，此时在从stack2中弹出元素即可实现先入先出。这是只有一次持续加入元素的情况；而现实是，可能会在弹出元素后再要求加入元素，此时再弹出时，就要求先判断stack2中是否还有元素，若有就先把stack2中的元素弹出再进行下一步操作，当stack2中没有元素时，就要把stack1中元素全转到stack2中。
具体自己模拟两遍就懂了

代码如下：

class Solution
{
public:
    //先进先出
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        int temp=stack2.top();
        stack2.pop();
        return temp;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

6.旋转数组的最小数字【查找和排序】

题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

题解：
方法一：
暴力遍历找最小值输出。
代码如下：

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int len=rotateArray.size();
        if(len==0) return 0;
        int res=rotateArray[0];
        for(int i=0;i<len;i++){
            res=min(res,rotateArray[i]);
        }
        return res;
    }
};

方法二：
利用二分，每次将rotateArray[right]与rotateArray[mid]进行比较：
有三种情况，情况一：
代码如下：

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int len=rotateArray.size();
        if(len==0) return 0;
        int left=0;
        int right=len-1;
        while(left<right){
            if(rotateArray[left]<rotateArray[right]){
                return rotateArray[left];
            }
            int mid=(left+right)/2;
            if(rotateArray[right]<rotateArray[mid]){
                left=mid+1;
            }else if(rotateArray[right]>rotateArray[mid]){
                right=mid;
            }else{
                right--;
            }
        }
        return rotateArray[left];
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

7.斐波那契数列【递归和循环】

题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39

题解：
常规斐波那契数列：F(n)=F(n-1)+F(n-2) 其中F(1)=1、F(2)=1；
此处从0开始，即F(0)=0;
递归太耗时，用数组存每次的结果又太耗内存
用b表示第 i 项结果，它是第 i-1 项和 i-2 项的和；
而第 i+1 项的值，则是需要上一项（即第 i 项）的值b，同时需要第 i-1 项的值；
这就可以找到方法了：
当前值会成为下一项的前一项，而当前值的前一项会成为下一项的前两项；
b=a+b; a=b-a;随时更新b和a；

代码如下：

class Solution {
public:
    int Fibonacci(int n) {
        if(n<=1) return n;
        int a=0;
        int b=1;
        for(int i=2;i<=n;i++){
            b=a+b;
            a=b-a;
        }
        return b;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

8.跳台阶【递归和循环】

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

题解：
找规律：
到第1级，只有1种跳法，即直接一步跨上去
到第2级，只有2种跳法，即先1步到第1级再1步到第2级，这是1种跳法；第2种是直接跨2步到第2级；
…
接着你便会发现：
当前你处于第 i 级，你只能从第 i-1 级跨1步到第 i 级，或从第 i-2 级跨2步到第 i 级；
即到第 i 级的跳法 ：F(i)=F(i-1)+F(i-2)；
斐波那契数列，其写法参考上一题。

代码如下：

public class Solution {
    public int JumpFloor(int target) {
        if(target==1)
            return 1;
        else if(target==2)
            return 2;
        
        int sum = 2;
        int num = 1;
        for(int i=3;i<=target;i++){
            sum = sum + num;
            num = sum - num;
        }
        return sum;
    }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

9.变态跳台阶【递归和循环】

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

题解：
我们只需要考虑一个问题：当前台阶能从哪个台阶跳过来？
若处于第 i 级，则 能从第0级，第1级，第2级…第 i-1 级跳过来；
即： F(i) = F(0) + F(1) +F(2)+…+F(i-1);
其中F(0)=1，即从第0级跨 i 步到第 i 级；
可知：
F(1)=1;
F(2)=1+1=2;
F(3)=1+1+2=4;
F(4)=1+1+2+4=8;
可知F(i)=2^(i-1);

代码如下：

class Solution {
public:
    int jumpFloorII(int number) {
        /*
        1  1
        2  1+1=2
        3  1+1+2=4
        4  1+1+2+4=8
        */
        return 1<<(number-1);
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

9.矩形覆盖【递归和循环】

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

比如n=3时，2*3的矩形块有3种覆盖方法：
在这里插入图片描述

题解：
找规律，递推。

代码如下：

public class Solution {
    public int RectCover(int target) {
        if(target==0)
            return 0;
        else if(target ==1)
            return 1;
        else if(target==2)
            return 2;
        
        int sum=2;
        int num=1;
        
        for(int i=3;i<=target;i++){
            sum=sum+num;
            num=sum-num;
        }
        return sum;
    }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

10.二进制中1的个数【位运算】

题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

题解：
一个整数只要不为0，其二进制中一定有1；
若一个数的二进制为1100，其减1为1011；
二者进行按位与运算，即1100&1011=1000；
可知，再减1，然后按位与，1000&0111=0；
按这个思路，就可找到该数二进制中1的个数。

代码如下：

public class Solution {
    public int NumberOf1(int n) {
        int num=0;
        while(n!=0){
            num++;
            n=n &(n-1);
        }
        return num;
    }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

11.数值的整数次方【代码的完整性】

题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为0

代码如下：

public class Solution {
    public double Power(double base, int exponent) {
        return Math.pow(base,exponent);
  }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

12.调整数组顺序使奇数位于偶数前面【代码的完整性】

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

题解：
内存占用略多，复杂度还行

代码如下：

public class Solution {
    public void reOrderArray(int [] array) {
        int len = array.length;
        int[] a=new int[len];
        int[] b=new int[len];
        int ak=0;
        int bk=0;
        for(int i=0;i<len;i++){
            if(array[i]%2==1)
                a[ak++]=array[i];
            else
                b[bk++]=array[i];
        }
        for(int i=0;i<ak;i++){
            array[i]=a[i];
        }
        for(int i=0;i<bk;i++){
            array[i+ak]=b[i];
        }
        
    }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

13.链表中倒数第k个结点【代码的鲁棒性】

题目描述
输入一个链表，输出该链表中倒数第k个结点。

题解：
快慢指针，设立两个指针fast和head；
起始时都指向头节点，
fast先遍历k次，若不到k个就发现fast==null，说明链表内的结点不到k个，直接null；
然后fast和head同时向后遍历，直到fast指向null，说明此时fast已访问到链表的末尾；而又因为fast比head多遍历k次，而后二者是同时遍历的，所以当fast指向链表尾部时，head刚好指向链表的中倒数第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 fast=head;
        ListNode slow=head;
        for(int i=0;i<k;i++){
            if(fast==null )
                return null;
            fast=fast.next;
        }
        while(fast!=null){
            fast=fast.next ;
            slow=slow.next;
        }
        return slow;
    }
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

14.反转链表【代码的鲁棒性】

题目描述
输入一个链表，反转链表后，输出新链表的表头。

题解：
链表内的各结点是通过指针顺次相连的，题目要求反转链表，我们只需要改变各结点之间原有的链接关系即可，即反向链接即可。
这时我们引入两个辅助用的指针pre(指向前一个结点)和next(指向后一个结点)。
head指向当前结点，head.next指向下一个结点，这样才构成了整个链表；而我们要做的就是让head.next指向前一个结点。
知道了思路，接下来就是要利用pre和next辅助转变：
next=head.next; //解放出head.next以便下一步让其指向前一个结点，同时next可以便于链表向后遍历；
head.next = pre; //指向前一个结点，完成了一个结点的反向链接，接下来的操作就是要保证后序的结点也可以这么方便的操作。
pre=head; //为下一轮操作做准备，
head=next; //为下一轮操作做准备，

代码如下：

/*
public class ListNode {
    int val;
    ListNode next = null;

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

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

16.合并两个排序的链表【代码的鲁棒性】

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

题解：
注意要设头结点，初始的作为结果指针不动，另一个指向初始的结果指针，并且机动。

代码如下：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        ListNode* pstr=new ListNode(-1);
        ListNode* temp=pstr;
        while(pHead1&&pHead2){
            if(pHead1->val<pHead2->val){
                temp->next=pHead1;
                pHead1=pHead1->next;
                temp=temp->next;
            }else{
                temp->next=pHead2;
                pHead2=pHead2->next;
                temp=temp->next;
            }
            
        }
        if(pHead1) temp->next=pHead1;
        else temp->next=pHead2;
        
        return pstr->next;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

17.二叉树的镜像

题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。

比如：    源二叉树 
            8
           /  \
          6   10
         / \  / \
        5  7 9 11
        镜像二叉树
            8
           /  \
          10   6
         / \  / \
        11 9 7  5

题解：

递归解决

代码如下：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    TreeNode* Mirror(TreeNode* pRoot) {
        // write code here
        //每一个节点的左右子孩子都要交换
        if(pRoot==NULL) return NULL;
        TreeNode* temp=Mirror(pRoot->left);//左边换好的
        pRoot->left=Mirror(pRoot->right);//右边换好的交给左边
        pRoot->right=temp;//左边换好的交给右边
        return pRoot;//以pRoot为根节点的子树，已完成交换，所以返回
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

20.包含min函数的栈

题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数。在该栈中，调用 min、push 及 pop 函数的时间复杂度都是 O(1).
push(value)：将元素 value压入栈中
pop()：弹出栈顶的元素
top() ：获得栈顶元素
min() ：获得栈中的最小元素。

题解：
用一根正常的栈保存数据，用一个辅助栈更新最小值。这个辅助栈会随着正常栈的更新而更新。
代码如下：

class Solution {
public:
    //开辟一个辅助栈，这个辅助栈用来更新对应正常栈的位置的最小值
    stack<int> normal,minval;
    void push(int value) {
        normal.push(value);
        if(minval.empty()){
            minval.push(value);
        }else{
            if(value<=minval.top()){
                minval.push(value);
            }else{
                minval.push(minval.top());
            }
        }
    }
    void pop() {
        normal.pop();
        minval.pop();
    }
    int top() {
        return normal.top();
    }
    int min() {
        return minval.top();
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

28.数组中出现次数超过一半的数字

题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组[1,2,3,2,2,2,5,4,2]。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。你可以假设数组是非空的，并且给定的数组总是存在多数元素。1<=数组长度<=50000

题解：
方法一：
第一反应是统计每个元素的出现次数，超过一半就是答案

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        map<int,int> ma;
        int len=numbers.size();
        for(int i=0;i<len;i++){
            ma[numbers[i]]++;
            if(ma[numbers[i]]>(len/2)) return numbers[i];
        }
        return 0;
    }
};

方法二：
直接排序，如果有答案，那一定是处于中间的那个数字。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        sort(numbers.begin(),numbers.end());
        int len=numbers.size();
        int cnt=numbers[len/2];
        int num=0;
        for(int i=0;i<len;i++){
            if(numbers[i]==cnt){
                num++;
                if(num>(len/2)) return cnt;
            }
        }
        return 0;
    }
};

方法三：
一个元素的个数超过一半，那么这个元素把所有与他不相同的元素抵消掉之后，剩余的个数仍大于1.

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int cnt=-1;
        int num=0;
        for(int i=0;i<numbers.size();i++){
            if(num==0){
                cnt=numbers[i];
                num++;
            }else{
                if(cnt==numbers[i]) num++;
                else num--;
            }
        }
        num=0;
        for(int i=0;i<numbers.size();i++){
            if(cnt==numbers[i]) num++;
        }
        if(num>(numbers.size()/2)) return cnt;
        return 0;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

30.连续子数组的最大和

题目描述
输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为 O(n).

题解：
动态规划最重要的是状态转移
dp[i] 以i为结尾的连续数组的最大和。
状态转移方程：dp[i]=max(array[i],dp[i-1]+array[i])
同时用res更新最大的值
代码如下：

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        //动态规划最重要的是状态转移
        //dp[i] 以i为结尾的连续数组的最大和。
        //状态转移方程：dp[i]=max(array[i],dp[i-1]+array[i])
        vector<int> dp(array.size());
        int res=array[0];
        dp[0]=array[0];
        for(int i=1;i<array.size();i++){
            dp[i]=max(array[i],dp[i-1]+array[i]);
            res=max(res,dp[i]);
        }
        return res;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

34.第一个只出现一次的字符串

题目描述
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

题解：
哈希，先遍历并用map存一下，然后在遍历一遍

代码如下：

class Solution {
public:
    int FirstNotRepeatingChar(string str) {
        unordered_map<char, int> mp;
        for(int i=0;i<str.length();i++){
            mp[str[i]]++;
        }
        for(int i=0;i<str.length();i++){
            if(mp[str[i]]==1) return i;
        }
        return -1;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

36.两个链表的第一个公共节点

题目描述
输入两个无环的单链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

题解：
用双指针遍历，但是由于两个链表的长度可能不一致，所以拼接一下
a+b
b+a
这样，他们的长度就一致了，由于后面一部分是相等的，所以无论如何，拼接之后的最后一段都是相等的。
代码如下：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        if(pHead1==NULL||pHead2==NULL) return NULL;
        ListNode* p1=pHead1;
        ListNode* p2=pHead2;
        while(p1!=p2){
            p1=p1->next;
            p2=p2->next;
            if(p1!=p2){
                if(p1==NULL) p1=pHead2;
                if(p2==NULL) p2=pHead1;
            }
        }
        return p1;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

38.二叉树的深度

题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

题解：
递归每一层的深度，取最大的
也可以这样说，当前节点的深度就是1+左右节点深度的最大值

代码如下：

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot) {
        //当前层+下层的最大值
        if(pRoot==NULL) return 0;
        return 1+max(TreeDepth(pRoot->left),TreeDepth(pRoot->right));
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

39.平衡二叉树

题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树
平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

题解：
判断左右子树深度的差值是否满足条件

代码如下：

class Solution {
public:
    int TreeDepth(TreeNode* pRoot){
        if(pRoot==NULL) return 0;
        return 1+max(TreeDepth(pRoot->left),TreeDepth(pRoot->right));
    }
    bool IsBalanced_Solution(TreeNode* pRoot) {
        if(pRoot==NULL) return true;
        return abs(TreeDepth(pRoot->left)-TreeDepth(pRoot->right))<=1;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

45.扑克牌顺子

题目描述
现在有2副扑克牌，从扑克牌中随机五张扑克牌，我们需要来判断一下是不是顺子。
有如下规则：

  1. A为1，J为11，Q为12，K为13，A不能视为14
  2. 大、小王为 0，0可以看作任意牌
  3. 如果给出的五张牌能组成顺子（即这五张牌是连续的）就输出true，否则就输出false。
    例如：给出数据[6,0,2,0,4]
    中间的两个0一个看作3，一个看作5 。即：[6,3,2,5,4]
    这样这五张牌在[2,6]区间连续，输出true
    数据保证每组5个数字，每组最多含有4个零，数组的数取值为 [0, 13]

题解：
用set把非零的数存入，如果遇到重复的直接返回false；
接下来我们的数组中，只可能是非重复的；
统计非零数中的最大值和最小值，如果二者之差小于5，则为true，反之为false；

代码如下：

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {
        
        int maxn=-1;
        int minn=14;
        set<int> st;
        for(int i=0;i<numbers.size();i++){
            if(numbers[i]>0){
                if(st.count(numbers[i])>0) return false;
                st.insert(numbers[i]);
                minn=min(minn,numbers[i]);
                maxn=max(maxn,numbers[i]);
            }
            
        }
        return maxn-minn<5;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

48.不用加减乘除做加法

题目描述
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

题解：
按位&，可得进位，但需要左移一位
按位^，可得非进位的和

代码如下：

class Solution {
public:
    int Add(int num1, int num2) {
        //不用四则运算，这时候只能考虑位运算了
        while(num2!=0){
            //负数左移会在低位补1，所以转化为无符号整数
            int c=(num1&num2)<<1;//求出所有的进位
            num1=num1^num2;//求出所有非进位和
            num2=c;//把进位赋给num2
        }
        return num1;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

50.数组中重复的数字

题目描述
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任一一个重复的数字。 例如，如果输入长度为7的数组[2,3,1,0,2,5,3]，那么对应的输出是2或者3。存在不合法的输入的话输出-1

题解：
方法很多，这里用了，map，还可以用set，或者直接sort然后比较前后是否相同。

代码如下：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param numbers int整型vector 
     * @return int整型
     */
    int duplicate(vector<int>& numbers) {
        // write code here
        map<int,int> mp;
        for(int i=0;i<numbers.size();i++){
            mp[numbers[i]]++;
            if(mp[numbers[i]]>1) return numbers[i];
        }
        return -1;
    }
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

51.构建乘积数组

题目描述
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）
对于A长度为1的情况，B无意义，故而无法构建，因此该情况不会存在。

题解：
分别统计前缀积与后缀积

代码如下：

class Solution {
public:
    vector<int> multiply(const vector<int>& A) {
        vector<int> B(A.size(),1);
        int temp=1;
        for(int i=1;i<A.size();i++){
            temp*=A[i-1];
            B[i]=temp;
        }
        temp=1;
        for(int i=A.size()-2;i>=0;i--){
            temp*=A[i+1];
            B[i]*=temp;
        }
        return B;
    }
};

DNMTOOBA
关注
专栏目录
牛客网剑指Offer题解C++ (3/10)
mrbacker的博客
03-28 399
一、调整整数数组使奇数位于偶数前面 题目描述 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。 算法思想 这题我的想法是遍历数组，遇到偶数就将该偶数后面的前移移位，并将该偶数移到最后面，给一个值标记第一个偶数移的位置，当遍历到第一个偶数就完成了。 cla...
【剑指offer】【leetcode精选题集】【Java】剑指offer题解合集 更新中
dadongwudi的博客
07-30 538
Leetcode题集 [剑指offer][JAVA]面试题第[03]题[数组中的重复数字][HashSet] [剑指offer][JAVA]面试题第[04]题[二维数中的查找][数组] [剑指offer][JAVA]面试题第[05]题[替换空格][StringBuilder/Buffer] [剑指offer][JAVA]面试题第[06]题[从尾到头打印链表][栈][递归] [剑指offer][JAVA]面试题第[09]题[用两个栈实现队列][LinkedList] [剑指offer][JAVA]面试题第
剑指offer（牛客网）
04-09
根据牛客网上的目录来的，这个也是我在网上找到的，算是给自己留个备份。似乎一定要设置积分才能上传。
牛客网剑指offer
小小巴的博客
02-26 717
牛客网剑指offer 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 因为是旋转数组，考虑使用二分查找的方法，根据题目的意思，其实可以看作两个递增的数组，最开始旋转...
牛客网-剑指Offer（66题）
爱码者的博客
08-06 1035
1、在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 方法一：直接遍历二维数组 public class Solution { public static void main(String[] args){ int[][] a = ...
牛客网-剑指offer
崔洪振367
06-29 497
该部分主要是对递归的一个应用，同样也可以作为动态规划的基础题目去思考。 1、跳台阶 /** * * @author 崔洪振367 * @version 创建时间：2017年6月28日 下午9:24:40 */ public class 跳台阶 { public int JumpFloor(int target) { if(target == 1){ return 1;
牛客网剑指offer习题
qq_33700236的博客
04-06 456
1.输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 （1）.使用递归方法 /使用递归进行处理 import java.util.ArrayList; public class Solution { ArrayList<Integer> arraylist=new ArrayList<Integer>();//实例化一个数组列表arraylist ...
牛客网剑指offer——Java题解.pdf
09-07
本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：使用双指针，从右上角...
牛客网《剑指Offer》66题 题解-附件资源
03-05
牛客网《剑指Offer》66题 题解-附件资源
剑指offer题解（Java版）
12-27
剑指offer题解，使用Java实现，整理自牛客网，QQ交流群：419927514
牛客网剑指offer(Python版)
hitzijiyingcai的博客
06-03 5607
目录 第一题:二维数组中的查找 第二题:替换空格 第三题:从头到尾打印链表 第四题:重建二叉树 第五题：用两个栈来实现一个队列 第六题：旋转数组的最小数字 第七题：斐波那契数列 第一题:二维数组中的查找 解题思路:从左下角元素往上查找，右边元素是比这个元素大，上边是的元素比这个元素小。于是，target比这个元素小就往上找，比这个元素大就往右找。如果出了边界，则说明二...
牛客刷题——剑指offer
weixin_59796310的博客
07-19 1617
牛客刷题 ——保姆级剑指offer教学
牛客网_剑指Offer_6~10
Rikin2016的博客
04-25 181
前言 这五题都挺简单的，后面四题的套路都一样。 题目描述 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 代码如下： import java.util.ArrayLis...
剑指Offer【牛客网】刷题（一）
点君的博客
03-04 358
1、二维数组中的查找 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 思路：数组是有序的，一开始没看到每一列都递增，后来也懒得改了，时间复杂度有点高 易错点：考虑极端情况，如给的数组是空，长度为0 public boolean Find(int tar...
牛客网-剑指offer（Java实现版本）
单线程的Daniel的博客
05-19 400
ps:这也算是一个鸿篇巨制啦，关于牛客网的剑指offer题目终于用Java实现了一遍，其实之前草率的实现了一遍，但是很快就忘了，，，，更过分的是我再写这篇博文的时候，前面的有些题我依旧有一些忘记了，有几道题难度太大，我也是一知半解。太TM难过了。欢迎大家在参考的同时，随时向我提意见，我会很高心和小可爱、小帅哥讨论滴，以加深我的记忆。o(￣▽￣)o谢啦!!☆⌒(*＾-゜)v，，，也欢迎大家收藏我的blog，里面会有一些实用或者有趣或者深刻的内容，嘻嘻嘻。 二维数组的查找 FindArray 替换空格 Repl
牛客网 剑指Offer，一些值得记住的小题（三）
shl_shl的博客
03-30 1980
13.输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。 import java.util.*; public class Solution { public ArrayList Permutation(String str) { ArrayList
牛客网 剑指Offer，一些值得记住的小题（五）
shl_shl的博客
03-31 2020
25.在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是重复的数字2或者3。 public class Solution { // Parameters: // numbers:
牛客网《剑指offer》专栏刷题练习|锻炼递归思想|练习栈的使用
微凉秋意的博客
08-13 999
🔥前言 书接上文，今天继续分享牛客网中的经典好题。那么今天带来两道简单题，用到了递归和栈的知识，我做完之后感觉神清气爽啊。刷题入口放在文章开头了，点击注册即可，那么快来跟我一起刷题练习吧！...
牛客网剑指offer j
最新发布
08-16
- *1* *2* *3* [牛客网剑指offer——Java题解](https://blog.csdn.net/qq_43722914/article/details/120162127)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值