【数据结构】二叉树问题总结

于 2024-01-13 16:59:07 发布
阅读量1.3k 收藏 24
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64538862/article/details/133559027
版权

目录

1.二叉树前序遍历，中序遍历和后序的实现

2.层序遍历

3.求二叉树中的节点个数

4.求二叉树中的叶子节点个数

5.求二叉树的高度

6.求二叉树第k层节点个数

7.二叉树查找值为x的节点

8.单值二叉树

9.二叉树最大深度

10.翻转二叉树

11. 检查两颗树是否相同

12. 对称二叉树

13. 另一颗树的子树

14.二叉树的前序遍历

15.通过前序遍历的数组构建二叉树 

16.判断二叉树是否是完全二叉树

17.判断二叉树是否是平衡二叉树 

18.二叉树销毁  

1.二叉树前序遍历，中序遍历和后序的实现

我们回顾以下二叉树的遍历：

前序遍历（先序遍历）：访问根节点的操作发生在遍历其左右子树之前

中序遍历：访问根节点的操作发生在遍历其左右子树之间

后序遍历：访问根节点的操作发生在遍历其左右子树之后

二叉树的遍历通过递归实现，下图为二叉树前序的递归遍历图解：

从根节点开始，先遍历根节点，再遍历左子树，左子树的遍历又分为先遍历根节点再遍历左子树，以根左子树右子树的顺序递归遍历，直至根节点为NULL

前序递归遍历的参考代码如下：

#include<stdio.h>
#include<stdlib.h>

//快速构建一棵二叉树
typedef int DataType;
typedef struct TreeNode
{
	struct TreeNode* left;
	struct TreeNode* right;
	DataType data;
}TreeNode;

//创建节点
TreeNode* BuyNode(DataType x)
{
	TreeNode* newnode = (TreeNode*)malloc(sizeof(TreeNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

//快速构建一棵树
TreeNode* CreateBinaryTree()
{
	TreeNode* n1 = BuyNode(1);
	TreeNode* n2 = BuyNode(2);
	TreeNode* n3 = BuyNode(3);
	TreeNode* n4 = BuyNode(4);
	TreeNode* n5 = BuyNode(5);
	TreeNode* n6 = BuyNode(6);

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;

	return n1;
}

//二叉树的前序遍历
TreeNode* PreOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);

}

int main()
{
	TreeNode* root = CreateBinaryTree();
	PreOrder(root);

	return 0;
}

 输出结果如下：

同理，可以使用递归实现 中序遍历和后序遍历

//二叉树的中序遍历
TreeNode* InOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);

}
//二叉树的后序遍历
TreeNode* PostOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);

}

2.层序遍历

二叉树的层序遍历要基于队列实现，上一层节点出队，其孩子节点依次入队，依次访问直到队列为空

📖Note：

采用链式队列实现时，队列中每个元素的数据域存放的是二叉树节点的指针，类型为TreeNode* 

// 队列的定义
typedef struct QueueNode
{
    TreeNode* data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
}Queue;
 

// 层序遍历
void BinaryTreeLevelOrder(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    //根节点入队
    if (root)
    {
        QueuePush(&q, root);
    }
    //队列不为空时
    while (!QueueEmpty(&q))
    {
        //访问队头元素并出队
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        printf("%d", front->val);

        //队头元素的孩子节点入队
        if (front->left)
        {
            QueuePush(&q, front->left);
        }
        if (front->right)
        {
            QueuePush(&q, front->right);
        }
    }
    printf("\n");
    QueueDestroy(&q);
}

 队列相关操作如下：

//队列初始化
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
}
//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL && pq->tail == NULL;
}
//队列销毁
void QueueDestroy(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* del = cur;
        cur = cur->next;
        free(del);
    }
    pq->head = pq->tail = NULL;
}
//访问队头数据
TreeNode* QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->head->data;

}
//数据入队
void QueuePush(Queue* pq, TreeNode* x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    else
    {
        newnode->data = x;
        newnode->next = NULL;
    }
    //空队列时插入
    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    //非空队列时插入
    else
    {
        pq->tail->next = newnode;//链接新元素
        pq->tail = newnode;//更新队尾
    }
}
//数据出队
void QueuePop(Queue* pq)
{
    assert(pq);
    //空队列不能进行出队操作
    assert(!QueueEmpty(pq));
    //队列中只有一个元素
    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* del = pq->head;
        pq->head = pq->head->next;
        free(del);
        del = NULL;
    }
}

 

