《剑指offer》题目 C++详细题解

最新推荐文章于 2024-08-18 17:01:18 发布
最新推荐文章于 2024-08-18 17:01:18 发布
阅读量786 收藏 15
点赞数 26
分类专栏： C++算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64446981/article/details/140928038
版权

JZ15 二进制中1的个数

核心考点：二进制计算

思路一：使用一个循环，因为我们知道整型变量只有32位，所以循环结束的条件就是到32，从最低位开始，逐位检查数字 n 的二进制表示，利用位运算中的与运算，将当前位移到最低位，然后与 1 进行按位与运算，判断结果是否为 1，如果当前位为 1，则计数器 count 加 1，循环结束后，计数器 count 中保存的就是数字 n 的二进制表示中 1 的个数。

class Solution {
public:
    int NumberOf1(int n) {
       int count = 0;
       int i = 0;
       while(i < 32)
       {
          if((n >> i) & 1 == 1) // 使用按位与进行比较
             count++;
          i++;
       }
       return count;
    }
};

但是上面的算法的时间复杂度是O(N)的，有没有更简单更便捷的算法呢？

思路二：使用 while 循环，只要 n 不为 0，就继续循环。循环中，执行 n &= (n - 1) 操作。该操作利用了二进制数中 1 的性质：将一个数减 1，然后与原数进行按位与运算，可以将最右边的一个 1 变成 0，每次执行 n &= (n - 1) 操作后，n 中的 1 的个数减少 1，因此代码将计数器 count 加 1，循环结束后，计数器 count 中保存的就是 n 的二进制表示中 1 的个数，代码返回 count。

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

这种方法比直接遍历二进制位效率更高，因为每次循环都只进行一次位运算，可以更快地将 n 中的 1 个数进行统计。

JZ22 链表中倒数最后k个结点

核心考点：链表，前后指针的使用，边界条件的检查

由于题目中明确了这是一个单链表，所以我们不可以从后向前遍历找到最后k个节点，所以此时我们可以使用前后双指针的思路，前指针先走k步，随后前后两个指针同时向后走，当前指针到达结尾的时候，后指针所在的位置就是倒数最后k个节点 。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        ListNode* fast = pHead;
        ListNode* slow = pHead;
        // 前指针先走k步
        while(k--)
        {
            if(fast == nullptr)
                return nullptr;
            fast = fast->next;
        } 
        // 前后指针同时走
        while(fast)
        {
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
};

JZ24 反转链表

核心考点：链表操作，思维缜密程度

这个题目的做法有很多种，我们依次来写一下。

思路一：定义三个指针，整体右移，边移动边翻转，保证不会断链

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* ReverseList(ListNode* head) {
        if(!head || !head->next)
            return head;
        // 至少两个节点
        ListNode* n1, *n2, *n3;
        n1 = head;
        n2 = head->next;
        n3 = head->next->next; // 可能为空
        
        while(n3 != nullptr)
        {
            n2->next = n1; // 翻转
            // 向后移动
            n1 = n2;
            n2 = n3;
            n3 = n3->next; // 不断链
        }

        // 走到这里n3为空
        n2->next = n1;
        head->next = nullptr;
        return n2;
    }
};

思路二：采用头插的方法进行翻转，此时拿原始链表的时候注意不要断链

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* ReverseList(ListNode* head) {
        if(!head || !head->next)
            return head;
        // 至少两个节点
        
        ListNode* newhead = nullptr;
        ListNode* cur = head;
        while(cur)
        {
            // 把原链表的第一个节点拿下来
            ListNode* tmp = cur;
            cur = cur->next;
            // 头插
            tmp->next = newhead;
            newhead = tmp;
        }
        return newhead;
    }
};

思路三：使用递归来解决，过程中出现重复子问题

如果我们先逆序前两个节点，会出现什么问题呢？

我们会发现此时会出现断链的情况，会把节点值为3的节点丢失，从而找不到后面的节点，会造成内存泄漏的问题，所以先直接修改前两个是不合理的，所以我们需要换一种思路，以一种宏观的思路，相信dfs一定可以能帮我们完成的逆序的任务，给dfs一个头节点，dfs帮我完成逆序，返回逆序之后的头节点，那么此时就有：

