剑指 Offer 21-30

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

难度简单38收藏分享切换为英文关注反馈

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。

双指针

class Solution {
public:vector<int> exchange(vector<int>& nums) {int left=0;int right=nums.size()-1;//奇数在前，偶数在后while(left<right){if(left<right&&nums[left]%2==1) left++;if(left<right&&nums[right]%2==0) right--;swap(nums[left],nums[right]);}return nums;}
};

剑指 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 == nullptrp = 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->val<l2->val){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<TreeNode*> 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<TreeNode*> 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 <= 100
0 <= matrix[i].length <= 100

（这很简单吗，我以为中级模拟呢，PAT里中级模拟）

vector<int> spiralOrder(vector<vector<int>>& matrix) {vector<int> 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<sum){for(int i=m1;i<=m;i++){ans.push_back(matrix[n1][i]);cnt++;}n1++;if(cnt==sum) break;for(int i=n1;i<=n;i++){ans.push_back(matrix[i][m]);cnt++;}m--;if(cnt==sum) break;for(int i=m;i>=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<int> 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<int> 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();*/

剑指 Offer 21-30相关推荐

《LeetCode力扣练习》剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 Java
<LeetCode力扣练习>剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 Java 一.资源题目: 输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数在数组 ...
【LeetCode】剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
[LeetCode]剑指 Offer 21. 调整数组顺序使奇数位于偶数前面文章目录 [LeetCode]剑指 Offer 21. 调整数组顺序使奇数位于偶数前面一.双指针一.双指针解题思路: ...
剑指offer系列-30.包含min函数的栈
剑指offer系列第30题.包含min函数的栈题目描述: 定义栈的数据结构,请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中, 调用 min.push 及 pop 的时间复杂度都是 ...
【双100%解法】剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
立志用最少的代码做最高效的表达输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数位于数组的前半部分,所有偶数位于数组的后半部分. 示例: 输入:nums = [1,2,3,4] 输 ...
Leetcode 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 (每日一题 20210917)
输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数位于数组的前半部分,所有偶数位于数组的后半部分.示例:输入:nums = [1,2,3,4] 输出:[1,3,2,4] 注:[3,1 ...
剑指offer(21):栈的压入、弹出序列
输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否可能为该栈的弹出顺序.假设压入栈的所有数字均不相等.例如序列1,2,3,4,5是某栈的压入顺序,序列4,5,3,2,1是该压栈序列对应 ...
【算法】剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
文章目录 1.概述 2,双指针 1.概述输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数在数组的前半部分,所有偶数在数组的后半部分. 示例: 输入:nums = [1,2,3,4 ...
剑指offer——21.调整数组顺序使奇数位于偶数前面
题目: 输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变. 知识点: 保证相对位置 ...
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 (快速排序partion操作应用）
借助一个额外的空间,空间复杂度O(N), 时间复杂度O(1) 快速排序partion操作,空间O(1), 不稳定冒泡排序,O(n^2), 空间O(1) class Solution { publi ...
剑指Offer面试题解总结21-30
目录剑指Offer(21~30) 调整数组顺序使奇数位于偶数前面链表中倒数第k个节点反转链表合并两个有序的链表树的子结构二叉树的镜像对称的二叉树顺时针打印矩阵包含min函数的栈剑指 ...

剑指 Offer 21-30

剑指 Offer 21-30相关推荐

最新文章

热门文章