leetCode算法题刷题思路——持续更新

最新推荐文章于 2024-07-10 16:47:58 发布

问号小朋友

最新推荐文章于 2024-07-10 16:47:58 发布

阅读量206

点赞数 1

分类专栏： leedCode刷题文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/qq_48201696/article/details/117203928

版权

leedCode刷题专栏收录该内容

2 篇文章 0 订阅

订阅专栏

leedcode算法题刷题思路

23.合并k个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路
while(k个链表中至少有一个不为nullptr){
 for(遍历这k个链表){
     找到那个值最小的当前结点
 }
 采用尾插法插入到目标链表中
 当前值最小结点后移一位
}
输入目标链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *p1,*p2,*p3;
        int i,temp = 0;
        p1 = nullptr;
        while(isCorr(lists)){
            for(i=0;i<lists.size();i++){
                if(lists[temp]!=nullptr&&lists[i]!=nullptr){
                    temp = (lists[temp]->val<lists[i]->val)?temp:i;
                }
                if(lists[temp]==nullptr&&lists[i]!=nullptr){
                    temp = i;
                }
            }
            p3 = new ListNode(lists[temp]->val);
            if(p1==nullptr){
                p1 = p3;
                p2 = p1;
            }else{
                p2->next = p3;
                p2 = p3;
            }
            lists[temp] = lists[temp]->next;
        }
        p2 = nullptr;
        p3 = nullptr;
        return p1;
    }

    bool isCorr(vector<ListNode*> &lists) const{
        if(lists.size()==0)
            return false;
        int i = 0;
        bool aim = false;
        for(;i<lists.size();i++){
            if(lists[i]!=nullptr){
                aim = true;
                break;
            }
        }
        return aim;
    }
};

25.k个一组翻转链表

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

你可以设计一个只使用常数额外空间的算法来解决此问题吗？

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

实例

思路

while(链表不为空){
    while(链表不为空&&i<k){
        将链表结点放入一个容器中
        链表后移
        i++;
    }
    if(i==k){ //即表示后面还有三个甚至三个以上的结点，可以进行翻转操作
        j = 容器的初始，s = 容器的末尾位置
        while(j<s){
            交换值
        }
        清空容器
    }
    i=0;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
 #include<vector>
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(head==nullptr)
            return nullptr;
        ListNode* p;
        p = head;
        int i=0,j,s,val;
        vector<ListNode*> temp;
        while(p!=nullptr){
            while(p!=nullptr&&i<k){
                temp.push_back(p);
                p = p->next;
                i++;
            }
            if(i==k){
                //交换结点的值
                j = 0;s = temp.size()-1;
                while(j<s){
                    val = temp[j]->val;
                    temp[j]->val = temp[s]->val;
                    temp[s]->val = val;
                    j++;
                    s--;
                }
                temp.clear();
            }
            i=0;
        }
        p = nullptr;
        return head;
    }
};

102.二叉树的层序遍历

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。（即逐层地，从左到右访问所有节点）。

示例

示例：
二叉树：[3,9,20,null,null,15,7],

3

/
9 20
/
15 7
返回其层序遍历结果：

[
[3],
[9,20],
[15,7]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

采用二叉树的层序遍历来输出二叉树的结点，可以采用双重嵌套循环，在子嵌套循环中，每经历一次子循环，队列中就有了这一层的所有结点，然后拿到一个len（队列的长度），循环这么多次，依次出队，然后返回最外围循环，直到队列为空

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 #include<list>
 using namespace std;
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if(root == nullptr){
            return result;
        }
        list<TreeNode*> queue;
        vector<int> temp;
        TreeNode *b = root;
        queue.push_back(b); 
        int i,len;
        while(!queue.empty()){
            i = 0;
            len = queue.size(); //len是队列中这一层的结点数，也就代表着下一个子循环遍历这么多次
            temp.clear(); //清空vector
            while(i<len&&!queue.empty()){
                b = queue.front();
                queue.pop_front();
                temp.push_back(b->val);
                if(b->left!=nullptr){
                    queue.push_back(b->left);
                }
                if(b->right!=nullptr){
                    queue.push_back(b->right);
                }
                i++;
            }
            result.push_back(temp);
        }
        return result;
    }
};

103.锯齿形二叉树

给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

思路

这题其实跟层序遍上面那一题没有什么太大的区别，只是在vector添加值的时候，奇数层用尾插法，偶数层用头插法,这边我的算法实现用到了STL里面的双向链表和构造器

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if(root == nullptr){
            return result;
        }
        list<TreeNode*> queue;
        vector<int> *temps;
        list<int> temp;
        TreeNode *b = root;
        queue.push_back(b);
        int i,len,j = 1;
        while(!queue.empty()){
            i = 0;
            len = queue.size();
            temp.clear();
            while(i<len&&!queue.empty()){
                b = queue.front();
                queue.pop_front();
                if(j%2!=0){
                    temp.push_back(b->val); //根据奇偶数层，来选择头插法还是尾插法
                }
                else{
                    temp.push_front(b->val);
                }
                if(b->left!=nullptr){
                    queue.push_back(b->left);
                }
                if(b->right!=nullptr){
                    queue.push_back(b->right);
                }
                i++;
            }
            j = (j+1)%2; //更改层的奇偶特性
            temps = new vector<int>(temp.begin(),temp.end()); //使用SLT里面的迭代器构造vector
            result.push_back(*temps);
        }
        return result;
    }
};

101.对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

思路

对于这题，可以从中分析出它的递归模型，当根节点为空时，树一定是对称的，他的递归模型为
$\begin{cases} true--p为nullptr\\false--p->left!=p->right\\f(left->right,right->left)\&\&f(left->left,right->right)\end{cases}$

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr)
            return true;
        bool isMorr = isMirror(root->left,root->right);
        return isMorr;
    }

    bool isMirror(TreeNode* left,TreeNode *right){
        if(left==nullptr&&right==nullptr)
            return true;
        if((left==nullptr&&right!=nullptr)||(right==nullptr&&left!=nullptr))
            return false;
        if(left->val!=right->val)
            return false;
        return isMirror(left->right,right->left)&&isMirror(left->left,right->right);
    }
};

100.相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

这题十分简单，直接用中序，先序，后序，层序中的任意一种就行

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p==nullptr&&q==nullptr)
            return true;
        if(p!=nullptr&&q!=nullptr){
            if(p->val!=q->val)
                return false;
            return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
        }
        return false;
    }
};

问号小朋友

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetCode算法题刷题思路——持续更新

leedcode算法题刷题思路23.合并k个升序链表给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。示例输入：lists = [[1,4,5],[1,3,4],[2,6]]输出：[1,1,2,3,4,4,5,6]解释：链表数组如下：[1->4->5,1->3->4,2->6]将它们合并到一个有序链表中得到。1->1->2->3->4->4->5->6来源：
复制链接

扫一扫