1.包含min函数的栈
时间限制：1秒 空间限制：32768K 热度指数：177188
本题知识点： 栈
题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
解题思路：
- 如果我们只有一个栈，在栈里添加一个成员变量存放最小元素是不够的，为什么呢？
- 因为如果当前最小的元素被弹出栈顶了，那么如何获得下一个最小的元素呢？
- 所以我们需要在压入最小的元素之前将次小的元素保存起来，可以添加一个辅助栈
- {3,4,2,1,0}， 往空的数据栈里压入3，显然现在3是最小值，将这个最小值也压入辅助栈里；然后压入4，辅助栈压入3；压入2，辅助栈压入2，依次下去
- 当最小元素压入辅助栈里，就可以保证辅助栈的栈顶一直都是最小的元素
- 当栈顶的元素被弹出，同时弹出辅助栈的最小元素，辅助栈的新栈顶就是下一个最小值
class Solution {
public:
void push(int value) {
StackData.push(value);
if(StackMin.empty())
StackMin.push(value);
else if(StackMin.top() < value)
StackMin.push(StackMin.top());
else
StackMin.push(value);
}
void pop() {
if(!StackData.empty())
{
StackData.pop();
StackMin.pop();
}
}
int top() {
return StackData.top();
}
int min() {
return StackMin.top();
}
private:
stack<int> StackData;
stack<int> StackMin;
};2.栈的压入、弹出序列
时间限制：1秒 空间限制：32768K 热度指数：212288
本题知识点： 栈
题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
解题思路：
总结：
- 如果下一个弹出的数字刚好是下一个弹出的栈顶数字，就直接弹出；如果下一个弹出的数字不在栈顶，就把压栈序列中还没有入栈的数字压入栈里面，直到把下一个需要弹出的数字压入栈顶为止
- 如果所有的数字都压入栈后，仍然没有找到下一个弹出的数字，那么该序列就不可能是一个弹出序列
class Solution {
public:
bool IsPopOrder(vector<int> pushV,vector<int> popV) {
if(popV.empty())
return false;
int len = pushV.size();
int i=0,j=0;
stack<int> s;
s.push(pushV[0]);
while(i <len && j< len){
if(s.top()!=popV[j]){
s.push(pushV[++i]);
}else{
s.pop();
j++;
}
}
if(s.empty())
return true;
return false;
}
};3.从上往下打印二叉树
时间限制：1秒 空间限制：32768K 热度指数：222428
题目描述从上往下打印出二叉树的每个节点，同层节点从左至右打印。
解题思路：
- 本题实质上是考树的遍历算法，是层序遍历
- 每次打印一个节点的时候，如果该节点有子结点，就把该节点的子节点入到一个队列的末尾
- 然后队列的头部是最早进入队列的结点，将它取出来
- 重复打印操作即可，直到队列中的所有节点都被打印出来
/*
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> result; //存放最后的数组
result.clear(); //将数组先清空
queue<TreeNode*> tree_queue;
if(NULL != root){
tree_queue.push(root);
}
while(!tree_queue.empty())
{
if(tree_queue.front()->left != NULL)
{
tree_queue.push(tree_queue.front()->left);
}
if(tree_queue.front()->right != NULL)
{
tree_queue.push(tree_queue.front()->right);
}
result.push_back(tree_queue.front()->val);
tree_queue.pop();
}
return result;
}
};4.二叉搜索树的后序遍历序列
时间限制：1秒 空间限制：32768K 热度指数：250141
题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
解题思路：
- 以{5,7,6,9,11,10,8}为例，我们知道后序遍历中的根节点位于数组的最后一个，所以在数组中的根节点8前面的是它的左右子树序列
- 二叉搜索树的左子树的结点都小于根节点的值，右子树的结点的值都大于根节点的值
- 所以数组中的5,7,6是根节点8的左子树；9,11，10是根节点8的右子树
- 左子树中的根结点和8是一样的规律，左子树中的根节点6,左子树5小于6，右子树7大于6，符合规律
- 右子树中的根节点10，左子树9小于10，右子树11大于10，符合规律
- 可以采用递归实现
class Solution {
public:
bool VerifySquenceOfBST(vector<int> sequence) {
int len=sequence.size();
if(len<=0)
return false;
//找到根节点，为最后一个元素
int root=sequence[len-1];
//找左子树，小于根节点
int i=0;
vector<int> sequenceleft;
for(; i<len-1; ++i) {
if(sequence[i] > root)
break;
sequenceleft.push_back(sequence[i]);
}
//找右子树，大于根节点，有小于根节点的那么false
int j=i;
vector<int> sequenceright;
for(;j<len-1; ++j) {
if(sequence[j]<root) return false;
sequenceright.push_back(sequence[j]);
}
//判断左右子树是不是二叉搜索树
bool left=true;
if(i>0)
left=VerifySquenceOfBST(sequenceleft);
bool right=true;
if(i<len-1)
right=VerifySquenceOfBST(sequenceright);
if(left && right){
cout<<"Yes"<<endl;
return true;
}
else {
cout<<"No"<<endl;
return false;
}
}
};5.二叉树中和为某一值得路径
解题思路：
- 由于路径总是从根节点开始遍历，而前中后三种遍历方式中只有前序遍历是从根结点开始的，所以按照前序遍历的方式
- 由于没有指向父节点的指针，所以我们还需要将当前节点的上一个节点保存起来，每访问一个节点，都把当前节点添加到路径中去
- 当达到节点5的时候，路径中包含结点10和结点5，然后遍历到节点4，将其也添加到路径中去，这时已经到达叶子结点，但是值不等于22，所以不是我们要找的路径
- 这时候我们回到节点5，要去遍历5的右结点7，此时要删除结点4，将7添加到路径中去，值为22，使我们要找的路径
- 再次回到节点5，删除节点7； 再接着回到节点10， 删除节点5； 将12添加到路径中去，符合要求
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回二维列表，内部每个列表表示找到的路径
def FindPath(self, root, expectNumber):
# write code here
if not root:
return []
if root and not root.left and not root.right and root.val == expectNumber:
return [[root.val]]
result = []
left = self.FindPath(root.left, expectNumber-root.val)
right = self.FindPath(root.right, expectNumber-root.val)
for i in left + right:
result.append([root.val] + i)
return result
6.复杂链表的复制
时间限制：1秒 空间限制：32768K 热度指数：221374
本题知识点： 链表
题目描述
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
/*
struct RandomListNode {
int label;
struct RandomListNode *next, *random;
RandomListNode(int x) :
label(x), next(NULL), random(NULL) {
}
};
*/
class Solution {
public:
//1. 复制原始链表的任一节点N并创建新节点N'，再把N'链接到N的后边
void CloneNodes(RandomListNode* pHead)
{
RandomListNode* pNode=pHead;
while(pNode!=NULL)
{
RandomListNode* pCloned=new RandomListNode(0);
pCloned->label=pNode->label;
pCloned->next=pNode->next;
pCloned->random=NULL;
pNode->next=pCloned;
pNode=pCloned->next;
}
}
//2. 如果原始链表上的节点N的random指向S，则对应的复制节点N'的random指向S的下一个节点S'
void ConnectRandomNodes(RandomListNode* pHead)
{
RandomListNode* pNode=pHead;
while(pNode!=NULL)
{
RandomListNode* pCloned=pNode->next;
if(pNode->random!=NULL)
pCloned->random=pNode->random->next;
pNode=pCloned->next;
}
}
//3. 把得到的链表拆成两个链表，奇数位置上的结点组成原始链表，偶数位置上的结点组成复制出来的链表
RandomListNode* ReConnectNodes(RandomListNode* pHead)
{
RandomListNode* pNode=pHead;
RandomListNode* pClonedHead=NULL;
RandomListNode* pClonedNode=NULL;
//初始化
if(pNode!=NULL)
{
pClonedHead=pClonedNode=pNode->next;
pNode->next=pClonedNode->next;
pNode=pNode->next;
}
//循环
while(pNode!=NULL)
{
pClonedNode->next=pNode->next;
pClonedNode=pClonedNode->next;
pNode->next=pClonedNode->next;
pNode=pNode->next;
}
return pClonedHead;
}
//4. 三步合一
RandomListNode* Clone(RandomListNode* pHead)
{
CloneNodes(pHead);
ConnectRandomNodes(pHead);
return ReConnectNodes(pHead);
}
};
225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
