二叉树操作算法

最新推荐文章于 2022-06-12 13:34:14 发布
最新推荐文章于 2022-06-12 13:34:14 发布
阅读量649 收藏
点赞数 1
分类专栏： Algorithm 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShutingChen/article/details/38172681
版权

二叉搜索树转化为双向链表

void _revertToDoubleList(struct node *root, struct node** prev ) {
	if (root == NULL) {
		return;
	}

	revertToDoubleList(root->left, prev);
	root->left = *prev;
	if (prev != NULL && *prev != NULL)
		(*pre)->right = root;
	*pre = root;
	revertToDoubleList(root->right, prev); 
}

struct node * revertToDoubleList(struct node *root) {
	if (root == NULL)
		return NULL;

	struct node *prev = NULL;
	_revertToDoubleList(root, prev);

	struct node *head = root, *tail = root;
	while (tail->right != NULL) {
		tail = tail->right;
	}

	head->left = tail;
	tail->right = head;

	return head;
}


二叉树翻转

struct node * reverseTree(struct node *root)
{
	if (root == NULL) {
		return NULL;
	}
	struct node *left = node->left;
	struct node *right = node->right;
	
	root->left = right;
	root->right = left;
	
	reverseTree(left);
	reverseTree(right);
}

最近公共节点

出口

  1. 没有找到a或b，则返回NULL；
  2.  碰到a或b，就立刻返回

实现

struct node* findLowestCommonAncestor(struct node* root, struct node *node1, struct node *node2) {
	if (root == NULL)
		return NULL;

	if (root == node1 || root == node2) {
		return root;
	}

	sturct node *left = findLowestCommonAncestor(root->left, node1, node2);
	sturct node *right = findLowestCommonAncestor(root->right, node1, node2);

	if (left && right)
		return root;
	return left? left:right;
}

比较两棵二叉树

int compare(struct node *node2, struct node*node1) {
	if (node2 == node1) {
		if (node1 == NULL) {
			return 1;
		} else {
			return compare(node1->left, node2->left) && 
				compare(node1->right, node2->right);
		}
	}
	
	return 0;
}

获取二叉树的宽度

int getWidth(struct node *root)
{
	if (root == NULL) {
		return 0;
	}
	if (root->left == NULL && root->right == NULL) {
		return 1;
	} else {
		return getWidth(root->left) + getWidth(root->right);
	}
}

获取二叉树的高度

int getHeight(struct node *root)
{
	if (root == 0)
		return NULL;
	int left = getHeight(root->left);
	int right=getRight(root->right);
	
	return max(left, right) + 1;
}

二叉搜索树的后序遍历结果

思路

  • 二叉的特点为：左子树均小于当前节点，右子树均大于当前节点。

实现

bool verifySequeceOfBST(int *sequece, int start, int end)
{
    if (sequece == NULL ||start > end || start < 0 ||end < 0) {
        return false;
    }   
 
    bool left = true, right = true;
    int i = 0, middle = 0;
 
    while (i < end && sequece[i] <= sequece[end]) {
        i++;
    }   
    middle = i - 1;
 
    while (i < end  && sequece[i] > sequece[end]) {
        i++;
    }   
 
    if (i != end) {
        return false;
    }   
 
    if (middle > start) {
        left = verifySequeceOfBST(sequece, start, middle);
    }   
 
    if (middle < end - 1) {
        right = verifySequeceOfBST(sequece, middle + 1, end - 1); 
    }   
 
    return (left && right);
}

二叉树中和为某一值的所有路径

思路

  • 采用前序遍历的方式遍历树，利用vector来存储一条路径
  • 当遇到子节点的数值小于指定和，将当前节点加入路径，继续遍历；若大于指定和，则不需要继续遍历该棵子树的路径。
  • 当遇到叶子节点时，判断当前的路径和是否为指定的和，若为指定的和，则打印；
  • 遍历完左右子树后，需要将当前的节点从路径中删除。