3.求二叉树中的节点个数

求一棵树中的节点个数，有两种解决思路

  1. 暴力求解，遍历计数
  2. 转换成子问题求解

暴力求解时，变量size的定义可能出现问题，定义1如下：

函数中直接定义size，每次递归调用函数size都被置0，所以最后的返回结果为1，不能求出二叉树的长度

//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	int size = 0;
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

定义2：将size定义成静态变量，但仍在函数内

这种定义方法解决了每次函数内递归size置0的问题，但是static定义的变量只有在第一次定义的时候才会初始化，所以当我们在其他函数中重复调用TreeSize函数时，size的值会累加

解决方法：将size定义成全局变量，每次调用函数前初始化size

//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	static int size = 0;
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

正确的定义与调用

#include<stdio.h>
#include<stdlib.h>
int size = 0;

//快速构建一棵二叉树
typedef int DataType;
typedef struct TreeNode
{
	struct TreeNode* left;
	struct TreeNode* right;
	DataType data;
}TreeNode;

//创建节点
TreeNode* BuyNode(DataType x)
{
	TreeNode* newnode = (TreeNode*)malloc(sizeof(TreeNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

//快速构建一棵树
TreeNode* CreateBinaryTree()
{
	TreeNode* n1 = BuyNode(1);
	TreeNode* n2 = BuyNode(2);
	TreeNode* n3 = BuyNode(3);
	TreeNode* n4 = BuyNode(4);
	TreeNode* n5 = BuyNode(5);
	TreeNode* n6 = BuyNode(6);

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;

	return n1;
}
//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

int main()
{
	TreeNode* root = CreateBinaryTree();
	printf("%d\n", TreeSize(root));
	size = 0;//初始化size
	printf("%d\n", TreeSize(root));

	return 0;
}

转换成子问题：一棵二叉树节点的个数 = 左子树节点的个数+右子树节点的个数+1

左子树和右子树节点的个数也是其对于的左右子树节点个数之和+1

int TreeSize(TreeNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

这种求解方法避免了定义变量的问题 

4.求二叉树中的叶子节点个数

求一棵树中叶子节点的个数，首先要清楚如何判断一个节点为叶子节点：

一个叶子节点的左右孩子都为空

求解叶子节点的个数问题也可以转换成子问题，一棵树中的叶子节点的个数为左子树中叶子节点的个数+右子树中叶子节点的个数 

//二叉树叶子节点的个数
int TreeLeafSize(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

5.求二叉树的高度

求解二叉树高度的问题转换成子问题：一棵树的高度 = max{左子树高度，右子树高度}+1

//二叉树的高度
int TreeHeight(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

	int left = TreeHeight(root->left);
	int right = TreeHeight(root->right);
	return  left > right ? left + 1 : right + 1;

}

6.求二叉树第k层节点个数

求一棵树的第k层节点的个数转换成子问题：一棵树第k层节点的额个数 = 左子树第k-1层节点个数+右子树第k-1层节点个数

//二叉树第k层节点的个数
int TreeKLevel(TreeNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}

	k = k - 1;
	return TreeKLevel(root->left, k) + TreeKLevel(root->right, k);
	
}

7.二叉树查找值为x的节点

查找值为x的节点转换成子问题：先检查根节点是否符合条件，不符合条件再去左子树找，左子树没找到去右子树查找，右子树没找到则返回NULL，载其中任何一个环节中如果中找到值为x的节点，则返回

//二叉树查找值为x的节点
TreeNode* TreeFind(TreeNode* root, int x)
{
	if(root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}

	//在左子树查找
	TreeNode* ret = TreeFind(root->left, x);
	if (ret)
	{
		return ret;
	}
	//左子树没找到，再在右子树查找
	ret = TreeFind(root->right, x);
	if (ret)
	{
		return ret;
	}

	//整棵树都没找到
	return NULL;
}

 8.单值二叉树

单值二叉树题目链接：. - 力扣（LeetCode）

题目分析：

对于一棵单值二叉树，当其根节点的值等于左右孩子的值时，问题就可以转换成子问题，判断它的左右子树是否为单值二叉树，其左右子树的判断又重复之前的操作

📖Note：

对于一个节点，可能存在四种情况：

  • 有左右孩子
  • 只有左孩子
  • 只有右孩子
  • 没有孩子（叶子节点）

有左孩子节点时，父节点与左孩子节点比较，不相等返回false，相等则比较父节点与右孩子节点，不相等则返回false，相等则返回true

bool isUnivalTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    //有左右孩子
    if (root->left && root->left->val != root->val)
    {
        return false;
    }
    if (root->right && root->right->val != root->val)
    {
        return false;
    }

    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

9.二叉树最大深度

二叉树最大深度：. - 力扣（LeetCode）

题目分析：

当二叉树为空时，其最大深度为0

当二叉树不为空时，求二叉树的最大深度转换成子问题为1加左右子树中深度较大者

int maxDepth(struct TreeNode* root) {
    if(root == NULL)
    {
        return 0;
    }
    int leftmax = maxDepth(root->left);
    int rightmax = maxDepth(root->right);
    return  leftmax > rightmax ? leftmax + 1 : rightmax + 1;
}

10.翻转二叉树

翻转二叉树题目链接：226. 翻转二叉树 - 力扣（LeetCode）

题目分析：

翻转二叉树有两种方法

1️⃣使用递归实现

先序遍历二叉树的框架：先交换根节点的左右子树，再分别递归左子树右子树，即可实现二叉树的翻转

struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return root;
    }
    //交换左右子树
    struct TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    invertTree(root->left);
    invertTree(root->right);

    return root;
}

2️⃣层序遍历法

层序遍历法基于队列实现

从根节点开始，层序遍历二叉树，依次翻转每一个节点的左右子树

struct TreeNode* invertTree(struct TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    //根节点入队
    if (root)
    {
        QueuePush(&q, root);
    }
    //队列不为空时
    while (!QueueEmpty(&q))
    {
        //访问队头元素并交换其左右子树
        struct TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        struct TreeNode* tmp = front->left;
        front->left = front->right;
        front->right = tmp;

        //队头元素的孩子节点入队
        if (front->left)
        {
            QueuePush(&q, front->left);
        }
        if (front->right)
        {
            QueuePush(&q, front->right);
        }
    }
    return root;
    QueueDestroy(&q);
}

11. 检查两颗树是否相同

检查两颗树是否相同题目链接：. - 力扣（LeetCode）

题目分析：

两棵二叉树相同，不仅结构上相同，而且对应节点的值相同

1️⃣对于两颗空二叉树，则它们是相同的树

2️⃣对于一颗空树和一颗非空树，它们是不相同的树

3️⃣对于两颗非空树，先判断它们根节点的值是否相同，不相同则它们是不相同的树，相同则转换成子问题：依次比较它们的左右子树。当左右子树都相同时它们为相同的树

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    //都为空树
    if (p == NULL && q == NULL)
    {
        return true;
    }
    //一个空树一个非空树
    if (p == NULL || q == NULL)
    {
        return false;
    }
    //两个非空树
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

12. 对称二叉树

对称二叉树题目链接：. - 力扣（LeetCode）

题目分析：

1️⃣对于一颗空树和只有一个节点的树，其为对称的树

2️⃣对于不止一个节点的树，如果其为对称的树，则其右子树翻转后和左子树是相同的树，这里需要用到我们已经写过的翻转二叉树和判断相同的树的函数

 //相同的二叉树
bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    //都为空树
    if (p == NULL && q == NULL)
    {
        return true;
    }
    //一个空树一个非空树
    if (p == NULL || q == NULL)
    {
        return false;
    }
    //两个非空树
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);

}
//翻转二叉树
struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return root;
    }
    //交换左右子树
    struct TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    invertTree(root->left);
    invertTree(root->right);

    return root;
}
//对称二叉树
bool isSymmetric(struct TreeNode* root) {
    //空树
    if (root == NULL)
    {
        return true;
    }
    //只有一个节点的树
    if (root->left == NULL && root->right == NULL)
    {
        return true;
    }
    //有左右孩子,且左右孩子为相同的树
    invertTree(root->right);
    return isSameTree(root->left,root->right);
}

