牛客 删除链表中的重复节点
题目描述
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
思路：
定义两个指针prev和last，比较last和last->next的值，不相等的话prev++ last++
如果两个值相等的话，那么只让last++
pre->next = last->next
PS：在访问链表的时候，要注意检查当前节点是不是空的
代码：
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
*/
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
if(nullptr == pHead){
return pHead;
}
//加头结点
ListNode *head = new ListNode(0);
head->next = pHead;
ListNode *prev = head;//初始化指向dummy head
ListNode *last = pHead;//初始化指向真正的头结点
while(last){
while(last->next != nullptr && last->val != last->next->val){
prev = prev->next;
last = last->next;
}
while(last->next != nullptr && last->val == last->next->val){
last = last->next;
}
//走到这里结果一共有三种,注意：prev永远指向的是前驱有效节点：
//1. last->next != nullptr 并且 (prev, last] 限定了一段重复范围，此时进行去重
//2. last->next == nullptr && (prev, last] 限定了一段重复范围，此时进行去重，最后相当于prev->next = nullptr
//3. last->next == nullptr && prev->next == last,这说明，从本次循环开始，大家都不相同，就不需要进行去重，这个是特殊情况
if(prev->next != last){
prev->next = last->next;
}
last = last->next;
}
return head->next;
}
};
牛客 包含min函数的栈
题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
思路：
用一个辅助栈，来保存当前栈中所有数的最小值。
在push操作的，minstack为空或者 value<minstack.top()，那么就将value放入minstack；否则将minstack.top()重复放入minstack。
代码：
class Solution {
stack<int> dataStack;
stack<int> minStack;
public:
void push(int value) {
if(minStack.empty() || value < minStack.top()){
minStack.push(value);
}
else{
minStack.push(minStack.top());
}
dataStack.push(value);
}
void pop() {
minStack.pop();
dataStack.pop();
}
int top() {
return dataStack.top();
}
int min() {
return minStack.top();
}
};
牛客 栈的压入、弹出序列
题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列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(pushV.empty() || popV.empty() || pushV.size() != popV.size())
return false;
stack<int> st;//辅助栈，帮助模拟入栈出栈
int i = 0,j = 0;
for(;i<pushV.size();++i){
st.push(pushV[i]);
//相等的话，表示要开始模拟出栈了
while(!st.empty() && st.top() == popV[j]){
//????
st.pop();
++j;
}
}
return st.empty();
}
};
牛客 从上往下打印二叉树
题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：
借助栈来实现BFS。PS：取完front之后要记得pop()
代码：
/*
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) {
queue<TreeNode*> que;
vector<int> ans;
if(nullptr == root)
return ans;
que.push(root);
while(!que.empty()){
TreeNode *temp = que.front();
que.pop();//你以为自己写的JAVA代码么？？？
ans.push_back(temp->val);
if(temp->left)
que.push(temp->left);
if(temp->right)
que.push(temp->right);
}
return ans;
}
};
牛客 二叉树后续遍历序列
题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
思路：
代码：
class Solution {
public:
bool helper(vector<int>& sequence, int start, int end){
if(start >= end)
return true;
int root = sequence[end];
int i = start;
while(i<end && sequence[i] < root)
++i;
for(int j=i;j<end;++j){
if(sequence[j] < root)
return false;
}
//判断左子树和右子树是否符合要求
return helper(sequence, 0, i-1) &&
helper(sequence, i, end-1);
}
bool VerifySquenceOfBST(vector<int> sequence) {
if(sequence.empty()){
return false;
}
return helper(sequence, 0, sequence.size()-1);
}
};