剑指offer

最新推荐文章于 2024-05-15 12:39:35 发布
最新推荐文章于 2024-05-15 12:39:35 发布
阅读量607 收藏
点赞数
分类专栏： OJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32095699/article/details/94008042
版权

变态跳台阶

题目描述

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

class Solution {
public:
    int jumpFloorII(int number) {
        vector<int>cur(number + 1, 0);
		vector<vector<int> > dp(number + 1, cur);
		int sum = 0;
		for (int i = 1; i <=number; i++)
		{
			dp[1][i] = 1;
		}

		for (int time = 2; time <= number; time++) {
			for (int step = time; step <= number; step++) {
				if (time == step)
					dp[time][step] = dp[time - 1][step - 1];
				else {
					dp[time][step] = dp[time - 1][step - 1] + dp[time][step - 1];
				}

			}

		}
		for (int i = 1; i <= number; i++) {
			sum += dp[i][number];
		}
		return sum;
    }
};

矩形覆盖

题目描述

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

#include<iostream>
using namespace std;
class Solution {
public:
	int rectCover(int number) {
		if (number == 0)
			return 0;
		if (number == 1)
			return 1;
		else if (number == 2) {
			return 2;
		}
		/*else
			return rectCover(number - 1) + rectCover(number - 2);*/

		int k = 2, a = 1, b = 2, res;
		while (k < number) {

			res = a + b;
			a = b;
			b = res;
			k++;

		}
		return res;

	}
};

int main() {

	Solution *sol = new Solution();
	cout << sol->rectCover(3);

	std::cin.get();
	return 0;
}

可以先横着放，也可以先竖着放

二进制中1的个数

题目描述

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

#include<iostream>
#include<string>
#include<bitset>
using namespace std;


class Solution {
public:

    int  NumberOf1(int n) {
	    return bitset<32>(n).count();
    }

};

bitset用法：

https://www.cnblogs.com/magisk/p/8809922.html

    bitset<8> foo ("10011011");

    cout << foo.count() << endl;　　//5　　（count函数用来求bitset中1的位数，foo中共有５个１
    cout << foo.size() << endl;　　 //8　　（size函数用来求bitset的大小，一共有８位

    cout << foo.test(0) << endl;　　//true　　（test函数用来查下标处的元素是０还是１，并返回false或true，此处foo[0]为１，返回true
    cout << foo.test(2) << endl;　　//false　　（同理，foo[2]为０，返回false

    cout << foo.any() << endl;　　//true　　（any函数检查bitset中是否有１
    cout << foo.none() << endl;　　//false　　（none函数检查bitset中是否没有１
    cout << foo.all() << endl;　　//false　　（all函数检查bitset中是全部为１

树的子结构 

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

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<map>
using namespace std;

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
		val(x), left(NULL), right(NULL) {
	}
};
class Solution {
public:
	bool dfs(TreeNode* pRoot1, TreeNode* pRoot2, bool flag) {
		
		if (pRoot1 != NULL && pRoot2 == NULL)
			return false;
		if (pRoot1 == NULL &&pRoot2!=NULL)
			return false;
		if (pRoot1 == NULL && pRoot2 == NULL)
			return true;

		if (pRoot1->val == pRoot2->val) {
			if (pRoot2->left == NULL && pRoot2->right == NULL)
				return true;

			flag = true;
			if (dfs(pRoot1->left, pRoot2->left, flag) && dfs(pRoot1->right, pRoot2->right, flag))
				return true;
			else {
				flag = false;
				return dfs(pRoot1->left, pRoot2, flag) || dfs(pRoot1->right, pRoot2,flag);
			}
		}
		else {
			if (flag)
				return false;
			else
				return dfs(pRoot1->left, pRoot2, flag) || dfs(pRoot1->right, pRoot2, flag);

		}
	}
	bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
	{
		bool flag = false;
		return dfs(pRoot1, pRoot2, false);

	}
};

二叉树中和为某一值的路径

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

class Solution {
public:
	vector<vector<int> >res;