此时刚好就完成了我们的逆序工作，如果上面的思路不好理解，我们可以把链表当作一棵树，只不过此时是一个单边树，此时我们对这棵树仅需进行以此后序遍历即可

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* ReverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) 
            return head;
        ListNode* newhead = ReverseList(head->next);
        
        head->next->next = head;
        head->next = nullptr;

        // 返回逆序之后的头节点
        return newhead;
    }
};

JZ25 合并两个排序的链表

核心考点：链表合并

对于这道题，解题的思路有很多种，我们可以一个一个节点的归并，当然，也可以采用递归完成。

思路一：通过循环遍历两个有序链表，每次选择较小的节点插入到新的链表，最终得到一个合并后的有序链表。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(pHead1 == nullptr)
            return pHead2;
        if(pHead2 == nullptr)
            return pHead1;
        
        ListNode* cur1 = pHead1;
        ListNode* cur2 = pHead2;
        // 标明新链表的头尾节点,闭区间
        ListNode* newhead = nullptr;
        ListNode* tail = nullptr;
        while(cur1 && cur2)
        {
            // 选出较小的节点
            ListNode* tmp = nullptr;
            if(cur1->val >= cur2->val)
            {
                tmp = cur2;
                cur2 = cur2->next;
            }
            else
            {
                tmp = cur1;
                cur1 = cur1->next;
            }
            // 尾插到新链表
            if(newhead == nullptr)
            {
                newhead = tail = tmp;
            }
            else
            {
                tail->next = tmp;
                tail = tail->next;
            }
        }
        // 合并后,cur1或者cur2可能不为空,此时直接链接即可
        if(cur1)
            tail->next = cur1;
        if(cur2)
            tail->next = cur2;
        return newhead;
    }
};

思路二：通过递归调用 Merge 函数，每次将两个链表首节点进行比较，并将较小的节点作为合并后的新链表的头节点，并将较小的节点的 next 指针指向递归调用 Merge 函数的结果，最终得到一个合并后的有序链表。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(pHead1 == nullptr)
            return pHead2;
        if(pHead2 == nullptr)
            return pHead1;
        
        ListNode* head = nullptr;

        // 1.找到较小的节点,head
        // 并从原链表中删除该节点
        if(pHead1->val < pHead2->val)
        {
            head = pHead1;
            pHead1 = pHead1->next;
        }
        else
        {
            head = pHead2;
            pHead2 = pHead2->next;
        }
        //2.出现子问题,此时变少了一个节点
        // 但是此时依然是合并链表
        head->next = Merge(pHead1, pHead2);

        return head;
    }
};

想清楚上面的方法，此时我们的代码就能更优化一点。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(pHead1 == nullptr)
            return pHead2;
        if(pHead2 == nullptr)
            return pHead1;
        
        if(pHead1->val < pHead2->val)
        {
            pHead1->next = Merge(pHead1->next, pHead2);
            return pHead1;
        }
        else
        {
            pHead2->next = Merge(pHead1, pHead2->next);
            return pHead2;
        }
    }
};

JZ26 树的子结构

核心考点：二叉树理解，二叉树遍历

解题思路：二叉树都是递归定义的，所以递归操作是比较常见的做法，首先明白子结构怎么理解，可以理解成子结构是原树的子树（或者一部分)，也就是说，B要是A的子结构，B的根节点+左子树+右子树，都在A中存在且构成树形结构，所以我们比较的过程要分为两步

  • 1.先确定起始位置
  • 2.在确定从该位置开始，后续的左右子树的内容是否一致
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
  private:
    bool IsSameTree(TreeNode* root1, TreeNode* root2) {
        if (!root2) // 子树已经遍历完毕
            return true;
        if (!root1) // 母树已经遍历完毕
            return false;

        if (root1->val != root2->val)
            return false;

        // 此位置处根节点值相等
       	bool left = IsSameTree(root1->left, root2->left);
        bool right = IsSameTree(root1->right, root2->right);
        return left && right;
    }

  public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
        if (pRoot1 == nullptr || pRoot2 == nullptr)
            return false;

        bool result = false;
        // 先寻找起始位置
        if (pRoot1->val == pRoot2->val) {
            // 判断两棵树是否相同
            result = IsSameTree(pRoot1, pRoot2);
        }
        // 左子树和pRoot2比较
        if (result == false) {
            result = HasSubtree(pRoot1->left, pRoot2);
        }
        // 右子树和pRoot2比较
        if (result == false) {
            result = HasSubtree(pRoot1->right, pRoot2);
        }
        return result;
    }
};

