左神算法--二叉树最大深度

一、二叉树最大宽度

思路1：利用两个额外储存空间，一个是队列，一个是map
队列可以将二叉树按照宽度遍历，map用来记录每一个节点属于第几层，用于统计

思路2：只是使用一个queue，不使用map，换成使用两个节点来记录当前层最后一个节点和下一层最后一个节点。
下一层最后一个节点：可以由当前层最后压入的子节点来确定
当前层最后一个结点：可以当前层遍历完后，下一层更新为当前层时，将下一层的最后一个节点复制给当前层最后一个节点。
因此，只要将第一个头节点作为第一个压入节点，同时因为第一层只有一个节点，head也就是最后一个节点。这样就可以获得下一层的最后一个节点，再一次更新时，也可以获得当前层的最后一个节点
代码

#include<iostream>
#include<queue>
#include<map>
using namespace std;

struct Binode{
    int data;
    Binode * lchild;
    Binode * rchild;
};

int maxwidth(Binode * head)
{
    map<Binode *,int>nodeFloor;
    queue<Binode *>curNodes;
    nodeFloor.insert(make_pair(head,1));
    curNodes.push(head);
    int curFloor=1;
    int maxNum=0;
    int curFloorNum=0;
    while (!curNodes.empty())
    {
        Binode * cur=new Binode;
        cur=curNodes.front();
        curNodes.pop();
        if(curFloor==nodeFloor[cur])
        {
            curFloorNum++;
            if(maxNum<curFloorNum)
            {
                maxNum=curFloorNum;
            }
        }
        else
        {
            curFloorNum=1;
            curFloor++;
        }
        if(cur->lchild!=NULL)
        {
            curNodes.push(cur->lchild);
            nodeFloor.insert(make_pair(cur->lchild,curFloor+1));

        }
        if(cur->rchild!=NULL)
        {
            curNodes.push(cur->rchild);
            nodeFloor.insert(make_pair(cur->rchild,curFloor+1));
        }

    }
    return maxNum;
}

int withoutHashmap(Binode * head)
{
    int curNodeNum=0;
    int maxNum=0;
    Binode * curEnd=new Binode;
    Binode * nextEnd=new Binode;
    curEnd=head;
    queue<Binode *>curNodes;
    curNodes.push(head);
    while (!curNodes.empty())
    {
        Binode * cur=new Binode;
        cur=curNodes.front();
        curNodes.pop();
        if(cur->lchild!=NULL)
        {
            curNodes.push(cur->lchild);
            nextEnd=cur->lchild;
        }
        if(cur->rchild!=NULL)
        {
            curNodes.push(cur->rchild);
            nextEnd=cur->rchild;
        }
        if(cur!=curEnd)
        {
            curNodeNum++;
        }
        else
        {
            curNodeNum++;
            if(maxNum<curNodeNum)
            {
                maxNum=curNodeNum;
            }
            curNodeNum=0;
            curEnd=nextEnd;
            nextEnd=NULL;
        }
    }
    return maxNum;
}

int main()
{
    Binode * head=new Binode;
    Binode * node1=new Binode;
    Binode * node2=new Binode;
    Binode * node3=new Binode;
    Binode * node4=new Binode;
    Binode * node5=new Binode;
    Binode * node6=new Binode;
    head->data=1;
    node1->data=2;
    node2->data=3;
    node3->data=4;
    node4->data=5;
    node5->data=6;
    node6->data=7;
    head->lchild=node1;
    head->rchild=node2;
    node1->lchild=node3;
    node1->rchild=node4;
    node2->lchild=node5;
    node2->rchild=node6;

    int maxNum=maxwidth(head);
    cout<<"hashMap max width is : "<<maxNum<<endl;
    cout<<"not hashMap max width is : "<<withoutHashmap(head)<<endl;
    

    return 0;

}