算法实现

void printPath(vector<int> path)
{
    cout << "Path:>";
    for (vector<int>::iterator iter = path.begin(); iter != path.end(); iter++) {
        cout << *iter << " ";
    }   
    cout << endl;
}
 
void findFixedSumPath(BTreeNode<int> *root, int currentSum, int sum, vector<int>& path) {
    if (root == NULL) {
        return;
    }   
    currentSum += root->value;
    if (currentSum <= sum) {
        path.push_back(root->value);
    }   
    
    if (root->isLeaf() && currentSum == sum) {
        printPath(path);    
    }   
 
    findFixedSumPath(root->left, currentSum, sum, path);
    findFixedSumPath(root->right, currentSum, sum, path);
 
    path.pop_back();
}

有n个元素的完全二叉树的深度

完全二叉树：若设二叉树的高度为H，除第H层外，其它各层（1~H-1）的节点数都达到最大个数，第H层有叶子节点，并且叶子节点都是从左到右一次排布。判断方法：二叉树的所有子树要么没有孩子，要么一定有左孩子；二叉树要么没有子树，要么一定左右子树都有；

特点：叶子节点只可能在最大的两层上出现，对任意节点，若其右分支下的子孙最大层为L，则左分支下的子孙最大层为L或L+1

第i层最多有2^(i-1)个节点，共i层的完全二叉树最多有2^i - 1个节点。

前序遍历、中序遍历和后序遍历的互求方法

Answer:

一、已知前序、中序遍历，求后序遍历--结果唯一

例：前序遍历：GDAFEMHZ; 中序遍历：ADEFGHMZ

step1：由前序遍历可知G为root节点。

step2：由中序遍历得知：ADEF必为root的左子树，HMZ必然是root的右子树。

step3：观察左子树：ADEF。左子树的根节点，必为root的左子结点，而大树的左子结点紧接着G，故而D为左子树的根节点。

step4：同理可得M为右子树的根节点。

step5：根据上面过程递归得出：

    ① 确定根，确定左子树，确定右子树；

    ② 在左子树中递归

    ③ 在右子树中递归

    ④ 打印当前根

根据上述过程，可以画出二叉树的形状：

即后序遍历为：AEFDHZMG

二、已知中序和后序遍历，求前序遍历--结果唯一

例：中序遍历：ADEFGHMZ；后序遍历：AEFDHZMG

step1： 根据后序遍历的特点，可知最后一个节点为root节点，即root节点为G

step2：观察中序遍历，可知ADEF为左子树，HMZ为右子树

step3：观察左子树ADEF，在后序遍历中，左子树的根节点位于遍历的最后，故而D为根节点；同理可得，M为右子树的根节点；

step4：经过观察得出，确认子树的过程是递归的。递归过程如下：

    ① 确定根，确定左子树，确定右子树；

    ② 在左子树中递归

    ③ 在右子树中递归

    ④ 打印当前根

由此可得出前序遍历的结果为：GDAFEMHZ

三、已知前序遍历和后序遍历，求中序遍历--结果不唯一

二分搜索

int binary_search (int *data, int len, int key) 
{
    int left, right, middle;
    int ret = -1; 
 
    if (data == NULL || len <= 0) {
        return ret;
    }   
    left = 0;
    right = len;
    while (left < right) {
        middle = (left+right)/2;
 
        if (data[middle] < key) {
            left = middle+1;
        } else if (data[middle] > key) {
            right = middle;
        } else {
            return middle;
        }   
    }   
 
    return ret;
}

前序遍历

过程

  • 先遍历节点，在分别遍历左右子节点

方法

  1.  将root节点压栈；
  2. 循环直到栈为空：
    1. pop() 取出node
    2. 现将右子结点压栈，再将左子结点压栈----左子结点先出栈，先遍历！

代码实现

