Rrui的Leetcode算法刷题笔记（九）

Rrui_739

于 2018-11-27 16:55:41 发布

阅读量281

点赞数

CC 4.0 BY-SA版权

分类专栏：程序

本文链接：https://blog.youkuaiyun.com/Rrui7739/article/details/84563790

程序专栏收录该内容

9 篇文章

订阅专栏

本文解析了四道LeetCode算法题目，包括构建四叉树、N叉树的层序遍历、链表的扁平化。通过递归和迭代方法解决复杂的数据结构问题，展示了如何处理树和链表的遍历与构建。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

427. Construct Quad Tree

/*
// Definition for a QuadTree node.
class Node {
public:
    bool val;
    bool isLeaf;
    Node* topLeft;
    Node* topRight;
    Node* bottomLeft;
    Node* bottomRight;

    Node() {}

    Node(bool _val, bool _isLeaf, Node* _topLeft, Node* _topRight, Node* _bottomLeft, Node* _bottomRight) {
        val = _val;
        isLeaf = _isLeaf;
        topLeft = _topLeft;
        topRight = _topRight;
        bottomLeft = _bottomLeft;
        bottomRight = _bottomRight;
    }
};
*/
class Solution {
public:
    Node* construct(vector<vector<int>>& grid) {
        
        return tree(grid,0,grid.size(),0,grid.size());
    }
    
    Node* tree(vector<vector<int>>& grid,int hangl,int hangr,int liel,int lier)
    {
        Node* head=new Node();
                
        if(grid.size()==0)
            return head;
        
        if(hangr-hangl==1)
        {
            head->val=grid[hangl][liel];
            head->isLeaf=true;
            head->topLeft=NULL;
            head->topRight=NULL;    
            head->bottomLeft=NULL;
            head->bottomRight=NULL;             //一定要初始化指针，防止野指针
            return head;
        }
        
        head->topLeft=tree(grid,hangl,(hangr+hangl)/2,liel,(lier+liel)/2);
        head->topRight=tree(grid,hangl,(hangr+hangl)/2,(lier+liel)/2,lier);
        head->bottomLeft=tree(grid,(hangr+hangl)/2,hangr,liel,(lier+liel)/2);
        head->bottomRight=tree(grid,(hangr+hangl)/2,hangr,(lier+liel)/2,lier);
        
        if(head->topLeft->isLeaf&&head->topRight->isLeaf&&head->bottomLeft->isLeaf&&head->bottomRight->isLeaf&&head->topLeft->val==head->topRight->val&&head->topLeft->val==head->bottomLeft->val&&head->topLeft->val==head->bottomRight->val)
        {
            head->val=head->topLeft->val;
            head->isLeaf=true;
            head->topLeft=NULL;
            head->topRight=NULL;    
            head->bottomLeft=NULL;
            head->bottomRight=NULL;    
        }
        else
        {
            head->val=true;
            head->isLeaf=false;            
        }
        return head; 
    }
};

注：简单题，但是这道题让我见识到了野指针的威力，尤其需要注意的是node类内声明了四个指针却没有初始化，如果在代码内不初始化这四个野指针那测试代码的时候会得到致命的错误，本题尤其感谢 @leetcode都是水题的小白二号二哥帮我debug，这一道看似简单的递归题换了我一天的时间。faster than 22.51%。

429. N-ary Tree Level Order Traversal

/*
// Definition for a Node.
class Node {
public:
    int val = NULL;
    vector<Node*> children;

    Node() {}

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        
        vector<int> a;
        vector<vector<int>> b;
        queue<Node*> q;
        
        if(!root)
            return b;
        q.push(root);
        while(!q.empty())
        {
            int size=q.size();
            vector<Node*> p;
            for(int i=0;i<size;i++)
            {
                a.push_back(q.front()->val);
                p=q.front()->children;
                for(int j=0;j<p.size();j++)
                    q.push(p[j]);
                q.pop();
            }            
            b.push_back(a);
            a.clear();
        }
        return b; 
    }
};

注：简单题，跟二叉树层序遍历没有本质区别，唯一的区别就是需要遍历它的子树vector。faster than 98.66%。

/*
// Definition for a Node.
class Node {
public:
    int val = NULL;
    Node* prev = NULL;
    Node* next = NULL;
    Node* child = NULL;

    Node() {}

    Node(int _val, Node* _prev, Node* _next, Node* _child) {
        val = _val;
        prev = _prev;
        next = _next;
        child = _child;
    }
};
*/
class Solution {
public:
    Node* flatten(Node* head) {
        
        Node *p= head;
        while(p)
        {
            Node *q;
            if(p->child)
            {
                q=p->next;
                Node *m=flatten(p->child); 
                p->child=NULL;
                p->next=m;
                m->prev=p;
                while(m->next)
                    m=m->next;
                m->next=q;
                if(q)
                    q->prev=m;
            }
            p=p->next; 
        }
         return head;   
    }
};

注：中等题，这种题直接递归再拼接链表即可，没什么难度，最快的算法是迭代，但是递归更容易想到。faster than 16.04%。