leetcode--第5章--树-5.1二叉树的遍历--5.1.1 binary tree preorder traversal

最新推荐文章于 2020-03-25 12:11:03 发布

qq_28088259

最新推荐文章于 2020-03-25 12:11:03 发布

阅读量355

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/qq_28088259/article/details/76301823

版权

leetcode 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

排序算法专栏可参考：

http://blog.csdn.net/column/details/15766.html

树及二叉树的基础知识补充：

数据结构、算法与应用 C++语言描述 P270

问题描述：

Given a binary tree, return the preorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

return [1,2,3].

Note: Recursive（递归） solution is trivial, could you do it iteratively（迭代）?

问题一：递归迭代

递归：

#include <iostream>
using namespace std;

void Recursion(int depth){
cout << "抱着"<<endl;
if (!depth) cout<<"我的小鲤鱼"<<endl;
else Recursion(--depth);
cout << "的我" << endl;
}

int main(){
cout << "吓得我抱起了" << endl;
Recursion(2);
putchar('\n');
}

迭代：

「递归」和「迭代」有哪些区别？

// 迭代，重复一定的算法，达到想要的目的。

//递归，自身调用自身的迭代就是递归。

问题二 如何初始化二叉树？

问题：

给定二叉树的初始化数据，怎样动态建立一个二叉树呢？

比如我们给定这样的一组数据：{ 1, 2, 3, 4, 0, 5, 6, 0, 7 }（假设0代表空），则我们构建的二叉树是这样的:

思路分析：

我们可以使用一个队列，队首出一个元素，队尾进两个元素，而这两个元素正好是这个队首元素的左右节点。

----这种 利用队列的方法初始化二叉树的方法 没毛病！

#pragma once 的具体作用

1、编译器预编译命令
2、命令内容显而易见：仅编译一次
3、用途：常出现在头文件中。因为同一头文件会在许多源文件中多次引用。如果没有指定编译一次，则编译时出现重定义错误。
4、相同作用命令
#ifndef    ABC_H
#define    ABC_H

解答及测试代码：

tree.h

#pragma once
#include <iostream>
#include <vector>
#include <queue> //队列
using namespace std;

//definition for binary tree
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) :val(x), left(nullptr), right(nullptr){}
};

//初始化一个二叉树
TreeNode* initBTree(int elements[], int size);

树的前序遍历
//void preOrder(TreeNode *root, vector<int> &result);
//
树的中序遍历
//void inOrder(TreeNode *root, vector<int> &result);
//
树的后序遍历
//void postOrder(TreeNode *root, vector<int> &result);
//
//vector的遍历
void traverse(vector<int> nums);

test.cpp

#include "tree.h"
#include <stack>
#include <iostream>
#include <vector>
#include <queue> //队列

TreeNode* initBTree(int elements[], int size){
if (size < 1){
return nullptr;
}
//动态申请size大小的指针数组
TreeNode **nodes = new TreeNode*[size]; //首先是数组，所以返回的是数组地址nodes,然后呢，数组元素还是指针
//将int数据转换成TreeNode节点
for (int i = 0; i < size; i++){
if (elements[i] == 0){
//if (!isalnum(elements[i])){
nodes[i] = nullptr; //一个非零数对应一个节点，节点以地址表示
}
else{
nodes[i] = new TreeNode(elements[i]); //动态申请
}
}

queue<TreeNode*> nodeQueue; //搞一个队列
nodeQueue.push(nodes[0]); //在队尾压入队列

TreeNode *node; //临时节点
int index = 1; //索引为1
while (index < size){
node = nodeQueue.front(); //返回队列头元素
nodeQueue.pop(); //删除队列首元素
nodeQueue.push(nodes[index++]); //在队尾压入元素，作为左节点
node->left = nodeQueue.back(); //返回队列尾元素
nodeQueue.push(nodes[index++]); //在队尾再压入元素，作为右节点
node->right = nodeQueue.back(); //返回队列尾元素
}
return nodes[0];
}

void traverse(vector<int> nums)
{
vector<int>::size_type size = nums.size();
for (int i = 0; i < size; i++)
{
cout << nums[i] << ' ';
}
cout << endl;
}

class Solution{
public:
vector<int> preorderTraversal(TreeNode *root){ //输入是根节点
vector<int> result;
stack<const TreeNode *> s; //栈的类型是指针,存放的是指针
if (root != nullptr) s.push(root); //压入栈顶

while (!s.empty()){ //只要这个堆栈不为空，这个是利用迭代，而不是递归
const TreeNode *p = s.top(); //把栈顶元素给它
s.pop(); //弹出栈顶元素
result.push_back(p->val); //把栈顶节点的数据值赋给这个向量

if (p->right != nullptr) s.push(p->right); //右子树节点地址压入堆栈
if (p->left != nullptr) s.push(p->left); //左子树节点地址压入堆栈，注意了，这个地方是后进先出，所以right先进，没毛病
}
return result;
}
};

int main(){
int nums[] = { 1, 2, 3, 4, 0, 5, 6, 0, 7 };
TreeNode *root = initBTree(nums, 9);
Solution mySolution;
vector<int> preResult = mySolution.preorderTraversal(root);
//前序遍历的结果
cout << "前序遍历的结果" << '\n';
traverse(preResult);
return 0;
}