JZ27 二叉树的镜像

核心考点：二叉树操作

这个题目我们仔细观察可以发现，所谓的二叉树镜像本质是自底向上进行左右左右子树交换的过程，既然是自底向上，那就说明这个题目的思想是后序遍历，这样这个题目就比较好写啦

class Solution {
public:
    TreeNode* Mirror(TreeNode* pRoot) {
        if(!pRoot)
            return pRoot;
        if(!pRoot->left && !pRoot->right)
            return pRoot;
        
        if(pRoot->left)
            Mirror(pRoot->left);
        if(pRoot->right)
            Mirror(pRoot->right);

        TreeNode* tmp = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = tmp;
        
        return pRoot;
    }
};

JZ76 删除链表中重复的结点

核心操作：链表操作，临界条件检查，特殊情况处理

解题思路：通过快慢指针的方式限定范围，从而达到去重的效果，这里需要注意处理全部相同，全部不同和部分相同的三种情况的方式。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead) {
        if(pHead == nullptr)
            return pHead;
        
        // 申请带头结点
        ListNode* head = new ListNode(0);
        head->next = pHead;

        // 定义重复区域的区间,左开右闭
        ListNode* prev = head;
        ListNode* tail = head->next;
        while(tail != nullptr)
        {
            // 1.先确定重复区域的起始位置
            while(tail->next != nullptr && tail->val != tail->next->val)
            {
                prev = tail;
                tail = tail->next;
            }
            // 2.确定重复区域的结束位置
            while(tail->next != nullptr && tail->val == tail->next->val)
            {
                tail = tail->next;
            }
            // 走到这里有三种情况
            // 1.tail->next为空, 有重复区间
            // 2.tail->next不为空, 有重复区间
            // 3.链表没有重复结点,没有重复区间
            if (prev->next != tail)
            {
                prev->next = tail->next;  
            }
            tail = tail->next;
            
        }
        ListNode* next = head->next;
        delete head;
        return next;
    }
};

JZ30 包含min函数的栈

核心考点：栈的规则性设计

解题思路：很容易想到，在栈内部保存min变量，每次更新的时候，都对min变量进行更新。//但是，面试官很容易就会问到：如果想拿出第二小，第三小的值怎么拿？用上面的办法就不行了，为了满足通用，我们使用一个辅助栈，内部保存元素的个数和数据栈完全一样，不过，辅助栈内部永远保存本次入栈的数为所有数据的最小值（注意：辅助栈内部元素可能会出现“必要性”重复)，我们这里是为了实现算法，所以就不从0开始实现stack了，我们直接使用c++库里面实现的栈就好，题面说了，保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法，所以，后面的代码对空的检验可有可无。

注意：最小栈的元素个数和数据栈的个数相同，最小栈的栈顶永远保存着当前个数的数据栈中的最小值，其中，最小栈可能出现重复的数组。

class Solution {
public:
    void push(int value) {
        st.push(value);
        if(minst.empty() || value < minst.top())
            minst.push(value); // 插入小值
        else
            minst.push(minst.top());  // 插入栈顶的值
    }
    void pop() {
        st.pop();
        minst.pop();
    }
    int top() {
        return st.top();
    }
    int min() {
        return minst.top();
    }
    stack<int> st;  // 数据栈
    stack<int> minst; // 最小栈
};

JZ31 栈的压入、弹出序列

核心考点：栈的理解

思路：将入栈序列的元素压入辅助栈。检查辅助栈的栈顶元素是否等于出栈序列的元素，如果相等，则执行出栈操作，继续检查直到栈顶元素不再等于出栈序列的元素或者栈为空。当入栈序列中的所有元素都被处理完后，检查出栈序列是否也到达了末尾。如果出栈序列也到达了末尾，说明所有元素都按照正确的顺序弹出了栈，因此此时是一个有效的弹出序列；反之则不是。

