二叉树常考算法汇总

筑梦悠然

已于 2024-05-19 18:51:30 修改

阅读量50

点赞数

分类专栏：算法汇总文章标签：算法深度优先 c++

于 2021-01-17 19:31:42 首次发布

本文链接：https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/106889527

版权

算法汇总专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、二叉树的深度优先遍历DFS和广度优先遍历BFS

2、递归和非递归方式遍历二叉树

（1）递归方式遍历二叉树

（2）非递归方式遍历二叉树

3、递归和非递归(层次遍历)方式求二叉树的高度

4、反转二叉树(小米)

5、红黑树和普通的平衡查找树的区别? 红黑树是如何保证自平衡的？(面试题)

（1）应用场景：TreeMap和TreeSet

（2）特性

（3）两者的对比

6、前中序或中后序还原二叉树(前中序-字节跳动)

7、二叉树左右侧视图(字节跳动)

8、二叉树Z形打印(字节跳动)

9、二叉搜索树转二叉平衡树,插入删除后的平衡(微软-2022)

1、二叉树的深度优先遍历DFS和广度优先遍历BFS

法1:栈与队列遍历

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

struct BitNode {
int data;
BitNode *left, *right;
BitNode(int x) :data(x), left(NULL), right(NULL){}
};
void CreateBitTree(BitNode *&root) {
int key;cin>>key;
if (key == -1) {
root = NULL;
} else {
root = new BitNode(key);
CreateBitTree(root->left);
CreateBitTree(root->right);
}
}

//深度优先搜索，利用栈，先右后左：先将右子树压栈，再将左子树压栈
void DFS(BitNode *root) {
stack<BitNode*> stk;
stk.push(root);
while (!stk.empty()) {
BitNode *node = stk.top();
cout << node->data << ' ';
stk.pop();
if (node->right) stk.push(node->right);
if (node->left) stk.push(node->left);
}
}