13. 另一颗树的子树

另一颗树的子树题目链接：572. 另一棵树的子树 - 力扣（LeetCode）

 

题目分析：

1️⃣当一棵树为空时，任何树都不是其子树

2️⃣特殊情况：两棵树相同时，一颗是另一颗的子树

3️⃣当两棵树不相同时，递归判断主树的左子树与右子树是否与已知子树相同，只要左子树或右子树中存在与已知子树相同的树，则已知子树为主树的子树

//另一棵树的子树
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    if (root == NULL)
    {
        return false;
    }
    if (isSameTree(root,subRoot))
    {
        return true;
    }
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

14.二叉树的前序遍历

二叉树的前序遍历题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

​

题目分析：

本题的前序遍历不是单纯的打印，而是通过函数接口返回一个前序遍历序列数组（该数组是动态开辟的）

首先，要动态开辟数组，我们需要知道要开辟数组的大小，即二叉树节点的个数，调用题目3的函数接口TreeSize即可

然后，先序遍历二叉树，将二叉树节点按先序遍历的顺序依次存入我们动态开辟的数组，返回数组首元素地址即可

📖Note：

这里我们需要对先序遍历二叉树的函数接口增加一个参数，整型指针pi，用来指示每次存储的数组下标。如果在PreOrder函数内定义下标指针，每次递归都会使其初始化为0，所以采用参数的形式定义。

