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

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%。