1.树概念及结构(了解)
1.1树的概念
- 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6
-
终端或叶节点节点：度为0的节点称为叶节点； 如上图：B、C、H、I...等节点为叶节点
-
非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G...等节点为分支节点
-
兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图： B、C是兄弟节点
-
树的度 ：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6
-
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；(也有的是从0开始)
-
树的高度或深度 ：树中节点的最大层次； 如上图：树的高度为4
-
森林：由m（m>0）棵互不相交的多颗树的集合称为森林
1.2树的表示
表示法一：顺序表存孩子的指针
struct TreeNode
{
int data;
struct TreeNode* child1;
struct TreeNode* child2;
};表示法二：左孩子右兄弟
typedef int DataType;
struct Node
{
struct Node* _firstChild1;//第一个孩子结点
struct Node* _pNextBrother;// 指向其下一个兄弟结点
DataType _data;// 结点中的数据域
};
表示法三：双亲表示法
- 节点存双亲的下标
2.二叉树概念及结构
2.1特殊的二叉树
- 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，
2^0+2^1+2^2+2^3+......2^(h-1)=N，2^h-1=N,h=以2为底 N+1 的对数， -
完全二叉树：最后一层从左往右都是连续的，且除了最后一层其他层都是满的
设最后一层缺失x个
2^0+2^1+2^2+2^3+......2^(h-1)-x=N， 2^h-1-x=N ,h=以2为底 N+1+x 的对数，
2.2二叉树的性质
- 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
- 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
- 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,
n0＝n2 ＋1 - 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=logN(近似处理)
3.二叉树性质相关选择题练习
1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
A
不存在这样的二叉树
B
200
C
198
D
199
解：
由n0 = n2 + 1得200，
选B
2.
在具有
2*n
个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n
+
1
C n
-
1
D n
/
2
解：n0+n1+n2=2*n
n0=n2+1
n0=n2+1
化简得：2*n0-1+n1=2*n，
又由完全二叉树最后一层的性质得，度为1的只有0个，或只有1一
个，这就意味着n1=1，n0=n， 选A
个，这就意味着n1=1，n0=n， 选A
3.
一棵完全二叉树的节点数位为
531
个，那么这棵树的高度为（ ）
A
11
B
10
C
8
D
12
解：由2^h-1-x=531,
且x的取值范围 [1,2^(h-1)]，将选项带进去，得到只有10最符合题意
选B
4.二叉树链式结构的实现
4.1 前中后序遍历PrevOrder && InOrder && PostOrder
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
void PrevOrder(BTNode* root) {
if (root == NULL) {
//printf("NULL ");
return;
}
printf("%c ", root->data);
PrevOrder(root->left);
PrevOrder(root->right);
}
void InOrder(BTNode* root)
{
if (root == NULL) {
//printf("NULL ");
return;
}
InOrder(root->left);
printf("%c ", root->data);
InOrder(root->right);
}
void PostOrder(BTNode* root)
{
if (root == NULL) {
//printf("NULL ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%c ", root->data);
}
BTNode* BuyBTNode(BTDataType ch)
{
BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
if (tmp == NULL) {
return NULL;
}
tmp->data = ch;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
int main()
{
BTNode* A = BuyBTNode('A');
BTNode* B = BuyBTNode('B');
BTNode* C = BuyBTNode('C');
BTNode* D = BuyBTNode('D');
BTNode* E = BuyBTNode('E');
A->left = B;
A->right = C;
B->left = D;
B->right = E;
PrevOrder(A);
printf("\n");
InOrder(A);
printf("\n");
PostOrder(A);
printf("\n");
return 0;
}
4.2 求节点个数TreeSize
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyBTNode(BTDataType ch)
{
BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
if (tmp == NULL) {
return NULL;
}
tmp->data = ch;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
int TreeSize(BTNode* root)
{
// 后序遍历
// 根节点 + 1
return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
int main()
{
BTNode* A = BuyBTNode('A');
BTNode* B = BuyBTNode('B');
BTNode* C = BuyBTNode('C');
BTNode* D = BuyBTNode('D');
BTNode* E = BuyBTNode('E');
A->left = B;
A->right = C;
B->left = D;
B->right = E;
printf("%d\n", TreeSize(A));
return 0;
}
- 这里有后序的思想
4.3 求叶子节点个数TreeLeafSize
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyBTNode(BTDataType ch)
{
BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
if (tmp == NULL) {
return NULL;
}
tmp->data = ch;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
// 叶子节点的个数
int TreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
if (root->left == NULL && root->right == NULL)
return 1;
//返回左右叶子节点的个数，不算自己
return TreeLeafSize(root->left)
+ TreeLeafSize(root->right);
}
int main()
{
BTNode* A = BuyBTNode('A');
BTNode* B = BuyBTNode('B');
BTNode* C = BuyBTNode('C');
BTNode* D = BuyBTNode('D');
BTNode* E = BuyBTNode('E');
A->left = B;
A->right = C;
B->left = D;
B->right = E;
printf("%d\n", TreeLeafSize(A));
return 0;
}
4.4 求某一层节点个数TreeKLevel
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyBTNode(BTDataType ch)
{
BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
if (tmp == NULL) {
return NULL;
}
tmp->data = ch;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
//某一层节点的个数
int TreeKLevel(BTNode* root, int k)
{
assert(k >= 1);
if (root == NULL)
return 0;
if (k == 1)
return 1;
return TreeKLevel(root->left, k - 1)
+ TreeKLevel(root->right, k - 1);
}
int main()
{
BTNode* A = BuyBTNode('A');
BTNode* B = BuyBTNode('B');
BTNode* C = BuyBTNode('C');
BTNode* D = BuyBTNode('D');
BTNode* E = BuyBTNode('E');
A->left = B;
A->right = C;
B->left = D;
B->right = E;
printf("%d\n", TreeKLevel(A,3));
return 0;
}- 转换成子问题：求左子树的第k-1层+求右子树的第k-1层
- 在这段代码中k会不断的减减,只有减到这层的时候才返回1
4.5 查找某一节点TreeFind
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyBTNode(BTDataType ch)
{
BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
if (tmp == NULL) {
return NULL;
}
tmp->data = ch;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
//查找某一个节点
BTNode* TreeFind(BTNode* root, BTDataType x)
{
//出口
if (root == NULL)
return NULL;
//出口
if (root->data == x)
return root;
//不断的接近出口
BTNode* ret1 = TreeFind(root->left, x);
if (ret1)
return ret1;
//不断的接近出口
BTNode * ret2 = TreeFind(root->right, x);
if (ret2)
return ret2;
return NULL;
}
int main()
{
BTNode* A = BuyBTNode('A');
BTNode* B = BuyBTNode('B');
BTNode* C = BuyBTNode('C');
BTNode* D = BuyBTNode('D');
BTNode* E = BuyBTNode('E');
A->left = B;
A->right = C;
B->left = D;
B->right = E;
BTNode* Pfind = TreeFind(A, 'E');
printf("%c", Pfind->data);
return 0;
} 
- BTNode* ret1 = TreeFind(root->left, x);这里之所以设置ret1，主要是因为找到了的话，就可以直接返回，避免重复递归
- 在函数递归中每次return都是返回给上一层，并不是直接就结束了
4.6 求树的深度TreeDepth
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyBTNode(BTDataType ch)
{
BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
if (tmp == NULL) {
return NULL;
}
tmp->data = ch;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
int TreeDepth(BTNode* root)
{
if (root == NULL)
return 0;
//统计左右子树的深度
int leftDepth = TreeDepth(root->left);
int rightDepth = TreeDepth(root->right);
// 这里+1,是为了算上root节点
return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}
int main()
{
BTNode* A = BuyBTNode('A');
BTNode* B = BuyBTNode('B');
BTNode* C = BuyBTNode('C');
BTNode* D = BuyBTNode('D');
BTNode* E = BuyBTNode('E');
A->left = B;
A->right = C;
B->left = D;
B->right = E;
printf("%d", TreeDepth(A));
return 0;
}
- 这个问题的子问题就是：最大深度=左右孩子大的那个加1
5. 层序遍历——非递归实现
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>
struct BinaryTreeNode;//前置声明
typedef struct BinaryTreeNode* QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;// 存的是二叉数的节点
}QNode;
typedef struct Queue
{
QNode* head;
QNode* tail;
}Queue;
void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
printf("malloc fail\n");
exit(-1);
}
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(pq->head);
if (pq->head->next == NULL)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->tail->data;
}
int QueueSize(Queue* pq)
{
assert(pq);
int size = 0;
QNode* cur = pq->head;
while (cur)
{
++size;
cur = cur->next;
}
return size;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
//--------------------------------------------
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyBTNode(BTDataType ch)
{
BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
if (tmp == NULL) {
return NULL;
}
tmp->data = ch;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
void LevelOrder(BTNode* root)
{
// 核心思路：上一层出的时候带下一层节点进
Queue q;
QueueInit(&q);
if (root)
QueuePush(&q, root);//首先存入一个节点
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
printf("%c ", front->data);
if (front->left)
{
QueuePush(&q, front->left);
}
if (front->right)
{
QueuePush(&q, front->right);
}
}
}
int main()
{
BTNode* A = BuyBTNode('A');
BTNode* B = BuyBTNode('B');
BTNode* C = BuyBTNode('C');
BTNode* D = BuyBTNode('D');
BTNode* E = BuyBTNode('E');
A->left = B;
A->right = C;
B->left = D;
B->right = E;
LevelOrder(A);
return 0;
}
- 利用队列的先进先出的特性
- 核心思路:根节点出的时候,把它的左右子树节点带进去
6. 哈夫曼树(了解)
482
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