void prev_scan (node_t * node)
{
    struct stack *s = NULL;
    if (node == NULL)
        return;
   
    printf("prev_scan\n");
    s = create_stack();
    if (s == NULL) {
        printf("Create stack failed!\n");
        return;
    }
    push(&s, node);
    while (!is_empty(s)) {
        node = pop(&s);
        printf("%d\t", node->value);
        if (node->right) {
            push(&s, node->right);
        }
        if (node->left) {
            push(&s, node->left);
        }
    }
   
    printf("\n");
    destroy_stack(&s);
}

中序遍历

过程

  •     先遍历左子结点，在遍历节点，最后遍历右子结点

方法

  1. 循环将节点的左子结点压栈，直到左子结点为空
  2. 出栈，打印该节点
  3. 将该节点赋值为右子结点，继续循环。

代码实现

void mid_scan (node_t * node)
{
    struct stack *s = NULL;
    if (node == NULL)
        return;
 
    printf("mid_scan\n");
    s = create_stack();
    if (s == NULL) {
        printf("Create stack failed!\n");
        return;
    }
    while (node || !is_empty(s)){
        while (node) {
            push(&s, node);
            node = node->left;
        }   
 
        node = pop(&s);
        printf("%d\t", node->value);
        node = node->right;
    }   
    printf("\n");
    destroy_stack(&s);
}

后序遍历

过程

  • 先遍历左子结点，在遍历右子节点，最后遍历结点

方法

  1. 将该节点的左子结点循环压栈，直到左子结点为空；
  2. 查看当前栈顶元素：
    1.  若当前栈有右子结点，并且该右子节点没有打印过。则将该节点赋值为右子节点，继续1
    2. 若当前栈没有右子结点，或者右子节点已经打印过，则出栈，并打印该节点。然后对prev赋值为当前节点，cur赋值为null

代码实现

void post_scan (node_t * root)
{
    struct stack *s = NULL;
    node_t *prev = NULL, *cur = root;
    if (root == NULL)
        return;
    printf("post_scan\n");
    s = create_stack();
    if (s == NULL) {
        printf("Create stack failed!\n");
        return;
    }   
       
    while(cur || !is_empty(s)){
        while(cur) {
            push(&s,cur);
            cur = cur->left;
        }   
        cur = top(s);
        if (cur->right == NULL || cur->right == prev) {
            pop(&s);
            printf("%d\t", cur->value);
            prev = cur;
            cur = NULL;
        }else {
            cur = cur->right;
        }   
    }   
    printf("\n");
    destroy_stack(&s);
}

找出二叉树的深度

分析

  • 一个二叉树的深度等于max{左子树的深度，右子树的深度}+1

代码实现

struct node{
    int value;
    struct node *left;
    struct node *right;
};

int get_depth(struct node *root)
{
    int left = 0, right = 0 ;
    if(root == NULL){
        return 0;
    }

    left = get_depth(root->left);
    right = get_depth(root->right);

    return left > right? left+1: right+1;
}