	//bool cmp(const vector<int> &a, const vector<int> &b) {
	//	int as = a.size();
	//	int bs = b.size();
	//	return as > bs;
	//}

	void dfs(TreeNode *root,vector<int> stack,int sum,int expectNumber) {
		if (root == NULL)return;
		stack.push_back(root->val);
		sum += root->val;
		if (sum > expectNumber)
			return;
		else if(root->left ==NULL && root->right==NULL && sum == expectNumber)
		{
			res.push_back(stack);
			return;
		}

		dfs(root->left, stack, sum, expectNumber);
		dfs(root->right, stack, sum, expectNumber);
		sum -= root->val;
		stack.pop_back();
		
	}
	vector<vector<int> > FindPath(TreeNode* root, int expectNumber) {
		
		vector<int> stack;
		int sum = 0;

		dfs(root, stack, sum, expectNumber);

		sort(res.begin(), res.end(), [](const vector<int> &a, const vector<int> &b) {return a.size() > b.size(); });

		return res;
	}
};

最小的K个数 - trick

题目描述

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

最小k个数-->建立大小为k的大根堆

最大k个数-->建立大小为k的小根堆

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>

using namespace std;

class Solution {
public:
	void swap(vector<int> &v, int a, int b) {
		int tmp = v[a];
		v[a] = v[b];
		v[b] = tmp;
	}

	void downAdjust(int i, vector<int> &v, int len) { //建最大堆,遍历v[k]~v[v.size()-1],只要小于堆顶就把堆顶（top[0]）替换掉
	
		int largest, left, right;
		while (i < len) {
			largest = i;
			left = 2 * i + 1;
			right = 2 * i + 2;
			if (right >= len && left >= len)break;
			if (left<len && v[left]>v[i]) {
				largest = left;
			}
			if (right<len &&v[right]>v[largest]) {
				largest = right;
			}
			if (largest != i) {
				swap(v, largest, i);
				i = largest;
			}
			else
				break;
		}

	}


	void buildHeap(vector<int> &v) {
		int len = v.size();
		for (int i = len / 2 - 1; i >= 0; i--) {
			downAdjust(i, v, len);
		}
	}

	vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
		vector<int> res;
		int len = input.size();
		if (len == 0 || k > len || k == 0)return res;
		vector<int> top(k, 0);
		for (int i = 0; i < k; i++)
		{
			top[i] = input[i];
		}
		
		buildHeap(top);
		for (int i = k; i < input.size(); i++)
		{
	
			if (input[i] < top[0]) {
				top[0] = input[i];
				downAdjust(0, top, k);

			}
		}
		return top;
	}
};
int main() {

	Solution *sol = new Solution();
	vector<int> input = { 3 };
	vector<int> top = sol->GetLeastNumbers_Solution(input, 0);

	for (int i = 0; i < top.size(); i++)
	{
		cout << top[i] << endl;
	}
	std::cin.get();
	return 0;
}

丑数 - trick

题目描述

把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

超时代码：

class Solution {
public:

	bool judge(int x) {
		//if (x == 1)return true;

		while (x % 2 == 0)
			x /= 2;
		while (x % 3 == 0)
			x /= 3;
		while (x % 5 == 0)
			x /= 5;


		if (x == 1)return true;
		else
			return false;
		

	}

	int GetUglyNumber_Solution(int index) {
		int k = 0;
		int i = 0;
		while (k<index)
		{
			i++;
			if (judge(i)) {
				k++;
			}
			
		}
		return i ;
	}
};

AC代码：
 

class Solution {
public:

	

	int GetUglyNumber_Solution(int index) {
		if (index < 7)return index;
		vector<int>res(index, 0);
		res[0] = 1;
		int t2 = 0, t3 = 0, t5 = 0;
		for (int i = 1; i < index; i++) {

			res[i] = min(res[t2] * 2, min(res[t3] * 3, res[t5] * 5));
			if (res[i] == res[t2] * 2)t2++;
			if (res[i] == res[t3] * 3)t3++;
			if (res[i] == res[t5] * 5)t5++;
		}
		return res[index - 1];
	}
};

 

