【done】剑指offer——面试题23：从上往下打印二叉树

力扣，https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/description/

BFS，使用Queue

java中queue常用知识点：https://www.jianshu.com/p/82696b0f222c

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int[] decorateRecord(TreeNode root) {
        if (root == null) {
            return new int[0];
        }
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while (q.size() > 0) {
            TreeNode topNode = q.poll();
            res.add(topNode.val);
            if (topNode.left != null) {
                q.offer(topNode.left);
            }
            if (topNode.right != null) {
                q.offer(topNode.right);
            }
        }

        int[] resArray = new int[res.size()];
        for (int i = 0; i < res.size(); ++i) {
            resArray[i] = res.get(i);
        }

        return resArray;
    }
}

Solution1：

典型的BFS算法！
思路一开始没想到，按照书上的思路写的答案。。。
注意：deque是双向队列，在头尾插入都很快！

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        deque<TreeNode*> deque;
        deque.push_back(root);
        while(!deque.empty()){
            int a = deque.front()->val;
            res.push_back(a);
            if(deque.front()->left != NULL)
                deque.push_back(deque.front()->left);
            if(deque.front()->right != NULL)
                deque.push_back(deque.front()->right);
            deque.pop_front();
        }
        return res;
    }
};

##双向队列queue的常用函数

deque<int> que; //定义了一个整型的双端队列;
que.front(); //返回容器que的第一个元素的引用。如果que为空，则该操作为空。
que.pop_back(); //删除最后一个数据。
que.pop_front(); //删除头部数据。
que.push_back(elem); //在尾部加入一个数据。
que.push_front(elem); //在头部插入一个数据。

##Solution2：
2018年9月1日重做，利用队列做就行queue

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x):
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        if (root == NULL)
            return res;
        queue<TreeNode* > tree_queue;
        tree_queue.push(root);
        while (!tree_queue.empty()) {
            int temp = tree_queue.front()->val;
            res.push_back(temp);
            if (tree_queue.front()->left)
                tree_queue.push(tree_queue.front()->left);
            if (tree_queue.front()->right)
                tree_queue.push(tree_queue.front()->right);
            tree_queue.pop();
        }
        return res;
    }
};

##队列queue的常用函数

queue<int> que; //定义了一个整型的双端队列
que.front(); //返回容器que的头部元素
que.pop(); //删除头部数据
que.push(elem) //在尾部加入一个数据
/*和栈stack的成员函数差不多*/