class Solution {
public:
    bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
        stack<int> st;
        int curpush = 0, curpop = 0;
        while(curpush < pushV.size())
        {
            // 入栈序列直接入栈
            st.push(pushV[curpush++]);
            // 出栈序列和栈顶元素相同,就一直出栈
            while(!st.empty() && st.top() == popV[curpop])
            {
                st.pop();
                curpop++;
            }
        }
        return curpop == pushV.size() ? true : false;
    }
};

JZ32 从上往下打印二叉树

核心考点：二叉树层序遍历

这个题目本质是二叉树的层序遍历，我们可以直接借助一个队列来完成这个题目，首先我们创建一个队列用来暂存待处理的节点，并创建一个用来存储层序遍历的结果的vector容器。将根节点压入队列，当队列不为空时，循环执行以下操作：从队列头部取出一个节点，将节点的值添加到结果中。如果节点有左子树，则将左子树节点加入队列。如果节点有右子树，则将右子树节点加入队列。当队列变为空时，所有节点都已经处理完毕，返回结果即可。

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
		vector<int> ret; // 返回层序遍历的结果
		queue<TreeNode*> q;
		if(root == nullptr)
			return ret;
		// 根节点先入队列
		q.push(root);
		
		while(q.size())
		{
			// 访问当前结点并出队列
			TreeNode* t = q.front();
			q.pop();
			ret.push_back(t->val);

			// 左子树入队列
			if(t->left)
				q.push(t->left);
			// 右子树入队列
			if(t->right)
				q.push(t->right);
		}
		return ret;
    }
};
三眼五显仙人~
关注
  • 26
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer题解(C++).docx
07-17
《剑指Offer题解》是针对面试准备的一份宝贵资源，由Sidney.Tan精心整理，结合了牛客网上的讨论、《剑指Offer》书中的解法以及个人的编程实践，提供了全面的代码和思路解析。这份文档按照牛客网上的题目顺序，覆盖了...
剑指offer题目题解java版+c++版+Python版.zip
07-15
总之，《剑指Offer》题解涵盖了编程基础、算法、设计模式等多个方面，通过不同语言的实现，帮助开发者巩固编程基础，提升解决实际问题的能力。无论是准备面试还是提升自身技术，都是不可或缺的学习资源。
c++-剑指offer题解之丑数
08-10
c++ c++_剑指offer题解之丑数
c++-剑指offer题解之矩形覆盖
08-10
c++ c++_剑指offer题解之矩形覆盖
c++-剑指offer题解之斐波那契数列
08-09
c++ c++_剑指offer题解之斐波那契数列
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
业精于勤，荒于嬉
08-14 1235
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 1165
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 824
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
LeeCode Practice Journal | Day43_DP10
Janniam的博客
08-14 283
上题的变体，与nums[i]前每一个连续的元素比较变为前一个元素比较。2、返回值不是dp[i]，是dp数组中的最大值。1、数组元素要初始化为1。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 375
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
noip2001数的划分
最新发布
no_play_no_games的博客
08-18 76
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 359
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
算法之递归和迭代
qq_28576837的博客
08-16 323
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 280
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
算法笔记：空间填充曲线
qq_40206371的博客
08-17 171
六次迭代的希尔伯特曲线：
算法：DFS之记忆化搜索
一名还在努力学习技术的程序员的博客
08-18 455
本篇博客是关于 记忆化搜索 的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
C - Enumerate Sequences（abc367）
m0_74310050的博客
08-18 244
题意：给定n，k和数组r，构造长度为n的整数序列，第i个元素介于1到ri之间，所有元素之和是k的倍数。分析：用dfs遍历每个1到ri之间，层数为n的时候停止深搜。
算法刷题day35|动态规划：121. 买卖股票的最佳时机、122. 买卖股票的最佳时机 II、123. 买卖股票的最佳时机 III
qq_61936886的博客
08-15 490
同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是dp[i - 1][1]呢？
看demo学算法之 循环神经网络（RNN）
wx740851326的博客
08-15 565
今天我们来聊聊神经网络中的“记忆大师”——循环神经网络（RNN）。想象一下，你正在看电影，每一帧都连贯着前一帧的故事情节。RNN就像是这样一位观众，它能记住之前看到的内容，帮助理解当前的画面。是不是很酷？🎬。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值