参考：https://www.nowcoder.com/questionTerminal/6aa9e04fc3794f68acf8778237ba065b 

把数组排成最小的数 - trick

题目描述

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>

using namespace std;
class Solution {
public:
	string PrintMinNumber(vector<int> numbers) {
		vector<string> res;
		for (int i = 0; i < numbers.size(); i++)
		{
			res.push_back(to_string(numbers[i]));
		}
		sort(res.begin(), res.end(), [](string a, string b) {return a + b < b + a; });
		string str;
		for (int i = 0; i < res.size(); i++)
		{
			str += res[i];
		}
		return str;
	}
};
int main() {
	Solution sol;
	vector<int> v = { 3,32,321 };
	cout << sol.PrintMinNumber(v) << endl;

	cin.get();
}

整数中1出现的次数（从1到n整数中1出现的次数）--trick

暴力解法：

class Solution {
public:
	int num1(int x) {
		string str = to_string(x);
		int cnt = 0;
		for (int i = 0; i < str.size(); i++)
		{
			if (str[i] == '1')
				cnt++;
		}
		return cnt;
		
	}
	int NumberOf1Between1AndN_Solution(int n)
	{
		int sum = 0;
		for (int i = 1; i <= n; i++)
		{
			sum += num1(i);
		}
		return sum;
	}
};

找规律：

class Solution {
public:


	int getLenOfNum(int n) {
		int len = 0;
		while (n != 0) {
			len++;
			n /= 10;
		}
		return len;
	}
	int NumberOf1Between1AndN_Solution(int n)
	{

		if (n < 1)
			return 0;
		int len = getLenOfNum(n);
		if (len == 1)
			return 1;
		int tmp = (int)pow(10, len - 1);
		int first = n / tmp;
		int firstOneNum = first == 1 ? n % tmp + 1 : tmp;
		int otherOneNUm = first * (len - 1) * (tmp / 10);
		return firstOneNum + otherOneNUm + NumberOf1Between1AndN_Solution(n % tmp);
	}
};

二叉搜索树与双向链表 -- trick 

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

 通过一个pre指针来记录上一个节点，然后中序遍历

参考代码：https://www.nowcoder.com/questionTerminal/947f6eb80d944a84850b0538bf0ec3a5

链接：https://www.nowcoder.com/questionTerminal/947f6eb80d944a84850b0538bf0ec3a5
来源：牛客网

class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if(pRootOfTree == nullptr) return nullptr;
        TreeNode* pre = nullptr;
         
        convertHelper(pRootOfTree, pre);
         
        TreeNode* res = pRootOfTree;
        while(res ->left)
            res = res ->left;
        return res;
    }
     
    void convertHelper(TreeNode* cur, TreeNode*& pre)
    {
        if(cur == nullptr) return;
         
        convertHelper(cur ->left, pre);
         
        cur ->left = pre;
        if(pre) pre ->right = cur;
        pre = cur;
         
        convertHelper(cur ->right, pre);
         
         
         
    }
};

 我的代码，记录左右标记

class Solution {
public:

	TreeNode *link(TreeNode *root, bool is_left) {
		if (root == NULL)return root;
		if (root->left == NULL && root->right == NULL) return root;

		root->left = link(root->left, true);
		if (root->left != NULL)
			root->left->right = root;
		root->right = link(root->right, false);
		if (root->right != NULL)
			root->right->left = root;

		TreeNode *cur = root;
		if (!is_left) {
			while (cur->left != NULL) 
				cur = cur->left;		
		}
		else {
			while (cur->right != NULL) 
				cur = cur->right;
		}
		return cur;
	}


	TreeNode* Convert(TreeNode* pRootOfTree)
	{
		bool is_left = true;
		if (pRootOfTree == NULL)return NULL;
		pRootOfTree->left = link(pRootOfTree->left, is_left);
		if (pRootOfTree->left != NULL)
			pRootOfTree->left->right = pRootOfTree;
		pRootOfTree->right = link(pRootOfTree->right, !is_left);
		if (pRootOfTree->right != NULL)
			pRootOfTree->right->left = pRootOfTree;

		while (pRootOfTree->left != NULL) {
			pRootOfTree = pRootOfTree->left;
		}
		return pRootOfTree;
	}
};

