算法给小码农链式二叉树-----一根草可斩星辰

2024-01-04 21:59
文章标签 算法 二叉树 小码 链式 一根 星辰

本文主要是介绍算法给小码农链式二叉树-----一根草可斩星辰，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 链式二叉树
        • 那么链式二叉树有什么好的地方呢
    • 二叉树的遍历
      • 前序、中序以及后序遍历
      • 按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：（上图为例图）（前中后访问根的时机不一样）
      • 分治
    • 二叉树
      • 二叉树节点
      • 我们把上面的树建好
      • 二叉树前序遍历
      • 二叉树中序遍历
      • 二叉树后序遍历
      • 二叉树节点个数
        • 次数用传址的方式
        • 次数用返回值的方式（假如我是代码我必然要嫁给这条代码）
      • 二叉树叶子节点个数
      • 二叉树第k层节点个数
      • 二叉树深度/高度
      • 二叉树查找值为x的节点
      • 二叉树层序遍历
      • 判断二叉树是否是完全二叉树BinaryTreeComplete
      • 二叉树销毁BinaryTreeDestory
    • 代码
      • BinaryTree.h
      • BinaryTree.c
      • test.c

在这里插入图片描述

链式二叉树

我们需要明白一点，就是普通的二叉树增删查改没有什么价值，因为普通二叉树用来存数据复杂且不方便

那么链式二叉树有什么好的地方呢

==价值体现：==在他的基础之上，增加一些性质，才有意义

1.搜索二叉树 ：最多查找高度次—>时间复杂度O(N)—>单链树也就引出平衡二叉树—>AVL树和红黑树

2.Huffman 树（以后再说，反正不是现在了解的）

我们不关注普通二叉树的增删查改，我们关注递归遍历结构

1.为后面学习更有用树打基础

2.很多oj题结构普遍二叉树

二叉树被分成 根 左子树 右子树

二叉树的遍历

前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓==二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。==访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

image-20211112211723351

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：（上图为例图）（前中后访问根的时机不一样）

image-20211112213707848

1.前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。根 左子树 右子树

上图前序遍历的顺序是：A B D NULL NULL NULL C E NULL NULL F NULL NULL只有把空放进去才能真正的知道思想，那些不加 空的就是耍流氓，没错说的就是你们老师，对你们耍流氓

2.中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。左子树 根 右子树

上图中序遍历的顺序是：NULL D NULL B NULL A （这时候想访问C就得访问E）NULL E NULL C NULL F NULL

3.后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。左子树 右子树 根

上图后序遍历的顺序是：NULL NULL D NULL B NULL NULL E NULL NULL F C A

分治

这里我们用的思想是分治的思想，分而治之-----大事化小，小事化了

二叉树

二叉树节点

//二叉树数据类型
typedef char BTDataType;
//二叉树节点
typedef struct BinaryTreeNode
{struct BinaryTreeNode* left;struct BinaryTreeNode* right;BTDataType data;
}BTNode;

我们把上面的树建好

//创建树 我们不学二叉树的增删查改原因就在这，我们想要啥树自己链一个就行，没必要增删查改
BTNode* CreatBinaryTree()
{BTNode* nodeA = BuyNode('A');BTNode* nodeB = BuyNode('B');BTNode* nodeC = BuyNode('C');BTNode* nodeD = BuyNode('D');BTNode* nodeE = BuyNode('E');BTNode* nodeF = BuyNode('F');nodeA->left = nodeB;nodeA->right = nodeC;nodeB->left = nodeD;nodeC->left = nodeE;nodeC->right = nodeF;return nodeA;
}

二叉树前序遍历

image-20211113085631295

这张图我实际上是想通过左右与上下滚动联合操作来截图的，然后我就找几个小时，基本能找的都找了，全网没有左右滚动截图的软件基本全是截图后窗口亮，不可以操作外面的滚动条，就算能操作也不可以左右滚动截图

//二叉树前序遍历
void PreOrder(BTNode* root)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{return;}printf("%c ",root->data);//递归左树PreOrder(root->left);//递归右树PreOrder(root->right);
}

二叉树中序遍历

image-20211113152651694

我故意写成一个窗口的宽度，不然会很麻烦

image-20211113171127588

//二叉树中序遍历
void InOrder(BTNode* root)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{//想打印空也可以printf("NULL ");return;}//不为空 递归左树InOrder(root->left);//打印数据printf("%c ",root->data);//递归右树InOrder(root->right);
}

二叉树后序遍历

image-20211113183048915

//二叉树后序遍历
void PostOrder(BTNode* root)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{//想打印空也可以printf("NULL ");return;}//不为空 递归左树PostOrder(root->left);//递归右树PostOrder(root->right);//打印数据printf("%c ", root->data);
}