//广度优先搜索，利用队列，先左后右：先将左子树入队，再将左子树入队
void BFS(BitNode *root) {
queue<BitNode*> que;
que.push(root);
while (!que.empty()) {
BitNode *node = que.front();
cout << node->data << ' ';
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}

int main() {
BitNode *root = NULL;
CreateBitTree(root);//创建二叉树
cout<<"dfs="; DFS(root);//深度优先遍历
cout<<endl;
cout<<"bfs="; BFS(root);//广度优先搜索
return 0;
}

法2:递归遍历

#include <iostream>
#include <queue>
using namespace std;
struct Node {
int value;
Node* left;
Node* right;
Node(int value):value(value), left(NULL), right(NULL) {}
};

void DFS(Node* head) {
if (head == NULL) return;
cout << head->value << " ";
DFS(head->left);
DFS(head->right);
}

void BFS(Node* head) {
if (head == NULL) return;
queue<Node*> que;
que.push(head);
while (!que.empty()) {
cout << que.front()->value << " ";
if (que.front()->left != NULL) que.push(que.front()->left);
if (que.front()->right != NULL) que.push(que.front()->right);
que.pop();
}
}
int main() {
Node* head = new Node(1);
head->left = new Node(2);
head->right = new Node(3);
head->left->left = new Node(4);
head->left->right = new Node(5);
head->right->left = new Node(6);
head->right->right = new Node(7);
cout << "DFS="; DFS(head);
cout << endl;
cout << "BFS="; BFS(head);
return 0;
}

//法1:栈与队列遍历
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
struct BitNode {
	int data;
	BitNode *left, *right;
	BitNode(int x):data(x), left(NULL), right(NULL){}
};
void CreateBitTree(BitNode * &root) {
	int key;cin>>key;
	if (key == -1) {
		root = NULL;
	} else {
		root = new BitNode(key);
		CreateBitTree(root->left);
		CreateBitTree(root->right);
	}
}


//深度优先搜索，利用栈，先右后左：先将右子树压栈，再将左子树压栈
void DFS(BitNode *root) {
	stack<BitNode*> stk;
	stk.push(root);
	while (!stk.empty()) {
		BitNode *node = stk.top();
		cout << node->data << " ";
		stk.pop();
		if (node->right) stk.push(node->right);
		if (node->left) stk.push(node->left);
	}
}

//广度优先搜索，利用队列，先左后右：先将左子树入队，再将左子树入队
void BFS(BitNode *root) {
	queue<BitNode*> que;
	que.push(root);
	while (!que.empty()) {
		BitNode *node = que.front();
		cout << node->data << " ";
		que.pop();
		if (node->left) que.push(node->left);
		if (node->right) que.push(node->right);
	}
}

int main() {
	BitNode *root = NULL;
	CreateBitTree(root);//创建二叉树
	cout<<"dfs="; DFS(root);//深度优先遍历
	cout<<endl;
	cout<<"bfs="; BFS(root);//广度优先搜索
	return 0;
}
/*
输入如下：
1 2 4 -1 -1 5 -1 -1 3 6 -1 -1 7 -1 -1
输入如下：
dfs=1 2 4 5 3 6 7 
bfs=1 2 3 4 5 6 7
*/

//法2:递归遍历
#include <iostream>
#include <queue>
using namespace std;
struct Node {
	int value;
	Node* left;
	Node* right;
	Node(int value):value(value), left(NULL), right(NULL) {}
};

void DFS(Node* head) {
	if (head == NULL) return;
	cout << head->value << " ";
	DFS(head->left);
	DFS(head->right);
}

void BFS(Node* head) {
	if (head == NULL) return;
	queue<Node*> que;
	que.push(head);
	while (!que.empty()) {
		cout << que.front()->value << " ";
		if (que.front()->left != NULL) que.push(que.front()->left);
		if (que.front()->right != NULL) que.push(que.front()->right);
		que.pop();
	}
}
int main() {
	Node* head = new Node(1);
	head->left = new Node(2);
	head->right = new Node(3);
	head->left->left = new Node(4);
	head->left->right = new Node(5);
	head->right->left = new Node(6);
	head->right->right = new Node(7);
	cout << "DFS="; DFS(head);
	cout << endl;
	cout << "BFS="; BFS(head);
	return 0;
}
/*
DFS=1 2 4 5 3 6 7 
BFS=1 2 3 4 5 6 7 
*/

2、递归和非递归方式遍历二叉树

（1）递归方式遍历二叉树

void preOrder(BTNode * head) {
   if (head == NULL) return NULL;
   cout<<head->data<<' ';
   preOrder(head->left);
   preOrder(head->right);
}

void inOrder(BTNode * head) {
   if (head == NULL) return NULL;
   preOrder(head->left);
   cout<<head->data<<' ';
   preOrder(head->right);
}

void postOrder(BTNode * head) {
   if (head == NULL) return NULL;
   preOrder(head->left);
   preOrder(head->right);
   cout<<head->data<<' ';
}

（2）非递归方式遍历二叉树

先序遍历(1个栈)：
1、首先申请一个新的栈记为stack
2、然后将头节点head压入stack中
3、每次从stack中弹出栈顶节点，记为cur，然后打印cur节点的值，如果cur右孩子不为空，右孩子先压入stack中，最后如果左孩子不为空的话，将左孩子压入stack中。
4、不断重复步骤3，直到stack为空，全部过程结束。

中序遍历(1个栈)：
1、首先申请一个新的栈记为stack，申请一个变量cur,初始令cur等于头节点。
2、先把cur节点雅茹栈中国呢，对以cur节点为头的整棵子树来说，依次把整棵树的左边界压入栈中，即不断令cur=cur.left,重复步骤2。
3、不断重复步骤2，直到发现cur为空，此时从stack中弹出一个节点，记为node，打印node的值，并让cur=node.right，然后继续重复步骤2。
4、当stack为空并且cur为空时，整个过程结束

后序遍历(2个栈)：
1、申请一个栈，记为s1，然后将头节点压入s1中
2、从s1中弹出的节点记为cur，先把cur的左孩子压入s1中，然后cur的右孩子压入s1中
3、在整个过程中，每一个从s1中弹出的节点都放进第二个栈s2中
4、不断重复步骤2和步骤3，直到s1为空，过程停止。
5、从s2中依次弹出节点并打印。

后序遍历(1个栈)：
1、首先申请一个新的栈记为stack，将头节点压入stack，同时设置2个变量h和c，在整个流程中，h代表最近一次弹出并打印的节点，c代表
当前stack的栈顶节点，初始时令h为头节点，c为null
2、每次令c等于当前stack的栈顶节点，但是不从stack中弹出节点，此时分以下3种情况：
(1)如果c的左孩子不为空，且h不等于c的左孩子，也不等于c的右孩子，则把c的左孩子压入stack中
(2)如果(1)不成立，并且c的右孩子不为空，并且h不等于c的右孩子，则把c的右孩子压入stack中
(3)如果(1)(2)都不成立，那么从stack中弹出c并打印，然后令h等于c
3、一直重复步骤2，直到stack为空，过程停止。

代码框架详见：非递归方式先序+中序+后序遍历二叉树

前序：
(1)根节点入栈。
(2)循环：出栈并打印，有右则压右，有左压左。
stk.push(head);
while(!stk.empty()) {
   cur=stk.top();cout<<cur->data<<" ";stk.pop();
   if (cur->right) stk.push(cur->right);
   if (cur->left) stk.push(cur->left);
}

中序：
(1)从根节点开始一直往左走，边走边入栈。
(2)循环：出栈并打印，向右走，有右则压右。
while(!stk.empty() || p!=NULL) {
   if (p!=NULL) {
       stk.push(p);
       p=p->left;
   } else {
       p=stk.top();cout<<cur->data<<" ";stk.pop();
       p=p->right;
   }
}

后序：
(1)根节点入栈.
(2)循环：栈顶的左右节点为空或都遍历过，则出栈并打印并标记访问过。有右则压右，有左压左。
stk.push(head);visited=NULL;
while(!stk.empty()) {
cur=stk.top();

   if (
   (cur->left==NULL&&cur->right==NULL) ||
   (visited!=NULL && (cur->left==visited&&cur->right=visited))
   ) {
       cout<<cur->data<<" ";stk.pop();visited=cur;
   }
   if (cur->right) stk.push(cur->right);
   if (cur->left) stk.push(cur->left);
}

#include<iostream>
#include<stack>
using namespace std;
struct BTNode {
	int data;
	BTNode *left;
	BTNode *right;
	BTNode(int _data=-1):data(_data),left(NULL),right(NULL) {}
};

void preOrder(BTNode *head) {
		if (head == NULL)  return ;
		stack<BTNode *> stk;stk.push(head);
		while (!stk.empty()){			
			head= stk.top();stk.pop();cout<<head->data<<" ";
			if(head->right != NULL) stk.push(head->right);
			if(head->left != NULL) stk.push(head->left);
		}
}
 
 
void inOrder(BTNode *head) {
	if (head == NULL)  return ;
	stack<BTNode *> stk;BTNode *node;
	while (!stk.empty() || head != NULL){
		if (head != NULL){
			stk.push(head);
			head = head->left;
		} else{
		    head = stk.top();stk.pop();cout<<head->data<<" ";
			head = head->right;
		}
	}
}
void postOrder(BTNode *head) {
	if (head == NULL) return;
	stack<BTNode *>stk;BTNode *cur, *visited;
	cur=head;visited=NULL;
	stk.push(head);
	while (!stk.empty()) {
		cur = stk.top();
		if ((cur->left==NULL&&cur->right==NULL) || 
		((visited==cur->left || visited==cur->right) && visited!=NULL)) {
			cout << cur->data << " ";
			stk.pop();
			visited = cur;
		} else {
			if (cur->right != NULL) stk.push(cur->right);
			if (cur->left != NULL) stk.push(cur->left);
		}
	}
}
/*void postOrder(BTNode * head){
	if (head == NULL) return ; 
		stack<BTNode *> s1,s2;//= new stack<BTNode>();
		s1.push(head);
		while (!s1.empty()){
			head = s1.top();s1.pop();s2.push(head);
			if(head->left != NULL) s1.push(head->left);
			if (head->right != NULL) s1.push(head->right);
		}
		while (!s2.empty()){
			BTNode *cur = s2.top(); s2.pop(); cout<<cur->data<<" ";
		}
}*/
int main() {
    BTNode *head = new BTNode(1);
    head->left = new BTNode(2);
    head->right = new BTNode(3);
    head->left->left = new BTNode(4);
	head->left->right = new BTNode(5);
	head->right->left = new BTNode(6);
	head->right->right = new BTNode(7);
	cout<<"非递归前序遍历：";preOrder(head);cout<<endl;
    cout<<"非递归中序遍历：";inOrder(head);cout<<endl;
    cout<<"非递归后序遍历：";postOrder(head);cout<<endl;
    return 0;
}
/*输出如下：
非递归前序遍历：1 2 4 5 3 6 7 
非递归中序遍历：4 2 5 1 6 3 7 
非递归后序遍历：4 5 2 6 7 3 1 
*/

3、递归和非递归(层次遍历)方式求二叉树的高度

递归

int getDepth(TreeNode *root)
{
   if(root == NULL) return 0;//空树深度为零
   int leftDepth=getDepth(root.left);
   int rightDepth=getDepth(root.right);
   return leftDepth>rightDepth?leftDepth+1:rightDepth+1;
}

非递归---层次遍历求树的高度
int GetDepth(bitreenode *root) {
int depth=0;
bitreenode *p=root;
queue<bitreenode*> q;
q.push(p);//根指针入队
while(!q.empty()) {
depth++;//高度加一
int width=q.size();//获取当前层次宽度
for(int i=0;i<width;i++) {
p=q.front();//获取队顶元素
q.pop();//弹出队顶元素
if(p->leftchild!=NULL) q.push(p->leftchild);
if(p->rightchild!=NULL) q.push(p->rightchild);
}
}
cout<<depth<<endl;
}

(1)根节点入栈
(2)循环：栈不为空则h++
(3)遍历栈所有元素：栈元素pop,有左入左，有右入右
PS:遍历过程其实就是层次遍历

#include<iostream>
#include<queue>
using namespace std;
struct BTNode {
	int data;
	BTNode *left;
	BTNode *right;
	BTNode(int _data=-1):data(_data),left(NULL),right(NULL) {}
};
int GetDepth(BTNode *root) {
	int depth=0;
	BTNode *p=root;
	queue<BTNode *> q;
	q.push(p);//根指针入队
	while(!q.empty()) {
		depth++;//高度加一
		int width=q.size();//获取当前层次宽度
		for(int i=0;i<width;i++) {
			p=q.front();//获取队顶元素
			q.pop();//弹出队顶元素
			if(p->left!=NULL) q.push(p->left);
			if(p->right!=NULL) q.push(p->right);
		}
	}
	cout<<depth<<endl;
	return depth;
}
int main() {
    BTNode *head = new BTNode(1);
    head->left = new BTNode(2);
    head->right = new BTNode(3);
    head->left->left = new BTNode(4);
	head->left->right = new BTNode(5);
	head->right->left = new BTNode(6);
	head->right->right = new BTNode(7);
	GetDepth(head);
    return 0;
}
/*输出：3 */

4、反转二叉树(小米)

#include <iostream>
#include<queue>
using namespace std;
struct BTNode{
    int val;
    BTNode * left;
    BTNode * right;
    BTNode(int x=0):val(x),left(NULL),right(NULL){};
};
//只打印反转后的二叉树
void reverseBpsPrint(BTNode * root) {
    queue<BTNode *> que; BTNode * node;
    que.push(root);
    while(!que.empty()) {
        node = que.front();
        cout<< node->val <<" ";
        que.pop();
        if(node->right) que.push(node->right);
        if(node->left) que.push(node->left);
    }
}
void swap(BTNode * &a, BTNode * &b) {
    BTNode * c = a; a = b; b = c;
}
//返回反转后的二叉树
BTNode * reserve(BTNode * root) {
    if(root == NULL || (root->left==NULL && root->right==NULL)) 
        return root;
    if(root->left != NULL && root->right != NULL){
        swap(root->left, root->right);
        root->left = reserve(root->left);
        root->right = reserve(root->right);
    } else if (root->left != NULL){
        root->right->val = root->left->val;
        root->left = NULL;
        return root;
    } else{
        root->left->val = root->right->val;
        root->right = NULL;
        return root;
    }
    return root; 
}

void bfsPrint(BTNode * root) {
    queue<BTNode *> que; BTNode * node;
    que.push(root);
    while(!que.empty()) {
        node = que.front();
        cout<< node->val <<" ";
        que.pop();
        if(node->left) que.push(node->left);
        if(node->right) que.push(node->right);
    }
}


int main(){
    BTNode * root = new BTNode(1);//注意此处要new 
    root->left = new BTNode(2); root->right = new BTNode(3);
    root->left->left = new BTNode(4); root->left->right = new BTNode(5); 
    root->right->left = new BTNode(6); root->right->right = new BTNode(7);
    cout<<"1.只打印反转结果=";reverseBpsPrint(root);
    cout<<endl<<"2.递归反转后的=";
    BTNode * reverseRoot = reserve(root); bfsPrint(reverseRoot);
    return 0;
}
/*
1.只打印反转结果=1 3 2 7 6 5 4 
2.递归反转后的=1 3 2 7 6 5 4 
*/

5、红黑树和普通的平衡查找树的区别? 红黑树是如何保证自平衡的？(面试题)

（1）应用场景：TreeMap和TreeSet

Java语言中TreeMap和TreeSet的底层结构就是红黑树。一般工程中喜欢使用红黑树而不是其它二叉查找树

（2）特性

红黑树除了具备二叉查找树的基本特性之外，还具备以下特性：
红黑树(rbtree)5个性质：
(1)每个结点要么是“红色”，要么是“黑色”(后面将说明)
(2)根结点永远是“黑色”的
(3)所有的叶结点都是空结点，并且是“黑色”的
(4)如果一个结点是“红色”的，那么它的两个子结点都是“黑色”的
(5)结点到其子孙结点的每条简单路径都包含相同数目的“黑色”结点
PS：根到叶子节点的最长路径<=2*最短路径

平衡二叉树(avl)3个性质：
(1)一棵n个结点的AVL树的其高度保持在0(log2(n)),不会超过3/2log2(n+1)
(2)一棵n个结点的AVL树的平均搜索长度保持在0(log2(n)).
(3)一棵n个结点的AVL树删除一个结点做平衡化旋转所需要的时间为0(log2(n)).

（3）两者的对比

A. avl树是高度平衡的，频繁的插入和删除，会引起频繁的reblance，导致效率下降，普通的二叉查找树（非平衡二叉查找树）在极端情况下可能会退化为链表的结构，退化后元素的添加、删除、查询时，时间复杂度退化为O(n)；
rbtree的高度近似log2n，它的插入、删除、查找的复杂度都是O(logN),红黑树不是高度平衡的，算是一种折中，插入最多2次旋转，删除最多3次旋转;

B. rbtree可以通过[变色、左旋、右旋]实现自平衡，详见：29-红黑树和平衡二叉树有什么区别？ | 码农家园