按之字形顺序打印二叉树 -- trick

两个stack分别记录奇数层和偶数层

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

class Solution{
public:
	vector<vector<int> > Print(TreeNode* pRoot) {
		vector<vector<int> > res;
		if (!pRoot)return res;

		stack<TreeNode*> s1;
		stack<TreeNode*> s2;

		s1.push(pRoot);
		while (!s1.empty() || !s2.empty()) {
			vector<int>cur;
			while(!s1.empty()) {
				
				TreeNode *w = s1.top();
				cur.push_back(w->val);
				s1.pop();
				if (w->left) {
					s2.push(w->left);
				}
				if (w->right) {
					s2.push(w->right);
				}
			}
			if (!cur.empty()) {
				res.push_back(cur);
				cur.clear();
			}

			while (!s2.empty()) {
				TreeNode *w = s2.top();
				cur.push_back(w->val);
				s2.pop();
				if (w->right) {
					s1.push(w->right);
				}
				if (w->left) {
					s1.push(w->left);
				}
			}
			if (!cur.empty()) {
				res.push_back(cur);
				cur.clear();
			}
		}
		


		return res;
	}

};

 

DXT00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer（1）（讲解极其详细版）
qq_41134710的博客
11-30 2215
剑指Offer（详细讲解版）
牛客网剑指offer——Java题解.pdf
09-07
剑指offer Java题解 本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：...
【剑指offer经典算法题目总结】
weixin_56235740的博客
05-16 229
本篇题目主要来源于剑指offer一书，是面试中高频率出现的问题，具有很强的复习参考价值，可作为面试前速览，其中不仅有题目解法，还有详细的分析过程，快来为你的面试准备锦上添花吧！
2024年最新剑指Offer——知识点储备-网络基础_剑指offer 网络，三面美团前端岗
最新发布
2401_84438654的博客
05-15 466
我在成长过程中也是一路摸爬滚打，没有任何人的指点，所以走的很艰难。例如在大三的时候，如果有个学长可以阶段性的指点一二，如果有已经工作的师兄可以告诉我工作上需要什么，我应该前面的三年可以缩短一半；后来去面试bat，失败了有5、6次，每次也不知道具体是什么原因，都是靠面试回忆去猜测可能是哪方面的问题，回来学习和完善，当你真正去招人的时候，你就会知道面试记录是多么重要，面试官可以从面试记录里看到你的成长，总是去面试，总是没有成长，就会被定义为缺乏潜力。
《剑指Offer》笔记&题解&思路&技巧&优化_Part_7
这里有一只小马吖
02-23 1180
🟢1. LCR 179. 查找总价格为目标值的两个商品 🟢2. LCR 180. 文件组合 🟢3. LCR 181. 字符串中的单词反转 🟢4. LCR 182. 动态口令 🔴5. LCR 183. 望远镜中最高的海拔 🟡6. LCR 185. 统计结果概率 🟢7. LCR 186. 文物朝代判断 🟢8. LCR 187. 破冰游戏 🟢8. LCR 187. 破冰游戏 🟡9. LCR 188. 买卖芯片的最佳时机 🟡10. LCR 189. 设计机械累加
力扣【剑指offer】题目汇总与总结
热门推荐
华辰烟雨的博客
08-06 2万+
本文为《剑指offer》刷题笔记的总结，花费不到两个月的时间将力扣上《剑指offer》的75道题刷了一遍，遇到不会的知识点或者应该做一些记录的题目都将其写在了往日的博客里。 整体来看，这75道题，涉及到常用的数据结构：数组、字符串、链表、栈、队列、树、图，还有一些常用的数据操作和算法：二分法、哈希表、递归、排序、查找、位运算、动态规划、回溯、滑动窗口、双指针、深度优先搜素（DFS）、贪心。 1、数组 （1）剑指offer03.数组中重复的数字。 （2）剑指offer04.二维数组中的查找。解法：找标
（最新版2022版）剑指offer之队列 & 栈题解
weixin_51405802的博客
10-31 517
（最新版2022版）剑指offer之队列 & 栈题解
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
剑指offer笔试及源程序
10-31
《剑指offer笔试及源程序》是一份针对IT求职者极具价值的资源，它涵盖了名企面试中常见的编程题目，并提供了详细的源代码解析。这份资料旨在帮助应聘者提升编程技能，增强解决实际问题的能力，从而在面试中脱颖而出...
《剑指Offer》题目及java代码实现
12-10
《剑指Offer》是一本备受推崇的编程面试指南，它集结了众多知名互联网公司的面试题，旨在帮助程序员提升算法和编程能力，为求职面试做好准备。本书主要关注于Java语言的实现，通过解决书中提出的各类问题，读者可以...
剑指offer程序
01-04
《剑指Offer》是一本备受推崇的编程面试指南，它为准备进入IT行业的求职者提供了大量实战性的编程题目。这个压缩包文件包含了该书中的部分练习程序，旨在帮助求职者熟悉并掌握常见的算法和数据结构问题，从而在面试...
剑指 offer 题解.pdf
09-13
剑指 offer 题解.pdf
剑指 Offer 专项突击版刷题笔记 3
hijackedbycsdn的博客
07-08 194
又因为在环中的指针走整数倍的圈数不影响它的位置，所以新指针走 a 步走到了入环点，而 slow 指针走的 c + (n - 1)(b + c) 步，原来在 b 步的位置，现在其实就是 b + c + (n - 1)(b + c) = n(b + c)，%(b + c) 得 0，也就是 slow 指针也走到了入环点。首先其实要知道的是，在环中，假设以入环点为序号 0，某个指针现在的序号为 i，环的长度为 len，那么如果你在环中某一个走了 n 步，你接下来的序号为 (n + i) % len。
剑指offer学习笔记（更新中）
weixin_45318683的博客
01-16 411
题目描述：数组中重复的数字解决的思路：hashset(不可以输入重复的数据)；重新创建一个数组判断。
《剑指offer》题目汇总
李滚滚的博客
03-28 1386
文章目录面试题1 赋值运算符函数以上是基本的内容，但还是有代码异常安全性问题存在。 面试题1 赋值运算符函数 题目：如下为类型CMyString的声明，请为该类型添加赋值运算符函数。 class CMyString { public: CMyString(char* pData = nullptr); CMyString(const CMyString& str); ~CMyStri...
【目录】《剑指Offer》Java实现
weixin_30577801的博客
09-12 161
如题： 　　1) 找出数组中重复的数字 　　2) 不修改数组找出重复的数字 　　3) 二维数组中的查找 　　4) 替换空格 　　5) 从尾到头打印链表 　　6) 重建二叉树 　　7) 二叉树的下一个结点 　　8) 用两个栈实现队列 　　9) 斐波那契数列及青蛙跳台阶问题 　　10) 旋转数组的最小数字 　　11) 矩阵中的路径 　　12) 机器人的运...
【刷题】剑指Offer篇
weixin_44856492的博客
04-09 1060
小文目录：T12：矩阵中的路径 LeetCode刷题 码 码不停蹄 T12：矩阵中的路径 class Solution { public boolean exist(char[][] arr, String word) { char[] words = word.toCharArray(); if(arr == null || arr.length == 0){ return false; } for
剑指Offer题解（持续更新）
KelvinSu的博客
03-03 566
剑指Offer个人做题记录
剑指offer|40题题解汇总成pdf了
qq_35006660的博客
08-17 493
唠嗑一下，这上面的内容在以往的文章中写到过，我刻意练习了很久才有那么一点自信，时光不负有心人，自己努力，自己肯定，这样的文章都是前段时间总结的，对于java后端的我来说，这些总结是难能可...
剑指 Offer 编程解题与优化策略
在"剑指offer"这份文档中，作者提供了使用Python语言解决特定面试题的代码实现。文档关注于两个主要的编程问题，它们都与数组操作有关。 首先，面试题3要求找到一个长度为n的数组中重复的数字，其中数字范围在0到n-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值