//求二叉树节点个数
int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//二叉树的前序遍历
void PreOrder(struct TreeNode* root, int* a, int* pi)
{
    if (root == NULL)
    {
        return;
    }
    //static int i = 0;
    a[*pi] = root->val;
    printf("a[%d] = %d\n", pi, a[*pi]);
    ++(*pi);

    PreOrder(root->left, a, pi);
    PreOrder(root->right, a, pi);
}

//二叉树的前序遍历，返回序列数组
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    //开辟数组空间
    int n = TreeSize(root);
    //printf("%d\n",n);
    int* a = (int*)malloc(sizeof(int) * n);

    int i = 0;
    PreOrder(root, a, &i);

    *returnSize = n;
    return a;
}

15.通过前序遍历的数组构建二叉树 

 题目链接：二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

题目分析：

对已知字符串序列进行遍历，遇到空节点（#代表空节点）则访问下一个，需要对非空节点开辟空间并为其数据域赋值，递归构造左子树和右子树即可

#include <stdio.h>
#include<stdlib.h>

typedef char BTDataType;
typedef struct BinaryTreeNode
{
    BTDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}BTNode;
//由前序序列构造二叉树
BTNode* BinaryTreeCreate(BTDataType* a,int* pi)
{
    if(a[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    BTNode* root = (BTNode*)malloc(sizeof(BTNode));
    if(root == NULL)
    {
        perror("malloc fail\n");
        return NULL;
    }
    root->data = a[*pi];
    (*pi)++;
    root->left = BinaryTreeCreate(a, pi);
    root->right = BinaryTreeCreate(a, pi);
    return root;
}
//中序遍历
void InOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    InOrder(root->left);
    printf("%c ",root->data);
    InOrder(root->right);
}

int main() {
    char str[100];
    scanf("%s", str);
    int i = 0;
    BTNode* root = BinaryTreeCreate(str, &i);
    InOrder(root);

    return 0;
}

16.判断二叉树是否是完全二叉树

一颗完全二叉树可能为满二叉树，也可能非满，此时最后一层的节点连续排列

判断方法：层序遍历二叉树，将所有节点依次入队，再依次出队，遇到NULL，则跳出循环，判断后续队列中是否存在非空节点，不存在则为完全二叉树，否则为非完全二叉树。

//判断一棵树是否为完全二叉树
int BinaryTreeComplete(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q,root);
    }
    //节点入队
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        if (front == NULL)
        {
            break;
        }
        QueuePush(&q, root->left);
        QueuePush(&q, root->right);

    }
    //判断后续队列中是否有非空节点，有则不是完全二叉树
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        //存在非空元素
        if (front != NULL)
        {
            QueueDestroy(&q);
            return false;
        }
    }
    QueueDestroy(&q);
    return true;
}

