刷题笔记-队列

最新推荐文章于 2023-03-20 09:43:03 发布

墨墨非鱼

最新推荐文章于 2023-03-20 09:43:03 发布

阅读量94

点赞数

分类专栏：数据结构算法

本文链接：https://blog.csdn.net/qq_36585574/article/details/106282266

版权

数据结构同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

算法

6 篇文章 0 订阅

订阅专栏

先祈祷一波
在这里插入图片描述

文章目录

1、二叉树的层序遍历
2、二叉树的层序遍历
3、二叉树的锯齿形层次遍历
4、二叉树的右视图
5、合并K个排序链表

队列
头文件

include<queue>

1、二叉树的层序遍历

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

示例：

二叉树：[3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]

遍历方法用一个队列来存储结点和层数。用的是广度优先遍历的思想。

上代码

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> > res;
        if(root==NULL)
            return res;
        queue<pair<TreeNode*,int> > q;
        q.push(make_pair(root,0));
        while(!q.empty())
        {
            TreeNode* node = q.front().first;  //获得队头的元素
            int level = q.front().second;
            q.pop();

            if(level==res.size())
                res.push_back(vector<int> ()); //拓展一行  level = size()-1
            res[level].push_back(node->val); //输入数据
            if(node->left)
            {
                q.push(make_pair(node->left,level+1));
            }
            if(node->right)
            {
                q.push(make_pair(node->right,level+1));
            }
            
        }

        return res;       
    }
};

另外一种方法就是一层一层遍历，队列存储的一层的结点。

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int> > ret;
        if(!root) return ret;

        queue <TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int currentLevelSize = q.size(); //就是这一层有多少个结点，一层一层
            ret.push_back(vector<int> ()); //一层
            for(int i = 1 ; i <=currentLevelSize; ++i)
            {
                auto node = q.front(); q.pop();
                ret.back().push_back(node->val);  
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
        }
        return ret;
    }
};

2、二叉树的层序遍历

Leetcode 107
【题目】
给定一个二叉树，返回其节点值自底向上的层次遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：

给定二叉树 [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其自底向上的层次遍历为：
[
[15,7],
[9,20],
[3]
]

就是前面的方法，然后最后reverse

上代码

/**
 * 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:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {

        //我投降了，原来是按之前的遍历顺序reverse一趟:)
        vector<vector<int>> res;
        if(root==NULL)
            return res;
        queue<TreeNode*> p;
        p.push(root);
        while(!p.empty())
        {
            int Length = p.size();

            res.push_back(vector<int> ());
            for(int i = 0 ; i< Length; i++)
            {
                auto cur = p.front();
                p.pop();
                res.back().push_back(cur->val);
                if(cur->left)
                {
                    p.push(cur->left);
                }
                if(cur->right)
                {
                    p.push(cur->right);
                }
            }

        }
        reverse(res.begin(),res.end());
        return res;
        
    }
};

3、二叉树的锯齿形层次遍历

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

例如：

给定二叉树 [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回锯齿形层次遍历如下：
[
[3],
[20,9],
[15,7]
]

我用队列，最终逃不过反转的命运，在遍历完一层后看是否要反转。

上代码

/**
 * 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:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int> > res;
        if(root==NULL)
        {
            return res;
        }
        

        queue <TreeNode*> q;
        q.push(root);
        int N =0 ;
        while(!q.empty())
        {
            int Length = q.size();
            N++;
            res.push_back(vector<int> ());
         
            for(int i = 0 ; i < Length; i++)
            {
                TreeNode* cur = q.front();
                q.pop();
                
                res.back().push_back(cur->val);
                if(cur->left)
                    q.push(cur->left);
                if(cur->right)
                    q.push(cur->right);
 
              
            }
            if(N%2==0)
            {
                reverse(res.back().begin(),res.back().end());
            }
            
        }
        return res;
    }
};

4、二叉树的右视图

Leetcode 199
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
1 <—
/
2 3 <—
\
5 4 <—

我的方法是用之前的队列的方法层序遍历整个二叉树，然后只记录最右边的数据。

/**
 * 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:
    vector<int> rightSideView(TreeNode* root) {
    vector<int> res;
    if(root==NULL)
    {
        return res;
    }
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty())
    {
        int length=q.size();

        int temp;
        for(int i = 0 ; i < length; i++)
        {
            TreeNode* cur = q.front();
            q.pop();
            temp=cur->val;
            if(cur->left)
                q.push(cur->left);
            if(cur->right)
                q.push(cur->right);
        }
        res.push_back(temp);


    }
    return res;

    }
};

5、合并K个排序链表

Leetcode 23
【题目】
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6

我用的优先队列，按照数值排序，进入优先队列，然后根据数值自动排序，最后把每个节点连接起来。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<pair<int,ListNode*>,vector<pair<int,ListNode*>>,greater<pair<int,ListNode*>>> pq;
        if(lists.size()==0)
        {
            return NULL;
        }
        int n = lists.size();
        for(int i = 0 ; i< n ; i++)
        {
            ListNode* cur=lists[i];
            while(cur!=NULL)
            {
                pq.push(make_pair(cur->val,cur));
                cur=cur->next;
            }
        }

        if(pq.size()==0)
            return NULL;
        ListNode*res;
        ListNode*p;
        p=pq.top().second;
        res=p;
        pq.pop();
       while(!pq.empty())
        {
            p->next=pq.top().second;
            pq.pop();
            p=p->next;
        }
        return res;
        
    }
};