剑指 Offer 21-30
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
难度简单38收藏分享切换为英文关注反馈
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
示例：
输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。双指针
class Solution {
public:
vector exchange(vector& nums) {
int left=0;
int right=nums.size()-1;
//奇数在前，偶数在后
while(left 剑指 Offer 22. 链表中倒数第k个节点
难度简单70收藏分享切换为英文关注反馈
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/solution/yi-wen-gao-ding-chang-jian-de-lian-biao-wen-ti-h-3/ 作者：Time-Limit
面试问题总结
无法高效获取长度，无法根据偏移快速访问元素，是链表的两个劣势。然而面试的时候经常碰见诸如获取倒数第k个元素，获取中间位置的元素，判断链表是否存在环，判断环的长度等和长度与位置有关的问题。这些问题都可以通过灵活运用双指针来解决。
先来看"倒数第k个元素的问题"。设有两个指针 p 和 q，初始时均指向头结点。首先，先让 p 沿着 next 移动 k 次。此时，p 指向第 k+1个结点，q 指向头节点，两个指针的距离为 k 。然后，同时移动 p 和 q，直到 p 指向空，此时 p 即指向倒数第 k 个结点。可以参考下图来理解：
class Solution {
public:
ListNode* getKthFromEnd(ListNode* head, int k) {
ListNode *p = head, *q = head; //初始化
while(k--) { //将 p指针移动 k 次
p = p->next;
}
while(p != nullptr) {//同时移动，直到 p == nullptr
p = p->next;
q = q->next;
}
return q;
}
};
获取中间元素的问题。设有两个指针 fast 和 slow，初始时指向头节点。每次移动时，fast向后走两次，slow向后走一次，直到 fast 无法向后走两次。这使得在每轮移动之后。fast 和 slow 的距离就会增加一。设链表有 n 个元素，那么最多移动 n/2 轮。当 n 为奇数时，slow 恰好指向中间结点，当 n 为 偶数时，slow 恰好指向中间两个结点的靠前一个(可以考虑下如何使其指向后一个结点呢？)。
下述代码实现了 n 为偶数时慢指针指向靠后结点
class Solution {
public:
ListNode* middleNode(ListNode* head) {
ListNode *p = head, *q = head;
while(q != nullptr && q->next != nullptr) {
p = p->next;
q = q->next->next;
}
return p;
}
};
总结快慢指针的特性 —— 每轮移动之后两者的距离会加一。
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode *slow = head;
ListNode *fast = head;
while(fast != nullptr) {
fast = fast->next;
if(fast != nullptr) {
fast = fast->next;
}
if(fast == slow) {
return true;
}
slow = slow->next;
}
return nullptr;
}
};如果存在环，如何判断环的长度呢？方法是，快慢指针相遇后继续移动，直到第二次相遇。
剑指 Offer 24. 反转链表
难度简单82
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
限制：
0 <= 节点个数 <= 5000
反转链表有很多，可以再记哦。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
/*
if(head==NULL) return head;
ListNode* cur=head;
ListNode* pre=NULL;
while(cur!=NULL){
ListNode* next=cur->next;
cur->next=pre;
pre=cur;
cur=next;
}
return pre;
*/
if(head==NULL) return head;
if(head->next == NULL) return head;
ListNode* last = reverseList(head->next);
head->next->next = head;
head->next = NULL;
return last;
}
};剑指 Offer 25. 合并两个排序的链表
难度简单39
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1：
输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
限制：
0 <= 链表长度 <= 1000
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* l3=new ListNode(0);
ListNode* ans=l3;
while(l1!=NULL||l2!=NULL){
if(l1!=NULL&&l2!=NULL){
if(l1->valval){
l3->next=l1;
l1=l1->next;
}else{
l3->next=l2;
l2=l2->next;
}
}else if(l1!=NULL){
l3->next=l1;
l1=NULL;
}else{
l3->next=l2;
l2=NULL;
}
l3=l3->next;
}
return ans->next;
}
}; 剑指 Offer 26. 树的子结构
难度中等93
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。
例如:
给定的树 A:
3
/ \
4 5
/ \
1 2
给定的树 B：
4
/
1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。
示例 1：
输入：A = [1,2,3], B = [3,1] 输出：false
示例 2：
输入：A = [3,4,5,1,2], B = [4,1] 输出：true
限制：
0 <= 节点个数 <= 10000
匹配类二叉树题目总结
面试题 04.10. 检查子树
求解思路可以分解为以下两步：
-
匹配根节点：首先在
A中找到与B的根节点匹配的节点C； -
匹配其他节点：验证
C的子树与B的子树是否匹配。
dfs 函数将注意力集中在了根节点已经匹配的情况。当从根节点同时开始向下遍历时
现在将视野放远来看，主函数则解决了如何确定 A 的哪个节点是 B 的根节点。
//注意此处说了空树不是子结构。
class Solution {
public:
//遍历结点...
bool sameRootSub(TreeNode* t1,TreeNode* t2){
if(t2==NULL) return true;
if(t1==NULL) return false;
return t1->val==t2->val&&sameRootSub(t1->left,t2->left)&&sameRootSub(t1->right,t2->right);
}
bool isSubStructure(TreeNode* A, TreeNode* B) {
if (A==NULL) return false;
if(B==NULL) return false;
return sameRootSub(A,B)||isSubStructure(A->left,B)||isSubStructure(A->right,B);
}
};剑指 Offer 27. 二叉树的镜像
难度简单49收藏分享切换为英文关注反馈
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
例如输入：
4
/ \
2 7
/ \ / \
1 3 6 9
镜像输出：
4
/ \
7 2
/ \ / \
9 6 3 1
示例 1：
输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1]
限制：
0 <= 节点个数 <= 1000
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* mirrorTree(TreeNode* root) {
if(root==NULL) return NULL;
if(root->left==NULL&&root->right==NULL) return root;
swap(root->left,root->right);
mirrorTree(root->left);
mirrorTree(root->right);
return root;
}
};//或者用栈做or用队列做
TreeNode* mirrorTree(TreeNode* root) {
if(root==NULL) return root;
queue q;
q.push(root);
while(!q.empty()){
TreeNode* now=q.front();q.pop();
if(now->left!=NULL) q.push(now->left);
if(now->right!=NULL) q.push(now->right);
swap(now->left,now->right);
}
return root;
} 剑指 Offer 28. 对称的二叉树
难度简单65收藏分享切换为英文关注反馈
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3
示例 1：
输入：root = [1,2,2,3,4,4,3] 输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3] 输出：false
class Solution {
public:
bool isSame(TreeNode* root1,TreeNode* root2){
if(root1==NULL&&root2==NULL) return true;
else if(root1==NULL||root2==NULL) return false;
else if(root1->val!=root2->val) return false;
return isSame(root1->right,root2->left)&&isSame(root1->left,root2->right);
}
bool isSymmetric(TreeNode* root) {
if(root==NULL) return true;
else return isSame(root->left,root->right);
}
利用队列进行迭代。队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像。最初，队列中包含的是 root->left 以及 root->right。该算法的工作原理类似于 BFS，但存在一些关键差异。每次提取两个结点并比较它们的值。然后，将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。
作者：bryceustc
链接：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof/solution/cyu-pythonliang-chong-jie-fa-shi-xian-di-gui-yu-di/
bool isSymmetric(TreeNode* root) {
if(root==NULL) return true;
// else return isSame(root->left,root->right);
queue q;
q.push(root->left);
q.push(root->right);
while(!q.empty()){
TreeNode* a=q.front();q.pop();
TreeNode* b=q.front();q.pop();
if(a==NULL&&b!=NULL||a!=NULL&&b==NULL) return false;
if(a!=NULL&&b!=NULL&&a->val!=b->val) return false;
if(a!=NULL&&b!=NULL){
q.push(a->left);q.push(b->right);
q.push(b->left);q.push(a->right);
}
}
return true;
} 剑指 Offer 29. 顺时针打印矩阵
难度简单124收藏分享切换为英文关注反馈
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]] 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
限制：
0 <= matrix.length <= 1000 <= matrix[i].length <= 100
（这很简单吗，我以为中级模拟呢，PAT里中级模拟）
vector spiralOrder(vector>& matrix) {
vector ans;
if(matrix.size()==0) return ans;
int x=0,y=0;
int n=matrix.size()-1,m=matrix[0].size()-1;
int n1=0,m1=0;
int cnt=0;
int sum=(n+1)*(m+1);
while(cnt=m1;i--){
ans.push_back(matrix[n][i]);cnt++;
}
n--;
if(cnt==sum) break;
for(int i=n;i>=n1;i--){
ans.push_back(matrix[i][m1]);cnt++;
}
m1++;
if(cnt==sum) break;
}
return ans;
} 剑指 Offer 30. 包含min函数的栈
难度简单36
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。
示例:
MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); minStack.push(-3); minStack.min(); --> 返回 -3. minStack.pop(); minStack.top(); --> 返回 0. minStack.min(); --> 返回 -2.
提示：
- 各函数的调用总次数不超过 20000 次
class MinStack {
public:
/** initialize your data structure here. */
stack data,fu;
MinStack() {
fu.push(INT_MAX);
}
void push(int x) {
data.push(x);
if(fu.top()>x){
fu.push(x);
}else fu.push(fu.top());
}
void pop() {
data.pop();fu.pop();
}
int top() {
return data.top();
}
int min() {
return fu.top();
}
};
/**
* Your MinStack object will be instantiated and called as such:
* MinStack* obj = new MinStack();
* obj->push(x);
* obj->pop();
* int param_3 = obj->top();
* int param_4 = obj->min();
*/ 解决方案
WHEN PUSH：保存最小值信息。每次 push 都将当前值与 minVal 比较，若不大于，则首先将 minVal 入栈，然后 push；否则，直接 push.
需要取不大于，而不是小于，是由第 2 点决定的
WHEN POP：回溯最小值信息。每次 pop 都将返回值与 minVal 比较，若等于则再次 pop，这时的值为最小值的回溯值（回溯值可能与 minVal 相等），将 minVal 更新为该值.
作者：xi-lin
链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof/solution/shuang-zhan-orzeng-qiang-xing-dan-zhan-by-xi-lin/
如果当前压入的值比当前最小值小，则压入一个当前最小值，再压入当前的值！
class MinStack {
public:
/** initialize your data structure here. */
stack data;
int minx=INT_MAX;
MinStack() {
}
void push(int x) {
//请注意是小于等于。
if(x<=minx){
data.push(minx);
minx=x;
}
data.push(x);
}
void pop() {
if(data.top()==minx){
data.pop();
minx=data.top();
}
data.pop();
}
int top() {
return data.top();
}
int min() {
return minx;
}
};
/**
* Your MinStack object will be instantiated and called as such:
* MinStack* obj = new MinStack();
* obj->push(x);
* obj->pop();
* int param_3 = obj->top();
* int param_4 = obj->min();
*/