17.判断二叉树是否是平衡二叉树 

平衡二叉树题目链接：110. 平衡二叉树 - 力扣（LeetCode）

 

题目分析：

对于一颗空树和只有一个节点的树，其为平衡二叉树

平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1

因此判断每个节点的左右左子树的高度差，调用题目9中二叉树的高度计算函数maxdepth

//二叉树的最大高度
int maxDepth(struct TreeNode* root) {
    if (root == NULL)
    {
        return 0;
    }
    int leftmax = maxDepth(root->left);
    int rightmax = maxDepth(root->right);
    return  leftmax > rightmax ? leftmax + 1 : rightmax + 1;
}

//平衡二叉树
bool isBalanced(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    if (root->left == NULL && root->right == NULL)
    {
        return true;
    }
    int left_heigh = maxDepth(root->left);
    int right_heigh = maxDepth(root->right);
    if (left_heigh - right_heigh == -1 || left_heigh - right_heigh == 0 
         || left_heigh - right_heigh == 1)
    {
        if(isBalanced(root->left) && isBalanced(root->right))
            return true;
    }
    return false;
}

18.二叉树销毁  

1️⃣对于一颗空树，直接返回即可

2️⃣对于一颗只有一个节点的树，直接释放该节点所占用的空间

3️⃣二叉树的销毁转换成分治子问题：采用后续遍历二叉树的框架，对每一个节点，先释放左子树所占用的空间，再释放右子树所占用的空间，最后释放根节点所占用的空间

