一、c++二叉树结构
typedef struct BiNode
{
int data; //结点内值域
struct BiNode* lchild, * rchild; //左孩子 右孩子
} BiNode, * BiTree;
或者：
class Node
{
public:
char data;// data表示该节点代表的内容；
Node* L;//左子树
Node* R;//右子树
};
Node* T;//创个指针，指向二叉树的根节点；
二、用递归和非递归两种方式实现二叉树的先序、中序、后序遍历
有如下的树：
递归方法：
先序遍历：
先遍历头，再遍历左子树的结点、再遍历右子树的结点,遍历结果如下：
递归方法代码如下：
void preOrder(Node*& T)
{
if (T == NULL)
{
return;//如果该结点为空就返回;
}
//递归遍历
else
{
cout << T->data << " "; //先输出根节点的那个数字
preOrder(T->L); //然后访问左孩子，开始递归
preOrder(T->R); //左孩子访问完成，开始右孩子递归
}
}
以上代码输出即为先遍历
递归序的遍历结果为：
我们只需要在递归遍历过程中数字第一次出现时打印即可。
非递归：
思路：
先将根节点放到栈中
1、然后从栈中弹出一个结点cur
2、打印cur；
3、先右再左（如果有），否则什么也不做
4、循环1-3，直至栈中没有数据为止。
class Solution {
public:
void preorderTraversal(TreeNode* root) {
if(root != NULL){
//申请一个临时栈
stack<TreeNode*> st;
//将根节点首先压入栈中
st.push(root);
//如果栈不为空，则开始循环
while(!st.empty())
{ //弹出栈中的一个结点
root = st.pop();
//打印弹出的结点
cout << root->val << " ";
//如果叶结点不为空，则开始先将出栈节点的右结点和左结点先后压入栈中
if(root->right != NULL)
{
st.push(root->right);
}
if(root->left != NULL)
{
st.push(root->left);
}
}
}
}
中序遍历：
先遍历左，再遍历头的结点、再遍历右子树的结点,遍历结果如下：
递归方法代码如下：
void inOrder(Node*& T)
{
if (T == NULL)
return;
else
{
inOrder(T->L);
cout << T->data << " ";
inOrder(T->R);
}
}
非递归方法：
思路：
1、将压入结点下的每颗子树整棵树左边界进栈（第一次先从根节点开始）,对于下图，进栈的为（1，2，4）
2、弹出结点，弹出的过程中对弹出结点打印
3、压入弹出节点的右结点
4、循环以上两个步骤
class Solution {
public:
void inOrderTraversal(TreeNode* root) {
if(root != NULL){
//申请一个临时栈
stack<TreeNode*> st;
//如果栈不为空，则开始循环
while(!st.empty() || root != NULL)
{
//如果当前结点不为空，则一直将其左结点压栈
if(root != NULL){
st.push(root);
root = root->left;
}
//否则从栈中弹出一个结点，并打印，将其右结点返回
else{
root = st.pop();
cout << root->val << " ";
root = root->right;
}
}
}
}
后序遍历：
先遍历左，再遍历右、再遍历头结点,遍历结果如下：
递归方法代码如下：
void posOrder(Node*& T)
{
if (T == NULL)
return;
else
{
posOrder(T->L);
posOrder(T->R);
cout << T->data << " ";
}
}
非递归方法：
思路：
先将根节点放到栈中
1、然后从栈中弹出一个结点cur
2、将弹出的结点放到一个回收栈中；
3、先左再右（如果有），否则什么也不做
4、循环1-3，直至栈中没有数据为止。
5、挨个从回收栈中弹出数据并打印
class Solution {
public:
void posOrderTraversal(TreeNode* root) {
if(root != NULL){
//申请一个临时栈
stack<TreeNode*> st1;
stack<TreeNode*> st2;
//将根节点首先压入栈中
st1.push(root);
//如果栈不为空，则开始循环
while(!st1.empty())
{ //弹出栈中的一个结点
root = st1.pop();
//将弹出的结点压入回收栈中
st2.push(root);
//如果叶结点不为空，则开始先将出栈节点的左结点和右结点先后压入栈中
if(root->left != NULL)
{
st1.push(root->left);
}
if(root->right != NULL)
{
st1.push(root->right);
}
}
//将回收栈中的数据打印
while(!st2.empty())
{
cout<<st2.pop()->val<< " ";
}
}
}
三、二叉树的宽度优先遍历(常见题目:求一棵二叉树的宽度)
有如上的树。宽度优先遍历输出为：1，2，3，4，5，6，7，8，9
思路：
本题我们使用队列的方式来解决：
1、首先将根节点放到队列中
2、弹出队列中的第一个结点，然后打印该结点，并将该节点的左右子节点先后放到队列中（没有左或者右则直接跳过放另外一个结点）。
3、重复步骤二知道队列为空
#include<stdio.h>
#include<vector>
#include<queue>
//树的机构体
struct TreeNode
{
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(NULL), right(NULL){}
};
//开始进行宽度优先遍历
void BFS(TreeNode* root)
{
//实例化一个队列
std::queue<TreeNode*> Q;
//将根节点压入队列中
Q.push(root);
//如果该队列非空，则一直循环操作
while (!Q.empty())
{
//将第一个元素返回并打印
TreeNode* node = Q.front();
printf("[%d]", node->val);
//弹出第一个元素
Q.pop();
//开始先放左结点再放右节点的操作
if (node->left)
{
Q.push(node->left);
}
if (node->right)
{
Q.push(node->right);
}
}
}
//初始化树
int main()
{
TreeNode a(1);
TreeNode b(2);
TreeNode c(5);
TreeNode d(3);
TreeNode e(4);
TreeNode f(6);
a.left = &b;
a.right = &c;
b.left = &d;
b.right = &e;
c.right = &f;
BFS(&a);
return 0;
}
四、求二叉树的最大宽度
思路：
1)、首先，我们需要知道每一个节点的层数：每一个节点的层数是其父节点层数+1所以，我们在push一个节点的孩子节点进入队列时，可以保存其孩子节点的层级：当前层级+1。
2)、其次，我们需要获取每一层的宽度，并所有层级宽度取最大值返回。因为宽度遍历方式相同层级的节点肯定是依次输出遍历，我们就很方便对某层宽度进行计数。
int MaxWidth(TreeNode* root)
{
int widMax = 0; //记录结果：最大宽度
if (nullptr == root)
{
return 0;
}
queue<TreeNode*> nodeQueue; //遍历二叉树的辅助队列
unordered_map< TreeNode*, int> levelMap; //记录每个节点所在层数的哈希表
//根节点入队列
nodeQueue.push(root);
levelMap[root] = 1; //根节点定义为在第1层
int curLevel = 1; //当前所在层数
int curWidth = 0; //当前层记录的宽度
while (!nodeQueue.empty())
{
TreeNode* temp = nodeQueue.front();
//弹出队首节点
nodeQueue.pop();
//获取队首节点的层数，如果和上一个队首节点的层数curLevel相同，则curWidth+1；否则，说明已经开始进入下一层，则重置curWidth并更新curLevel
if (levelMap[temp] == curLevel)
{
++curWidth;
}
//已经进入下一层
else
{
//在进入下一层结点之前先要保存最大宽度
widMax = curWidth > widMax ? curWidth : widMax;
//将宽度置一
curWidth = 1;
//重置层数
curLevel = levelMap[temp];
}
if (temp->left != NULL)
{
nodeQueue.push(temp->left);
//保存当前节点左孩子的层数：当前层数+1
levelMap[temp->left] = curLevel + 1;
}
if (temp->right != NULL)
{
nodeQueue.push(temp->right);
//保存当前节点右孩子的层数：当前层数+1
levelMap[temp->right] = curLevel + 1;
}
}
return widMax;
}
我们也可以不使用哈希表来实现这种操作。
思路：
1)进队列
2)cur_end记录最后一个结点
next_end记录每次进队列的结点
curlevel记录每层结点个数
3)每当出来的结点不等cur_end时，curlevel++；
每当出来的结点等于cur_end时，curlevel++，并将next_end赋给cur_end，next_end置为NULL,
max更新与curlevel比较，curlevel置为0
#include<iostream>
#include<stdlib.h>
#include<deque> //插入标准库中的头文件
using namespace std;
typedef struct treenode
{
char data;
treenode *right;
treenode *left;
}*Node;
//创建二叉树
void creat_tree(treenode *&rt)
{
char ch;
ch = getchar();
if ('#' == ch) {
rt = NULL;
} else {
rt = new treenode;
rt->data = ch;
creat_tree(rt->left); //构造左子树
creat_tree(rt->right); //构造右子树
}
}
int noMapWeight(Node* head) {
//如果没有结点，则返回
if (head == NULL)
return 0;
//创建一个队列
queue<Node*> q;
q.push(head);//先将头装进去
Node* cur_end = head; //定义当前层最后一个结点
Node* next_end = NULL; //定义下一层最后一个节点
int curlevel = 0, max = 0; //定义每层的节点数以及最大的节点数
while (!q.empty()) {
Node* out = q.front(); //取出第一个元素的值
q.pop();//弹出第一个元素
if (out->left != NULL) {//将左结点压入，并且下一层的最后一个结点赋值
q.push(out->left);
next_end = out->left;
}
if (out->right != NULL) {//将右结点压入，并对下一层最后一个节点赋值
q.push(out->right);
next_end = out->right;
}//如果输出的元素不为当前层最后一个结点，则宽度加一
if (out != cur_end) {
curlevel++;
//否则宽度先加一，然后将将所有变量移动到最后一层，并且暂存最大值
}else {
curlevel++;
cur_end = next_end;
next_end = NULL;
max = max < curlevel ? curlevel : max;
curlevel = 0;
}
}
return max;//返回最大值
}
int main() {
treenode *root = NULL;
int height, width; //表示高度和最大宽度
cout << "请输入二叉树,空值以#代表:" << endl;
creat_tree(root); //创建二叉树
Complete_binary_tree(root,height,width);
cout << "高度为：" << height << endl;
cout<<"最大宽度为：" << width << endl;
system("pause");
return 0;
}
五、如何判断一颗二叉树是搜索二叉树
搜索二叉树：左侧结点都比头节点小，右侧结点都比头节点大。经典搜索二叉树没有重复值。
上图即为经典搜索二叉树。从上图可以看出，在中序遍历中，所有结点都是升序的，即为搜索二叉树。如果某一位置是降序的，则该树就不是搜索二叉树。
法一：直接通过递归的方式挨个子树遍历比较。
/*
* 概念：每个结点都比左儿子大，比右儿子小，严格的搜索二叉树没有重复的值
step: 1)中序遍历得到的数组的升序的
*/
int preData = INT_MIN;
bool isBST(Node* head) {
if (head == NULL)
return true;
bool isLeftBST = isBST(head->left);
if (!isLeftBST)//如果左树不是，就直接返回false
return false;
if (preData >= head->data)//如果根的data比左的小，就返回false
return false;
else {
preData = head->data;
}
return isBST(head->right);
}
法二：将每次中序遍历的结点全放到list容器中，然后再判断list容器中结点的值是否为升序。
//判断是否为搜索二叉树2
#include<list>
#include<algorithm>
bool isBST2(Node* head) {
if (head == NULL)
return false;
list<int> L;
process(head, L);
int sz = L.size();
list<int>::iterator end = --L.end();
for (list<int>::iterator it = L.begin();it != end;)
if (*it >= *(++it))
return false;
return true;
}
void process(Node* head, list<int>& L) {
if (head == NULL)
return;
process(head->left, L);
L.push_back(head->data);
process(head->right, L);
}
法三：非递归过程中进行比较
bool isBST(node* head){
if (head == NULL){
return true;
}
stack<node*>newstack;
int pre = INT_MIN;
while (!newstack.empty() || head != NULL){
if (head != NULL){
newstack.push(head);
head = head->left;
}
else{
head = newstack.top();
//cout << head->value << ",";
if (pre < head->value){
pre = head->value;
}else{
return false;
}
newstack.pop();
head = head->right;
}
}
return true;
}
![P2[1-2]STM32简介(stm32简介+ARM介绍+片上外设+命名规则+系统结构+引脚定义+启动配置+最小系统电路+实物图介绍)](https://img-blog.csdnimg.cn/83b9ac2eb8a342b59391756331150525.png)
