2021-05-26

最新推荐文章于 2022-05-01 21:52:23 发布

cormacyoung

最新推荐文章于 2022-05-01 21:52:23 发布

阅读量205

点赞数

分类专栏： codetop 文章标签：数据结构

本文链接：https://blog.csdn.net/cormacyoung/article/details/117306653

版权

codetop 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

这篇博客探讨了三种经典的计算机算法问题：1) 如何在给定股票价格数组中找到最大利润；2) 如何进行二叉树的层序遍历；3) 如何反转链表的指定部分。每种问题都提供了详细的解决方案，包括使用最小值跟踪、队列以及迭代来解决这些挑战。

摘要由CSDN通过智能技术生成

刷题第一天

1、买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
笔记：
找出数组中的最小值，依次与其他值进行比较，差值最大的则为最大利润。

class Solution{
public:
	int maxProfit(vector<int>& prices) {
		if(prices.size() == 0) return 0;
		int maxvalue = 0;
		int minvalue = prices[0];
		for(int i = 0; i < prices.size(); i++){
			minvalue = min(minvalue, prices[i]);
			maxvalue = max(maxvalue, prices[i] - minvalue);
		}
		return maxvalue;
	}
};

2、二叉树的层序遍历

给你一个二叉树，请你返回其按层序遍历得到的节点值。（即逐层地，从左到右访问所有节点）。
笔记：使用一个队列，对于每一行的节点，存入队列中，前面取出，后面加入，将每一行节点加入到一维数组，然后再将遍历完一整行的一维数组加入到二维数组中，毕竟一维数组清空，继续存储下一行节点数据。

class Solution{
public:
	vector<vector<int>> levelOrder(TreeNode* root) {
		vector<vector<int>> res;
		if(root == nullptr) return res;
		queue<TreeNode*> queue;
		queue.push(root);
		vector<int> tmp;
		while(!queue.empty()){
			int n = queue.size();
			for(int i = 0; i < n; i++){
				TreeNode* p = queue.front();
				queue.pop();
				tmp.push_back(p->val);
				if(p->left) queue.push(p->left);
				if(p->right) queue.push(p->right);
			}
			res.push_back(tmp);
			tmp.clear();
		}
		return res;
	}
};

3、反转链表-2

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。
在这里插入图片描述笔记：使用三个节点：pre、cur、next，cur节点指向next的下一个节点，next指向cur(即pre的下一个节点)，pre指向next，然后依次轮询，得到反转。

class Solution{
public:
	ListNode* reverseBetween(ListNode* head, int left, int right) {
		ListNode* dummyHead = new ListNode(0);
		ListNode* pre = dummyHead;
		dummyHead->next = head;
		for(int i = 0; i < left - 1; i++)
			pre = pre->next;
		auto cur = pre->next;
		for(int i = 0; i < right - left; i++){
			auto next = cur->next;
			cur->next = next->next;
			next->next = pre->next;
			pre->next = next;
		}
		return dummyHead->next;
	}
};

4、搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值互不相同。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

class Solution{
public:
	int search(vector<int>& nums, int target) {
		if(nums.size() == 0 || target == nums[0]) return 0;
		int left = 0, right = nums.size() - 1;
		int mid = 0;
		while(left < right){
			int mid = (left + right) / 2;
			if(target == nums[left]) return left;
			if(target == nums[right]) return right;
			if(target == nums[mid]) return mid;
			if(nums[mid] > nums[left]){
				if(target > nums[mid])
					left = mid + 1;
				else{
					if(target > nums[left])
						right = mid - 1;
					else
						left = mid + 1;
				}
			}
			else{
				if(target > nums[mid]){
					if(target > nums[right])
						right = mid - 1;
					else	
						left = mid + 1;
				}
				else
					right = mid - 1;
			}
		}
		return -1;
	}
};