剑指 Offer 21-30

神秘的义勇神驹

于 2020-08-12 16:30:02 发布

阅读量111

点赞数

分类专栏： LeetCode面试题

本文链接：https://blog.csdn.net/qq_42671442/article/details/107947262

版权

LeetCode面试题专栏收录该内容

25 篇文章 0 订阅

订阅专栏

剑指 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 个结点。可以参考下图来理解：

移动过程中保持距离为 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->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();
 */

神秘的义勇神驹

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指 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&gt..
复制链接

扫一扫

专栏目录