二叉树节点个数

次数用传址的方式

image-20211113191511501

//二叉树节点个数
void BinaryTreeSize(BTNode* root,int* pn)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{return;}(*pn)++;BinaryTreeSize(root->left, pn);BinaryTreeSize(root->right, pn);
}
次数用返回值的方式（假如我是代码我必然要嫁给这条代码）

image-20211113193430719

//二叉树节点个数
int BinaryTreeSize(BTNode* root)
{return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right)+1;
}

二叉树叶子节点个数

image-20211113232154579

//二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{if (!root)//空树返回0return 0;if (!(root->left) && !(root->right))return 1;return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

二叉树第k层节点个数

image-20211114000025087

//二叉树第k层节点个数
int BinaryTreeLevelSize(BTNode* root, int k)
{if (!root)return 0;if (1 == k)return 1;//root不等于空，k也不等于1，说明root这棵树的第k层节点在子树里面//转换成求左右子树的第k-1层节点数量return BinaryTreeLevelSize(root->left, k - 1) + BinaryTreeLevelSize(root->right, k - 1);
}

二叉树深度/高度

image-20211114005007897

//二叉树深度/高度
int BinaryTreeDepth(BTNode* root)
{if (!root)return 0;//把递归的数用变量保存起来，减少资源的消耗int leftDepth = BinaryTreeDepth(root->left);int rightDepth = BinaryTreeDepth(root->right);return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

二叉树查找值为x的节点

image-20211114013914115

//二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{if (!root)return NULL;if (root->data == x)return root;BTNode* leftRet = BinaryTreeFind(root->left, x);if (leftRet)return leftRet;BTNode* rightRet = BinaryTreeFind(root->right, x);if (rightRet)return rightRet;//上面都没进就打印空return NULL;
}

二叉树层序遍历

image-20211117085251571

//二叉树层序遍历   不需要用递归，用队列就可以解决
void BinaryTreeLevelOrder(BTNode* root)
{//空就返回if (!root)return;//创建一个队列Queue q;//队列初始化QueueInit(&q);//把root放进队列QueuePush(&q,root);//队空就跳出来while (!QueueErase(&q)){//把队头取出来放准备拿里面的dataBTNode* front = QueueFront(&q);//再出队QueuePop(&q);//打印printf("%c ", front->data);//带左孩子进队if (front->left)QueuePush(&q,front->left);//带右孩子进队if (front->right)QueuePush(&q, front->right);}printf("\n");//和队列初始化的队列销毁QueueDestroy(&q);
}

判断二叉树是否是完全二叉树BinaryTreeComplete

image-20211118000032718

// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{Queue q;QueueInit(&q);QueuePush(&q, root);while (!QueueErase(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);//出到空跳出if (!front)break;else{QueuePush(&q, front->left);QueuePush(&q, front->right);}}//遇到空了以后，检查队列中剩下的节点//1.剩下全是空，则是完全二叉树//2.剩下的存在非空，则不是完全二叉树while (!QueueErase(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);//出到非空就不是完全二叉树if (front){//这里最容易忘记return之前要对销毁QueueDestroy(&q);return false;}}QueueDestroy(&q);return true;
}

二叉树销毁BinaryTreeDestory

image-20211120002929144

//二叉树销毁
void BinaryTreeDestory(BTNode* root)
{if (!root)return;BinaryTreeDestory(root->left);BinaryTreeDestory(root->right);free(root);
}

代码

BinaryTree.h

#pragma once#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>#define CountMode 0//二叉树数据类型
typedef char BTDataType;
//二叉树节点
typedef struct BinaryTreeNode
{struct BinaryTreeNode* left;struct BinaryTreeNode* right;BTDataType data;
}BTNode;//二叉树前序遍历
extern void PreOrder(BTNode* root);
//二叉树中序遍历
extern void InOrder(BTNode* root);
//二叉树后序遍历
extern void PostOrder(BTNode* root);
//获得节点函数
extern BTNode* BuyNode(BTDataType x);
#if CountMode
//二叉树节点个数
extern void BinaryTreeSize(BTNode* root, int* pn);
#elif !CountMode
//二叉树节点个数
extern int BinaryTreeSize(BTNode* root);
#endif
//二叉树叶子节点个数
extern int BinaryTreeLeafSize(BTNode* root);
//二叉树第k层节点个数
extern int BinaryTreeLevelSize(BTNode* root,int k);
//二叉树深度/高度
extern int BinaryTreeDepth(BTNode* root);
//二叉树查找值为x的节点
extern BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
//二叉树层序遍历   
extern void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
extern bool BinaryTreeComplete(BTNode* root);
//二叉树销毁
extern void BinaryTreeDestory(BTNode* root);

BinaryTree.c