ShutingChen
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树（各种基本算法）
11-29
二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树
面试算法之二叉树操作集锦
jishublog
09-03 202
开学了，找工作也正式拉开了序幕，每天光自己看书，也很没劲，和大家一起分享分享，交流一下笔试面试过程中的各种算法题目，如有问题，欢迎指正，希望大家一起进步。。。 下面是对数据结构二叉树的一些基本操作，可能在面试中都会涉及到。我们都知道二叉树的定义本身就是一种递归定义，所以对树的大部分操作都可以通过递归的方式进行，但递归不是万能的，因为递归的本身是一件很浪费内存资源的操作，所以在选择算法的时候要...
二叉树相关操作的算法总结
abtgu的博客
06-06 371
文章目录1.二叉树的顺序存储2.二叉树的链式存储结构3.二叉树的先序遍历4.二叉树的中序遍历5.二叉树的后序遍历6.二叉树的非递归遍历7.利用先序遍历算法创建二叉树8.计算二叉树结点个数9.计算二叉树中叶子结点个数10.计算二叉树的深度11.线索二叉树的结点定义12.以结点p为根结点的子树中序线索化13.遍历中序线索二叉树14.树的孩子兄弟存储表示15.哈夫曼树的存储表示 1.二叉树的顺序存储 #define MAXSIZE 100 //二叉树的最大结点数 typedef TElemType SqBi
数据结构有关二叉树的最全算法
weixin_51964627的博客
04-30 889
二叉树实验实验目的实验内容实验要求实验代码运行结果 实验目的 1.能够用高级语言描述二叉树的二叉链表存储结构； 2.能够用高级语言编写二叉树遍历操作的算法实现。 3.能够将二叉树的递归定义及其遍历操作特点灵活应用于解决二叉树中更复杂的问题。 实验内容 1．创建二叉链表表示的二叉树； 2．实现二叉树的先根、中根和后根遍历操作； 3．利用二叉树的遍历操作实现二叉树的复制、判断两棵二叉树是否相等、求树中叶子结点的个数、求树的深度和查找等操作。 实验要求 1.假设二叉树的结点值是字符，先根据输入一棵二叉树标明空子树
二叉树算法
11-09 220
#include <iostream> #include <stdio.h> using namespace std;typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;BiTree createBiTree(BiTree T) { char ch; c
二叉树的操作算法
11-28
本话题将围绕二叉树的操作算法进行深入探讨，包括其链表实现、遍历、构造、析构以及查找。 首先，二叉树的链表结构是通过二叉链表来实现的。每个节点包含一个数据元素和两个指向子节点的指针。在C++中，可以使用类...
二叉树遍历算法
08-04
二叉树遍历算法是计算机科学中的一种基本数据结构操作，尤其在处理树形数据结构时至关重要。二叉树是一种每个节点最多有两个子节点（通常称为左子节点和右子节点）的数据结构，广泛应用于搜索、排序、编译器设计等...
结构体 二叉树 操作算法
09-13
### 结构体与二叉树操作算法 #### 一、概述 本文档主要介绍了一个使用C语言实现的二叉树数据结构及其相关的操作算法。在计算机科学领域，二叉树是一种重要的非线性数据结构，它由节点组成，每个节点最多有两个子...
二叉树处理算法
12-26
理解并熟练掌握二叉树的创建、遍历和删除等基本操作，对于解决复杂问题和优化算法效率至关重要。通过深入学习和实践，我们可以更好地运用二叉树解决实际问题，如文件系统的目录结构、编译器的语法解析等。
二叉树实现以及相关算法
04-09
cout<<"****** 二叉树二叉链表结构测试程序 ******"<<endl; cout<<"* 0--退出 *"<<endl; cout<<"* 1--交互创建二叉树 *"<<endl; cout<<"* 2--文件创建二叉树 *"<<endl; cout<<"* 3--完全二叉树序列创建二叉树 *"<<endl; cout<<"* 4--打印二叉树 *"<<endl; cout<<"* 5--销毁二叉树 *"<<endl; cout<<"*--------------------------------------*"<<endl; cout<<"* 6--遍历二叉树（递归） *"<<endl; cout<<"* 7--遍历二叉树（非递归） *"<<endl; cout<<"* 8--求二叉树高度（深度） *"<<endl; cout<<"* 9--求结点层次 *"<<endl; cout<<"* 10-- 判定空树 *"<<endl; cout<<"* 11--求双亲结点 *"<<endl; cout<<"* 12--求孩子结点 *"<<endl; cout<<"* 13--求兄弟结点 *"<<endl; cout<<"* 14--查找结点 *"<<endl; cout<<"* 15--求结点数量
二叉树相关算法
much efforts, much luck
08-04 1254
二叉树类算法 一、二叉树的路径和：二叉树的每个节点为0-9的一个数字，根到叶子的一条路径拼成一个数，求所有路径形成的数字和 struct TreeNode { TreeNode* left; TreeNode* right; int value; }; int dfs(TreeNode* root, int sum) { if (root == nullptr) { return 0; } if (root->left ==
【数据结构】二叉树的操作算法
慢热型网友的博客
06-12 868
实现二叉树的如下操作，二叉树如下图所示。(采用二叉链存储结构实现) (1)输出二叉树b； (2)输出H节点的左、右孩子节点值； (3)输出二叉树的深度； (4)输出二叉树b的节点个数； (5)输出二叉树b的叶子节点个数。 具体效果如下： 实现二叉树的如下操作，先序遍历、中序遍历和后序遍历的递归算法，二叉树如下图所示。(采用二叉链存储结构实现) (1)采用括号表示法，构建如下二叉树，并输出二叉树b； (2)采用递归算法，输出二叉树的先序序列； (3)采用递归算法，输出二叉树的中序序列； (4)采用递归算法，
二叉树的常见算法
热门推荐
yhcuac
08-05 5万+
一.二叉树的遍历算法 二叉树的遍历可分为三种：先序遍历，中序遍历和后序遍历。 按照惯例，左孩子优先于右孩子，那么： - 先序遍历指的就是先访问本节点，再访问该节点的左孩子和右孩子； - 中序遍历指的就是：先访问左孩子，再访问本节点，最后访问右孩子； - 后序遍历指的就是：先访问左右孩子，最后访问本节点。 树的节点的数据结构常声明为： struct TreeNode { i...
实现二叉树各种基本操作的算法
李响
09-07 2527
#include<iostream> #include<cstdio> #include<malloc.h> using namespace std; #define maxsize 100 typedef char elemtype; typedef struct node { elemtype data; struct node* lchild; st...
二叉树相关算法实现
xxxxx
09-21 1348
二叉树打印所有节点 前序，中序，后序 public class Node { public int value; public Node left; public Node right; public Node(int value) { this.value = value; } } //前序递归 public void preOrder(Node head) { if(head ...
算法 - 二叉树的基本算法
weixin_40459875的博客
09-28 6188
目录 一、二叉树 二、二叉树的先序、中序、后序遍历 （一）、递归遍历 （二）、非递归遍历 （1）先序：头左右 （2）中序：左头右 （3）后序：左右头 三、实现二叉树的按层遍历 （一）、遍历-队列 （二）、求最大层的宽度 四、二叉树的序列化和反序列化 （一）、递归 （二）、按层 一、二叉树 图示： 结构： public class BtreeNode { public int value; public BtreeNode left; pub..
二叉树相关算法汇总（详细）
泛泛之素
06-05 1万+
二叉树基本知识 二叉树（Binary Tree）是n（n≥0）个有限元素的集合，该集合或者为空，或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树。 二叉树常见概念： 结点的度。结点所拥有的子树的个数称为该结点的度。 叶子结点。度为0的结点称为叶子结点，或者称为终端结点。 分支结点。度不为0的结点称为分支结点，或者称为非终端结点。一棵树的结点除叶子结点外，其余的都是分支结点。 左孩子、右孩子、双亲。树中一个结点的子树的根结点称为这个结
二叉树常用操作算法集、解释及注意事项
ljianhui的专栏
07-06 9266
二叉树是一种常用的数据结构，在程序中也经常需要使用二叉树，但是你所使用语言却并不一定提供了二叉树这种数据类型，所以为了方便使用，我们可以自己实现一个二叉树的数据类型。在需要时就像使用其他已定义的类型一样方便。 下面给出一些本人写的算法和解释（基于C语言），希望对读者写一个二叉树数据类型有所帮助。 0、递归的四条基本法则 由于二叉树中的算法大多使用递归来实现，而且使用递归实现也
二叉树操作算法详解
代码中还包含了一些其他未展示的二叉树操作，例如遍历（前序、中序、后序）、插入和删除等。这些操作是二叉树基本操作的核心，它们对于理解和处理二叉树至关重要。 - **前序遍历**：访问顺序为根-左-右，常用于复制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值