//二叉树的额销毁
void BinaryTreeDestroy(TreeNode* root)
{
    if (root == NULL)
    {
        return;
    }
    
    BinaryTreeDestroy(root->left);
    BinaryTreeDestroy(root->right);
    free(root);
}
李斯啦果
关注
  • 18
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
二叉树的前中后遍历
weixin_51746436的博客
11-22 526
一.什么是二叉树？ 二叉树是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 二.二叉树的实现代码 public class Mytree { private Node root; public void add(int x) { Node a=new Node(); a.data=x; if(root==null) {
轻松搞定面试中的二叉树题目
热门推荐
计算机的艺术
08-29 26万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7518888 树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关
数据结构中二叉树实现及部分操作
Amber的博客
12-02 4911
谈二叉树之前，我们先来看看树的定义树：由N(N>=0)个结点构成的集合。 对N>1的树： 1、有一个特殊的结点，称为根结点，根节点没有前驱结点 2、除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。 因此，树是递归定义的。 如下
数据结构——二叉树
02-06
另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过左右子树情况以及总结点数）、统计二叉树中所有结点的个数的算法
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
数据结构课程设计报告-二叉树的遍历.docx
03-07
数据结构课程设计报告-二叉树的遍历.docx
数据结构二叉树的实验报告
05-09
数据结构树的实验报告 可以保证：绝对原创，有很大的参考价值！
数据结构与算法总结.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
二叉树基础知识总结
小拳头的博客
03-24 10万+
题外话昨晚面了腾讯，问了一个完全二叉树的题，竟然让我算了快10分钟，因为等比公式记错了导致最后用最原始的方法推算结果也没算对，一下子就懵了。本来精心准备了1周的面试，最后因为自己基础知识记忆不牢固导致了悲剧。不管怎样，还是要继续查漏补缺，准备将数据结构再细细看一遍，先来补上二叉树的这个漏洞吧。 一、树的定义树是一种数据结构，它是由n（n&gt;=1）个有限结点组成一个具有层次关系的集合。 树具有的...
数据结构学习之二叉树(理论篇)
落魄影子
01-16 2万+
注：本文的主要目的是为了记录自己的学习过程，也方便与大家做交流。转载请注明来自： http://blog.csdn.net/ab198604         一、什么是树？         在前几篇的博文中主要讲述的是链式存储这种数据结构，它们的用途非常广泛，但是在实际的应用中，还存在着另一种非常重要的数据结构，它就是树。树的结构示意图如下所示：         上图就是一种数
数据结构与算法(二叉树)
w5201314ws6123的博客
01-12 842
1&gt;前面我们已经讲了线性结构，栈，队列，链表等线性结构，今天我们来讲一下一种非常重要的非线性结构:树  解释:你有没有发现非线性结构"树"和我们现实生活中的"树"很相似，这里面每一个点都是树的节点,节点与节点存在这某种关系,比如节点与节点相连接的关系叫做父子节点 解释:B,C，D的父节点是A，B,C,D被叫做兄弟节点，B,C,D是A的子节点,没有父子节点的节点叫做根节点,如图E,...
数据结构与算法--二叉树的深度问题
0102的博客
06-25 455
二叉树的深度 题目：输入一颗二叉树的根，求该树的深度。从根节点到叶子节点一次进过的节点形成的一条路径，最长的路径的长度为树的深度。 如下图中二叉树的额深度4，因为从根节点A到叶子节点的路径中有4个节点A B E J 问题中定义了一种树深度的计算规则，我们根据这个定义去得到树所有的路径，也就得到了最长的额路径。在我们之前的文章：数据结构与算法–面试必问AVL树原理及实现文章中，我们对二叉搜索树的具体实现方案有详细的说明，其中二叉搜索树平衡条件是左右子树的高度差不能超过1 ，和我们当前要求是一致的，我们
数据结构—二叉树相关概念及经典面试题
3166375975@的博客
09-28 1035
二叉树概念 一棵二叉树是结点的有限集合，该集合或者为空， 或者是由根结点加上两棵分别称为左子树和右子树的二叉树构成 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于2的结点 二叉树的子树有左右之分，其子树的次序不能颠倒 满二叉树、完全二叉树 满二叉树：在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子节点都在同一层上 完全二叉树： 如果一棵具有N个结点的二叉...
数据结构之二叉树
qq_45810848的博客
08-18 103
Before：树 树形结构可以说是一种很重要的非线性结构了，其中以树和二叉树最为常用。 树（Tree）是具有n(n≥0)个结点的集合，在一颗非空树中，其具备有如下几个特征： 有且仅有一个特定的称为**根(Root)**的结点。 当n>1时，其余结点可分为m(m>0)个互不相交的有限集T₁ ,T₂ ,…, Tₘ，其中每个集合本身又是一棵树，并且称为根的子树(Sub Tree)。如下图中的T₂ ={C,G}就是根A的一个子集。 因树下有树，树下还有树。可知，树的结构定义是一个递归的定义，即在.
数据结构-二叉树 问题
superjeweltobey的专栏
12-26 415
   #define null 0   #include "stdio.h"   typedef char datatype;   typedef struct tn  {datatype data;   struct tn *lc,*rc;   }Bnode,*Btree;   void createbtree(Btree *t)    /*建立一个树*/       { datatyp
数据结构——二叉树遍历和常见问题
weixin_57133901的博客
04-22 3002
二叉树遍历 二叉树常见问题
【数据结构】二叉树常见面试题
如风逝去
08-07 6015
1、创建二叉树 树的结构如下： 这里我们创建二叉树用的是静态创建即不是每次从标准输入读入数据然后插入树中，而是将定义好的一个序列，也就是一个数组构建一棵树，这里采用的是递归创建，首先来看一下参数，首先传进来的就是根结点，然后是要构建树的序列然后是数组下标索引，负责遍历整个数组，然后是数组的大小，然后是无效值，遇到无效值表示当前结点为空，就返回上一层函数调用，递归程序的出口是index...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值