#define _CRT_SECURE_NO_WARNINGS 1#include"BinaryTree.h"
#include"Queue.h"//获得节点函数
BTNode* BuyNode(BTDataType x)
{//创建二叉树节点BTNode* node = (BTNode*)malloc(sizeof(BTNode));//检查是否成功创建assert(node);//把数据放到节点里node->data = x;//左右子树先空树node->left = node->right = NULL;return node;
}//二叉树前序遍历
void PreOrder(BTNode* root)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{//想打印空也可以printf("NULL ");return;}printf("%c ",root->data);//递归左树PreOrder(root->left);//递归右树PreOrder(root->right);
}
//二叉树中序遍历
void InOrder(BTNode* root)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{//想打印空也可以printf("NULL ");return;}//不为空 递归左树InOrder(root->left);//打印数据printf("%c ",root->data);//递归右树InOrder(root->right);
}
//二叉树后序遍历
void PostOrder(BTNode* root)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{//想打印空也可以printf("NULL ");return;}//不为空 递归左树PostOrder(root->left);//递归右树PostOrder(root->right);//打印数据printf("%c ", root->data);
}
#if CountMode
//二叉树节点个数
void BinaryTreeSize(BTNode* root,int* pn)
{//不断言的原因是可以存在空树if (!root)//空树就直接返回{return;}(*pn)++;BinaryTreeSize(root->left, pn);BinaryTreeSize(root->right, pn);
}
#elif !CountMode
//二叉树节点个数
int BinaryTreeSize(BTNode* root)
{return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right)+1;
}
#endif
//二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{if (!root)//空树返回0return 0;if (!(root->left) && !(root->right))return 1;return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}
//二叉树第k层节点个数
int BinaryTreeLevelSize(BTNode* root, int k)
{//k小于等于零直接断言 因为都是从第一层开始的assert(k > 0);if (!root)return 0;if (1 == k)return 1;//root不等于空，k也不等于1，说明root这棵树的第k层节点在子树里面//转换成求左右子树的第k-1层节点数量return BinaryTreeLevelSize(root->left, k - 1) + BinaryTreeLevelSize(root->right, k - 1);
}
//二叉树深度/高度
int BinaryTreeDepth(BTNode* root)
{if (!root)return 0;//把递归的数用变量保存起来，减少资源的消耗int leftDepth = BinaryTreeDepth(root->left);int rightDepth = BinaryTreeDepth(root->right);return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}
//二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{if (!root)return NULL;if (root->data == x)return root;BTNode* leftRet = BinaryTreeFind(root->left, x);if (leftRet)return leftRet;BTNode* rightRet = BinaryTreeFind(root->right, x);if (rightRet)return rightRet;//上面都没进就打印空return NULL;
}
//二叉树层序遍历   不需要用递归，用队列就可以解决
void BinaryTreeLevelOrder(BTNode* root)
{//空就返回if (!root)return;//创建一个队列Queue q;//队列初始化QueueInit(&q);//把root放进队列QueuePush(&q,root);//队空就跳出来while (!QueueErase(&q)){//把队头取出来放准备拿里面的dataBTNode* front = QueueFront(&q);//再出队QueuePop(&q);//打印printf("%c ", front->data);//带左孩子进队if (front->left)QueuePush(&q,front->left);//带右孩子进队if (front->right)QueuePush(&q, front->right);}printf("\n");//和队列初始化的队列销毁QueueDestroy(&q);
}
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{Queue q;QueueInit(&q);QueuePush(&q, root);while (!QueueErase(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);//出到空跳出if (!front)break;else{QueuePush(&q, front->left);QueuePush(&q, front->right);}}//遇到空了以后，检查队列中剩下的节点//1.剩下全是空，则是完全二叉树//2.剩下的存在非空，则不是完全二叉树while (!QueueErase(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);//出到非空就不是完全二叉树if (front){//这里最容易忘记return之前要对销毁QueueDestroy(&q);return false;}}QueueDestroy(&q);return true;
}
//二叉树销毁
void BinaryTreeDestory(BTNode* root)
{if (!root)return;BinaryTreeDestory(root->left);BinaryTreeDestory(root->right);free(root);
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1#include"BinaryTree.h"
#include"Queue.h"//创建树 我们不学二叉树的增删查改原因就在这，我们想要啥树自己链一个就行，没必要增删查改
BTNode* CreatBinaryTree()
{BTNode* nodeA = BuyNode('A');BTNode* nodeB = BuyNode('B');BTNode* nodeC = BuyNode('C');BTNode* nodeD = BuyNode('D');BTNode* nodeE = BuyNode('E');BTNode* nodeF = BuyNode('F');nodeA->left = nodeB;nodeA->right = nodeC;nodeB->left = nodeD;nodeC->left = nodeE;nodeC->right = nodeF;return nodeA;
}int main()
{BTNode* root = CreatBinaryTree();//PreOrder(root);//InOrder(root);PostOrder(root);printf("\n");
#if CountModeint n1 = 0;BinaryTreeSize(root, &n1);printf("%d ",n1);
#elif !CountModeprintf("%d\n",BinaryTreeSize(root));
#endifprintf("%d\n", BinaryTreeLeafSize(root));printf("%d\n", BinaryTreeLevelSize(root,3));printf("%d\n", BinaryTreeDepth(root));BTNode* ret1 = BinaryTreeFind(root,'C');printf("%p\n", ret1);BTNode* ret2 = BinaryTreeFind(root, 'H');printf("%p\n", ret2);BinaryTreeLevelOrder(root);printf("%d\n", BinaryTreeComplete(root));BinaryTreeDestory(root);root = NULL;return 0;
}

这篇关于算法给小码农链式二叉树-----一根草可斩星辰的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/570729。

相关文章

openCV中KNN算法的实现

openCV中KNN算法的实现

《openCV中KNN算法的实现》KNN算法是一种简单且常用的分类算法,本文主要介绍了openCV中KNN算法的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的... 目录KNN算法流程使用OpenCV实现KNNOpenCV 是一个开源的跨平台计算机视觉库，它提供了各
阅读更多...
springboot+dubbo实现时间轮算法

springboot+dubbo实现时间轮算法

《springboot+dubbo实现时间轮算法》时间轮是一种高效利用线程资源进行批量化调度的算法,本文主要介绍了springboot+dubbo实现时间轮算法,文中通过示例代码介绍的非常详细,对大家... 目录前言一、参数说明二、具体实现1、HashedwheelTimer2、createWheel3、n
阅读更多...
SpringBoot实现MD5加盐算法的示例代码

SpringBoot实现MD5加盐算法的示例代码

《SpringBoot实现MD5加盐算法的示例代码》加盐算法是一种用于增强密码安全性的技术,本文主要介绍了SpringBoot实现MD5加盐算法的示例代码,文中通过示例代码介绍的非常详细,对大家的学习... 目录一、什么是加盐算法二、如何实现加盐算法2.1 加盐算法代码实现2.2 注册页面中进行密码加盐2.
阅读更多...
Java时间轮调度算法的代码实现

Java时间轮调度算法的代码实现

《Java时间轮调度算法的代码实现》时间轮是一种高效的定时调度算法,主要用于管理延时任务或周期性任务,它通过一个环形数组（时间轮）和指针来实现,将大量定时任务分摊到固定的时间槽中,极大地降低了时间复杂... 目录1、简述2、时间轮的原理3. 时间轮的实现步骤3.1 定义时间槽3.2 定义时间轮3.3 使用时
阅读更多...
如何通过Golang的container/list实现LRU缓存算法

如何通过Golang的container/list实现LRU缓存算法

《如何通过Golang的container/list实现LRU缓存算法》文章介绍了Go语言中container/list包实现的双向链表,并探讨了如何使用链表实现LRU缓存,LRU缓存通过维护一个双向... 目录力扣：146. LRU 缓存主要结构 List 和 Element常用方法1. 初始化链表2.
阅读更多...
golang字符串匹配算法解读

golang字符串匹配算法解读

《golang字符串匹配算法解读》文章介绍了字符串匹配算法的原理,特别是Knuth-Morris-Pratt（KMP）算法,该算法通过构建模式串的前缀表来减少匹配时的不必要的字符比较,从而提高效率,在... 目录简介KMP实现代码总结简介字符串匹配算法主要用于在一个较长的文本串中查找一个较短的字符串（称为
阅读更多...
通俗易懂的Java常见限流算法具体实现

通俗易懂的Java常见限流算法具体实现

《通俗易懂的Java常见限流算法具体实现》：本文主要介绍Java常见限流算法具体实现的相关资料,包括漏桶算法、令牌桶算法、Nginx限流和Redis+Lua限流的实现原理和具体步骤,并比较了它们的... 目录一、漏桶算法1.漏桶算法的思想和原理2.具体实现二、令牌桶算法1.令牌桶算法流程:2.具体实现2.1
阅读更多...
Python中的随机森林算法与实战

Python中的随机森林算法与实战

《Python中的随机森林算法与实战》本文详细介绍了随机森林算法,包括其原理、实现步骤、分类和回归案例,并讨论了其优点和缺点,通过面向对象编程实现了一个简单的随机森林模型,并应用于鸢尾花分类和波士顿房... 目录1、随机森林算法概述2、随机森林的原理3、实现步骤4、分类案例：使用随机森林预测鸢尾花品种4.1
阅读更多...
不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2