建立二叉树的代码c语言

合集下载

二叉树的建立与基本操作

二叉树的建立与基本操作二叉树是一种特殊的树形结构，它由节点（node）组成，每个节点最多有两个子节点。

二叉树的基本操作包括建立二叉树、遍历二叉树、查找二叉树节点、插入和删除节点等。

本文将详细介绍二叉树的建立和基本操作，并给出相应的代码示例。

一、建立二叉树建立二叉树有多种方法，包括使用数组、链表和前序、中序、后序遍历等。

下面以使用链表的方式来建立二叉树为例。

1.定义二叉树节点类首先，定义一个二叉树节点的类，包含节点值、左子节点和右子节点三个属性。

```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = None```2.建立二叉树使用递归的方法来建立二叉树，先构造根节点，然后递归地构造左子树和右子树。

```pythondef build_binary_tree(lst):if not lst: # 如果 lst 为空，则返回 Nonereturn Nonemid = len(lst) // 2 # 取 lst 的中间元素作为根节点的值root = Node(lst[mid])root.left = build_binary_tree(lst[:mid]) # 递归构造左子树root.right = build_binary_tree(lst[mid+1:]) # 递归构造右子树return root```下面是建立二叉树的示例代码：```pythonlst = [1, 2, 3, 4, 5, 6, 7]root = build_binary_tree(lst)```二、遍历二叉树遍历二叉树是指按照其中一规则访问二叉树的所有节点，常见的遍历方式有前序遍历、中序遍历和后序遍历。

1.前序遍历前序遍历是指先访问根节点，然后访问左子节点，最后访问右子节点。

```pythondef pre_order_traversal(root):if root:print(root.value) # 先访问根节点pre_order_traversal(root.left) # 递归访问左子树pre_order_traversal(root.right) # 递归访问右子树```2.中序遍历中序遍历是指先访问左子节点，然后访问根节点，最后访问右子节点。

c语言哈夫曼树的构造及编码

c语言哈夫曼树的构造及编码一、哈夫曼树概述哈夫曼树是一种特殊的二叉树，它的构建基于贪心算法。

它的主要应用是在数据压缩和编码中，可以将频率高的字符用较短的编码表示，从而减小数据存储和传输时所需的空间和时间。

二、哈夫曼树的构造1. 哈夫曼树的定义哈夫曼树是一棵带权路径长度最短的二叉树。

带权路径长度是指所有叶子节点到根节点之间路径长度与其权值乘积之和。

2. 构造步骤(1) 将待编码字符按照出现频率从小到大排序。

(2) 取出两个权值最小的节点作为左右子节点，构建一棵新的二叉树。

(3) 将新构建的二叉树加入到原来排序后队列中。

(4) 重复上述步骤，直到队列只剩下一个节点，该节点即为哈夫曼树的根节点。

3. C语言代码实现以下代码实现了一个简单版哈夫曼树构造函数：```ctypedef struct TreeNode {int weight; // 权重值struct TreeNode *leftChild; // 左子节点指针struct TreeNode *rightChild; // 右子节点指针} TreeNode;// 构造哈夫曼树函数TreeNode* createHuffmanTree(int* weights, int n) {// 根据权值数组构建节点队列，每个节点都是一棵单独的二叉树TreeNode** nodes = (TreeNode**)malloc(sizeof(TreeNode*) * n);for (int i = 0; i < n; i++) {nodes[i] = (TreeNode*)malloc(sizeof(TreeNode));nodes[i]->weight = weights[i];nodes[i]->leftChild = NULL;nodes[i]->rightChild = NULL;}// 构建哈夫曼树while (n > 1) {int minIndex1 = -1, minIndex2 = -1;for (int i = 0; i < n; i++) {if (nodes[i] != NULL) {if (minIndex1 == -1 || nodes[i]->weight < nodes[minIndex1]->weight) {minIndex2 = minIndex1;minIndex1 = i;} else if (minIndex2 == -1 || nodes[i]->weight < nodes[minIndex2]->weight) {minIndex2 = i;}}}TreeNode* newNode =(TreeNode*)malloc(sizeof(TreeNode));newNode->weight = nodes[minIndex1]->weight + nodes[minIndex2]->weight;newNode->leftChild = nodes[minIndex1];newNode->rightChild = nodes[minIndex2];// 将新构建的二叉树加入到原来排序后队列中nodes[minIndex1] = newNode;nodes[minIndex2] = NULL;n--;}return nodes[minIndex1];}```三、哈夫曼编码1. 哈夫曼编码的定义哈夫曼编码是一种前缀编码方式，它将每个字符的编码表示为二进制串。

二叉排序树c语言代码实现

printf ("是否继续输入？\n 1.是 2.否（其他键退出）\n");
if ((*n) != NULL) {
free (*n);
*n = NULL;
}
}
/* 查找结点 */
PNODE find_node (PNODE n, int value) {
in_order_traversal ( n->right);
}
}
int main() {
char buf[50],a[1000];
int i,n,option,s[80],p;
PNODE tree = NULL;/*树的第一个结点*/
PNODE node = NULL;
{
r = (PNODE)malloc(sizeof(NODE));
if(!r)
{
printf("内存分配失败！");
exit(0);
zjm3:fgets (buf, sizeof(buf), stdin);
sscanf (buf, "%i", &option);
printf ("\n\n");
if(option<0) {
printf ("输入错误，请重新输入该元素\n",n);
goto zjm3;}
if(find_node (tree, option))
{
(*n)->value = value;
(*n)->left = NULL;
(*n)->right = NULL;
}
}

哈夫曼树的构造c语言代码

哈夫曼树的构造c语言代码哈夫曼树是一种特殊的二叉树，常被用于数据压缩中。

它的构造过程非常重要，接下来我将用c语言展示如何构造哈夫曼树。

首先，我们需要定义一个结构体作为节点：```struct Node{int weight;//权重int parent;//父节点在数组中的下标int lchild;//左子节点在数组中的下标int rchild;//右子节点在数组中的下标};```然后，我们需要读入数据，计算每个数据的权重，随后用一个数组存储节点信息：```int n;//数据个数int W[maxn];//存储每个数据的权重Node tree[maxn*2-1];//哈夫曼树```接下来，我们需要编写一个函数用来选择权值最小的两个节点，然后将它们合并成一个节点。

```int select_min(Node*tree,int n){int res=-1;int min=INT_MAX;for(int i=0;i<n;i++){if(tree[i].parent!=-1)continue;//跳过已经合并的节点if(tree[i].weight<min){min=tree[i].weight;res=i;}}return res;}void merge_node(Node*tree,int a,int b,int i){tree[a].parent=i;tree[b].parent=i;tree[i].weight=tree[a].weight+tree[b].weight;tree[i].lchild=a;tree[i].rchild=b;}```接下来，我们就可以开始构造哈夫曼树了。

我们先初始化每个节点，将它们都看成一个独立的树，然后选择最小的两个节点进行合并，直到最后只剩下一个树为止。

```void build_tree(Node*tree,int n,int*W){for(int i=0;i<n;i++){tree[i].weight=W[i];tree[i].parent=-1;tree[i].lchild=-1;tree[i].rchild=-1;}for(int i=n;i<(n<<1)-1;i++) {int a=select_min(tree,i);int b=select_min(tree,i);merge_node(tree,a,b,i);}}```最后，我们可以调用build_tree函数来构造哈夫曼树。

数据结构二叉树的基本操作代码

数据结构二叉树的基本操作代码x#include<iostream>using namespace std;//二叉树的结构struct TreeNode{int data;//节点的值TreeNode *left;//指向左子树TreeNode *right;//指向右子树};//插入节点void insert(TreeNode *&tree, int val){if(tree == NULL){tree = new TreeNode;tree->data = val;tree->left = tree->right = NULL;}else if(val<=tree->data)//小于根节点的值则插入到左子树 insert(tree->left, val);else if(val>tree->data)//大于根节点的值则插入到右子树 insert(tree->right,val);}//查找节点TreeNode* find(TreeNode *tree,int val){if (tree == NULL)//树为空，无法查找return NULL;else if (val == tree->data)//值和节点的值相等，返回该节点return tree;else if (val < tree->data)//值小于节点的值，查找左子树 return find(tree->left,val);else if (val > tree->data)//值大于节点的值，查找右子树 return find(tree->right,val);elsereturn NULL;//无法查找}//遍历二叉树//先序遍历void preOrder(TreeNode *tree){if(tree != NULL){cout<< tree->data <<'t'; //先访问根节点preOrder(tree->left); //再遍历左子树 preOrder(tree->right); //最后遍历右子树 }}//中序遍历void inOrder(TreeNode *tree){if(tree != NULL){inOrder(tree->left); //先遍历左子树 cout<< tree->data <<'t'; //再访问根节点inOrder(tree->right); //最后遍历右子树 }}//后序遍历void postOrder(TreeNode *tree){if(tree != NULL){postOrder(tree->left); //先遍历左子树 postOrder(tree->right); //再遍历右子树 cout<< tree->data <<'t'; //最后访问根节点 }}//查找最大值TreeNode* findMax(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->right == NULL)return tree;elsereturn findMax(tree->right);}//查找最小值TreeNode* findMin(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->left == NULL)return tree;elsereturn findMin(tree->left);}//删除节点void remove(TreeNode *&tree, int val){if(tree == NULL)return;else if(val < tree->data)remove(tree->left, val);else if(val > tree->data)remove(tree->right, val);else//找到要删除的节点{if(tree->left != NULL && tree->right != NULL)//左右子树均不为空{TreeNode *temp = tree;TreeNode *max = findMax(tree->left);//查找左子树的最大结点tree->data = max->data;//将最大结点的值替换到要删除的节点remove(temp->left, max->data);//将最大结点删掉}else//只有一边的子节点不为空或者左右节点都为空{TreeNode *temp = tree;if(tree->left == NULL)//如果左节点为空，就将右节点提升 tree = tree->right;else if(tree->right == NULL)//如果右节点为空，就将左节点提升tree = tree->left;delete temp;//删掉要删除的节点}}}int main(){TreeNode *tree = NULL; //声明一个空树int arr[10] = {12, 3, 4, 6, 7, 9, 10, 5, 2, 8};for(int i=0; i<10; i++){insert(tree, arr[i]);//把数组元素插入到树当中}cout<<'先序遍历：';preOrder(tree);cout<<endl;cout<<'中序遍历：';inOrder(tree);cout<<endl;cout<<'后序遍历：';postOrder(tree);cout<<endl;cout<<'查找节点数据：4';TreeNode *findNode = find(tree, 4);if(findNode != NULL)//如果节点存在cout<<'找到了，节点的值是：'<<findNode->data;else//如果节点不存在cout<<'没有找到';cout<<endl;cout<<'查找树的最大值：'<<findMax(tree)->data<<endl; cout<<'查找树的最小值：'<<findMin(tree)->data<<endl; cout<<'删除节点：。

平衡二叉树的实现c语言

平衡二叉树的实现c语言平衡二叉树（AVL树）是一种自平衡的二叉查找树，其中任何节点的两个子树的高度差最多为1。

下面是一个简单的AVL树的C语言实现：```cinclude <>include <>typedef struct AVLNode {int key;int height;struct AVLNode left, right;} AVLNode;typedef struct {AVLNode root;} AVLTree;int getHeight(AVLNode node) {if (node == NULL)return 0;return node->height;}int getBalance(AVLNode node) {if (node == NULL)return 0;return getHeight(node->left) - getHeight(node->right);}AVLNode rotateRight(AVLNode y) {AVLNode x = y->left;AVLNode T2 = x->right;x->right = y;y->left = T2;y->height = max(getHeight(y->left), getHeight(y->right)) + 1; x->height = max(getHeight(x->left), getHeight(x->right)) + 1; return x; // new root is x}AVLNode rotateLeft(AVLNode x) {AVLNode y = x->right;AVLNode T2 = y->left;y->left = x;x->right = T2;x->height = max(getHeight(x->left), getHeight(x->right)) + 1; y->height = max(getHeight(y->left), getHeight(y->right)) + 1; return y; // new root is y}AVLNode insert(AVLTree tree, int key) {AVLNode root = tree->root;if (root == NULL) { // tree is empty, create a new node as root. tree->root = (AVLNode)malloc(sizeof(AVLNode));root = tree->root;root->key = key;root->height = 1;return root;} else if (key < root->key) { // insert into left subtree.root->left = insert(root->left, key);} else if (key > root->key) { // insert into right subtree.root->right = insert(root->right, key);} else { // duplicate keys not allowed.return root; // don't insert duplicate key.}root->height = 1 + max(getHeight(root->left), getHeight(root->right)); // adjust height of current node.int balance = getBalance(root);if (balance > 1 && key < root->left->key) { // left left case.return rotateRight(root); // rotate right.} else if (balance < -1 && key > root->right->key) { // right right case.return rotateLeft(root); // rotate left.} else if (balance > 1 && key > root->left->key) { // left right case. root->left = rotateLeft(root->left); // rotate left first.return rotateRight(root); // then rotate right.} else if (balance < -1 && key < root->right->key) { // right left case.root->right = rotateRight(root->right); // rotate right first.return rotateLeft(root); // then rotate left.} // keep balance.return root; // already balanced.} ```。

C语言实现创建二叉树，先序遍历、中序遍历、后序遍历输出

C语⾔实现创建⼆叉树，先序遍历、中序遍历、后序遍历输出# include <stdio.h># include <stdlib.h># include <string.h># include <iostream># define OK 0;# define ERROR -1;typedef int TElemType;typedef char DataType;typedef int Status;typedef struct BiNode {DataType data;//存⾃定义类型的值struct BiNode *lchild, *rchild;//左右⼩孩指针}BiNode,*BiTree;void CreatBiNode(BiNode **Node)//此处应注意传递的参数（⼆重指针）{char data;scanf_s("%c", &data);*Node = (BiTree)malloc(sizeof(BiNode));if (data == '#'){*Node = NULL;}else if ((data != '#') && (*Node)){(*Node)->data = data;(*Node)->lchild = NULL;(*Node)->rchild = NULL;CreatBiNode(&(*Node)->lchild);CreatBiNode(&(*Node)->rchild);}}Status PreOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {printf("%c", T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}Status InOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {InOrderTraverse(T->lchild);printf("%c", T->data);InOrderTraverse(T->rchild);}}Status PostOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c", T->data);}}int main(){printf("先序输⼊⼆叉树(空结点⽤'#'表⽰):");BiTree T=NULL;CreatBiNode(&T);printf("先序遍历⼆叉树：");PreOrderTraverse(T);printf("\n中序遍历⼆叉树：");InOrderTraverse(T);printf("\n后序遍历⼆叉树：");PostOrderTraverse(T);system("pause");return 0;}解决思想：⼩⽣⽤的是递归创建⼆叉树，递归遍历⼆叉树，因为使⽤递归会⽐较简洁。

二叉树 c语言

二叉树 c语言在计算机科学领域中，树型数据结构是一种非常重要的数据结构，在实际开发中也得到了广泛的应用。

其中，二叉树又是一种非常常见的树型结构。

二叉树在很多情况下都能够提供更好的算法效率，同时也易于理解和实现，因此我们可以通过通过学习和掌握二叉树的特点以及优点，来更好的应用到实际开发中。

一、二叉树的定义二叉树是一种树型结构，树型结构是由节点构成的。

二叉树与一般的树型结构不同，它的每个节点最多只有两个子节点，分别称为左子树和右子树。

它们可以为空或者不为空，其子节点的数量时不固定且没有任何限制的。

二叉树的定义如下：（1）空树是树的一种特殊的状态。

我们可以把它称为二叉树；（2）若不是空树，那么它就是由一个称为根节点（root）的元素和左右两棵分别称为左子树（left subtree）和右子树（right subtree）的二叉树组成。

二、二叉树的特性（1）每个节点最多只有两个子节点，分别称为左子节点和右子节点；（2）左子树和右子树是二叉树；（3）二叉树没有重复的节点。

三、二叉树的应用二叉树是一种非常实用的数据结构，因为它可以模拟很多实际生活中的情况。

例如，我们可以利用二叉树来对某些数据进行分类和排序。

在二叉树的基础上，我们还可以构造二叉堆、哈夫曼树等更高级的数据结构。

除此之外，二叉树还可以应用到程序设计中。

例如，我们可以构造一个二叉树来表示某个程序的控制流，这个程序在执行时可以沿着二叉树的各个节点进行分支和选择，实现不同的功能。

此外，我们还可以利用二叉树来加快某些算法的执行效率，比如二分查找算法等。

四、二叉树的遍历方式对于二叉树的遍历，有三种基本方式，即前序遍历、中序遍历、后序遍历。

它们的遍历顺序不同，因此也得到了不同的称呼。

下面我们来简要介绍一下这三种遍历方式的特点和应用。

（1）前序遍历前序遍历是指首先访问树的根节点，然后按照从左到右的顺序依次遍历左子树和右子树。

前序遍历的应用非常广泛，可以用于生成表达式树、构造二叉树等等。

关于树的各种C语言代码

集合了树的各种算法，已经运行过，本人亲自所写，先序，后序，等全包括#include<stdio.h>#include<malloc.h>#define Max 100typedef int Status;typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int count;Status CreatBiTree(BiTree *bt) /*1.按先序遍历序列创造二叉树的二叉链表*/ {char ch;getchar();scanf("%c",&ch);if (ch == ' '){*bt = NULL;}else{*bt = (BiTree)malloc(sizeof(BiTNode));(*bt)->data = ch;printf("\n\t请输入%c结点的左孩子:",(*bt)->data);CreatBiTree(&((*bt)->lchild));printf("\n\t请输入%c结点的右孩子:",(*bt)->data);CreatBiTree(&((*bt)->rchild));}return 1;}void PreOrder(BiTree bt) /*2.先序遍历二叉树*/{if (bt != NULL){printf("%c\n",bt->data);PreOrder(bt->lchild);PreOrder(bt->rchild);}}void InOrder(BiTree bt) /*3.中序遍历二叉树*/{if (bt != NULL){InOrder(bt->lchild);printf("%c\n",bt->data);InOrder(bt->rchild);}}void PostOrder(BiTree bt) /*4.后序遍历二叉树*/{if (bt != NULL){PostOrder(bt->lchild);PostOrder(bt->rchild);printf("%c\n",bt->data);}}void PreOrderLeaf(BiTree bt) /*5.输出所有的叶子结点*/{if (bt != NULL){if ((bt->lchild == NULL) && (bt->rchild == NULL)){printf("%c\n",bt->data);}PreOrderLeaf(bt->lchild);PreOrderLeaf(bt->rchild);}}Status Leaf(BiTree bt) /*6.统计叶子结点数目，即度为零的结点数目*/ {if (bt == NULL){count = 0;}else if ((bt->lchild == NULL) && (bt->rchild == NULL)){count = 1;}else{count = Leaf(bt->lchild) + Leaf(bt->rchild);}return count;}void Degree1Node(BiTree bt) /*7.输出度为一的结点*/{if (bt != NULL){if (((bt->lchild != NULL) || (bt->rchild != NULL))&& (!((bt->lchild != NULL) && (bt->rchild != NULL)))) {printf("%c\n",bt->data);}Degree1Node(bt->lchild);Degree1Node(bt->rchild);}}void Degree2Node(BiTree bt) /*8.输出度为二的结点*/{if ( bt != NULL){if ((bt->lchild != NULL) && (bt->rchild != NULL)){printf("%c\n",bt->data);}Degree2Node(bt->lchild);Degree2Node(bt->rchild);}}Status CountNode(BiTree bt) /*9.统计二叉树中结点的总数*/{if (bt == NULL){return 0;}else{count++;CountNode(bt->lchild);CountNode(bt->rchild);return count;}}Status TreeDepth(BiTree bt) /*10.求二叉树的深度*/{int ldep, rdep;if (bt == NULL){return 0;}else{ldep = TreeDepth(bt->lchild);rdep = TreeDepth(bt->rchild);if (ldep > rdep){return (ldep +1);}else{return (rdep + 1);}}}void PrintTree(BiTree bt, int nlayer) /*11.按树状打印二叉树*/ {if (bt == NULL) /*如果是空则直接退出函数*/{return;}PrintTree(bt->rchild,nlayer + 1);for ( int i = 0; i < nlayer; i++){printf("----");}printf("%c\n",bt->data);PrintTree(bt->lchild,nlayer + 1);}void PreOrderTree(BiTree bt) /*12.非递归先序遍历*/BiTree Stack[Max];BiTree p = bt;int top = 0;while (p != NULL || top != 0){if (p != NULL){printf("%c",p->data);top++;Stack[top] = p;p = p->lchild;}else{p = Stack[top];top--;p = p->rchild;}}}void InOrderTree(BiTree bt) /*13.非递归中序遍历*/ {BiTree Stack[Max];BiTree p = bt;int top = 0;do{while (p != NULL){top++;Stack[top] = p;p = p->lchild;}if (top != 0){p = Stack[top];top--;printf("%c",p->data);p = p->rchild;}}while ((p != NULL) || (top != 0));void PostOrderTree(BiTree bt) /*14.非递归后序遍历*/ {BiTree p, q;int top = 0;BiTree Stack[Max];q = NULL;p = bt;while ((p != NULL) || (top != 0)){while (p != NULL){top++;Stack[top] = p;p = p->lchild;}if (top > 0){p = Stack[top];if ((p->rchild == NULL) || (p->rchild == q)){printf("%c",p->data);q = p;p = NULL;top--;}else{p = p->rchild;}}}}void LayerOrder(BiTree bt) /*15.层次遍历*/{int front,rear;BiTree Q[Max];front = 0;rear = front;BiTree r, s, p;r = s = p = bt;if (p == NULL) return;Q[rear] = p;rear++;while (front != rear){s = r = Q[front];printf("%c",Q[front]->data);front++;if (r->lchild){Q[rear] = r->lchild;rear++;}if (s->rchild){Q[rear] = s->rchild;rear++;}}}int main(){BiTree bt;int choice;int i,j,k;int nlayer = 1;printf("请用数字选择操作：\n");printf("1.按先序序列创建二叉树（二叉链表）\n");printf("2.递归先序遍历二叉树\n");printf("3.递归中序遍历二叉树\n");printf("4.递归后序遍历二叉树\n");printf("5.输出叶子结点（即度为零的结点）\n");printf("6.统计叶子结点数目\n");printf("7.输出度为一的结点\n");printf("8.输出度为二的结点\n");printf("9.统计二叉树中结点总数\n");printf("10.求二叉树的高度（即深度）\n");printf("11.按树状打印二叉树\n");printf("12.非递归先序遍历二叉树\n");printf("13.非递归中序遍历二叉树\n");printf("14.非递归后序遍历二叉树\n");printf("15.层次遍历二叉树\n");printf("0.则退出\n");while (1){printf("请输入你要执行的操作(0-15):");scanf("%d",&choice);if (choice == 0){break;}else switch (choice){case 1 : printf("\n请输入按先序建立二叉树的结点序列：");printf("\n说明：逐个输入，输入空格代表后继结点为空，按回车输入下一个结点。

c语言二叉树代码

c语言二叉树代码以下是一个简单的C语言二叉树代码，包括二叉树的创建、插入、遍历、删除等操作：```#include<stdio.h>#include<stdlib.h>//定义二叉树节点类型typedef struct node{int data;struct node *left;struct node *right;}Node;//创建二叉树Node* create_tree(){int value;printf('请输入节点的值（-1表示结束）：');scanf('%d', &value);if(value == -1){return NULL;}else{Node *p = (Node*)malloc(sizeof(Node));p->data = value;printf('请输入%d的左子节点：', value);p->left = create_tree();printf('请输入%d的右子节点：', value);p->right = create_tree();return p;}}//插入节点Node* insert_node(Node *root, int value){if(root == NULL){Node *p = (Node*)malloc(sizeof(Node));p->data = value;p->left = NULL;p->right = NULL;return p;}else if(value < root->data){root->left = insert_node(root->left, value);}else if(value > root->data){root->right = insert_node(root->right, value); }return root;}//先序遍历void preorder_traversal(Node *root){if(root != NULL){printf('%d ', root->data);preorder_traversal(root->left);preorder_traversal(root->right);}}//中序遍历void inorder_traversal(Node *root){if(root != NULL){inorder_traversal(root->left);printf('%d ', root->data);inorder_traversal(root->right);}}//后序遍历void postorder_traversal(Node *root){if(root != NULL){postorder_traversal(root->left);postorder_traversal(root->right);printf('%d ', root->data);}}//查找节点Node* search_node(Node *root, int value){ if(root == NULL){return NULL;}else if(root->data == value){return root;}else if(value < root->data){return search_node(root->left, value);}else{return search_node(root->right, value); }}//删除节点Node* delete_node(Node *root, int value){if(root == NULL){return NULL;}else if(value < root->data){root->left = delete_node(root->left, value); }else if(value > root->data){root->right = delete_node(root->right, value); }else{//情况一：被删除节点没有子节点if(root->left == NULL && root->right == NULL){ free(root);root = NULL;}//情况二：被删除节点只有一个子节点else if(root->left == NULL){Node *temp = root;root = root->right;free(temp);}else if(root->right == NULL){Node *temp = root;root = root->left;free(temp);}//情况三：被删除节点有两个子节点else{Node *temp = root->right;while(temp->left != NULL){temp = temp->left;}root->data = temp->data;root->right = delete_node(root->right, temp->data); }}return root;}//主函数int main(){Node *root = NULL;int choice, value;while(1){printf('请选择操作： ');printf('1.创建二叉树 ');printf('2.插入节点');printf('3.遍历二叉树 ');printf('4.查找节点');printf('5.删除节点');printf('6.退出程序');scanf('%d', &choice); switch(choice){case 1:root = create_tree(); break;case 2:printf('请输入要插入的节点值：');scanf('%d', &value);root = insert_node(root, value);break;case 3:printf('先序遍历：');preorder_traversal(root);printf('中序遍历：');inorder_traversal(root);printf('后序遍历：');postorder_traversal(root);printf('');break;case 4:printf('请输入要查找的节点值：');scanf('%d', &value);Node *result = search_node(root, value);if(result != NULL){printf('找到节点：%d', result->data);}else{printf('未找到节点：%d', value);}break;case 5:printf('请输入要删除的节点值：');scanf('%d', &value);root = delete_node(root, value); break;case 6:printf('程序已退出。

c语言二叉树代码

c语言二叉树代码对于c语言的二叉树代码，我们可以先了解一下二叉树的性质。

二叉树是一种树形结构，每个节点最多有两个子节点。

根据二叉树的性质，我们可以定义一个结构体来表示二叉树的节点。

struct TreeNode {int val; // 节点的值struct TreeNode *left; // 左子节点struct TreeNode *right; // 右子节点};接下来就是实现二叉树的增删改查：1. 增加节点void addNode(struct TreeNode **node, int val) {if (*node == NULL) {struct TreeNode *newNode = (structTreeNode*)malloc(sizeof(struct TreeNode));newNode->val = val;newNode->left = NULL;newNode->right = NULL;*node = newNode;} else {if (val < (*node)->val) {addNode(&((*node)->left), val);} else {addNode(&((*node)->right), val);}}}2. 删除节点void deleteNode(struct TreeNode **node, int val) {if (*node == NULL) {return;}if ((*node)->val == val) {if ((*node)->left != NULL && (*node)->right != NULL) { struct TreeNode *minNode = (*node)->right;while (minNode->left != NULL) {minNode = minNode->left;}(*node)->val = minNode->val;deleteNode(&((*node)->right), minNode->val);} else {struct TreeNode *temp = *node;if ((*node)->left != NULL) {*node = (*node)->left;} else {*node = (*node)->right;}free(temp);}} else if (val < (*node)->val) {deleteNode(&((*node)->left), val);} else {deleteNode(&((*node)->right), val);}}3. 查找节点struct TreeNode* searchNode(struct TreeNode* node, int val) { if (node == NULL) {return NULL;}if (node->val == val) {return node;} else if (val < node->val) {return searchNode(node->left, val);} else {return searchNode(node->right, val);}}以上就是c语言实现二叉树的基本代码。

摩斯密码 c语言二叉树

摩斯密码 c语言二叉树摩斯密码是一种将字母和数字转换为短信号和长信号的编码方式。

在莫尔斯电码中，点表示短信号，横线表示长信号。

二叉树是一种树状数据结构，其中每个节点最多有两个子节点。

二叉树可以用于搜索和排序，以及在计算机科学中的其他许多应用程序。

以下是使用C语言实现摩斯密码和二叉树：摩斯密码：```。

#include <stdio.h>。

#include <string.h>。

int main ()。

char msg[100];。

char morse[26][5] = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};。

int i, j;。

printf("Enter a message to convert to Morse code: ");。

fgets(msg, sizeof(msg), stdin);。

msg[strlen(msg)-1] = '\0';。

二叉树c语言的程序代码

# include "stdio.h"# include "stdlib.h"# include "malloc.h"typedef struct Node{char data; //定义根结点struct Node *lchild; //定义左子树struct Node *rchild; //定义右子树}Node,*BiTree;int JianShu(BiTree &T) { //构造二叉链表表示的二叉树T,按先序遍历输入二//叉树中结点的值(一个字符),空格字符表示空树.char e;T=(Node *)malloc(sizeof(Node)); //开辟一个以sizeof(Node)为单位的空间if(!T) //开辟失败exit (-2);fflush(stdin); //清空缓存scanf ("%c",&e);if(e==' ')T=NULL;else {T->data=e; // 生成根结点printf ("请输入%c的左孩子:",e);JianShu(T->lchild); // 构造左子树printf ("请输入%c的右孩子:",e);JianShu(T->rchild); // 构造右子树}return 1;}int DLR_P(BiTree &T) { //先序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树printf ("%c ",T->data); //访问TDLR_P(T->lchild); //递归遍历左子树DLR_P(T->rchild); //递归遍历右子树}return 1;}int LDR_P(BiTree &T) { //中序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树LDR_P(T->lchild); //递归遍历左子树printf ("%c ",T->data); //访问TLDR_P(T->rchild); //递归遍历右子树}return 1;}int LRD_P(BiTree &T) { //后序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树LRD_P(T->lchild); //递归遍历左子树LRD_P(T->rchild); //递归遍历右子树printf ("%c ",T->data); //访问T}return 1;}int DLR_0(BiTree &T,int &s_0) { //用先序遍历求二叉树T中所有叶子总数if (T!=NULL) { //非空二叉树if(!T->lchild&&!T->rchild) { //判断该结点是否为叶子s_0++; //是叶子则计数并打印printf ("%c ",T->data);}DLR_0(T->lchild,s_0); //递归遍历左子树,直到叶子处DLR_0(T->rchild,s_0); //递归遍历右子树,直到叶子处}return s_0;}int DLR_1(BiTree &T,int &s_1) { //用先序遍历求二叉树T中所有1度结点总数if (T!=NULL) { //非空二叉树if(T->lchild&&!T->rchild) { //判断该结点是否为1度结点s_1++; //是1度结点则计数并打印printf ("%c ",T->data);}if(!T->lchild&&T->rchild) { //判断该结点是否为1度结点s_1++; //是1度结点则计数并打印printf ("%c ",T->data);}DLR_1(T->lchild,s_1); //递归遍历左子树,直到1度结点处DLR_1(T->rchild,s_1); //递归遍历右子树,直到1度结点处}return s_1;}int DLR_2(BiTree &T,int &s_2) { //用先序遍历求二叉树T中所有2度结点总数if (T!=NULL) { //非空二叉树if(T->lchild&&T->rchild) { //判断该结点是否为2度结点s_2++; //是2度结点则计数并打印printf ("%c ",T->data);}DLR_2(T->lchild,s_2); //递归遍历左子树,直到2度结点处DLR_2(T->rchild,s_2); //递归遍历右子树,直到2度结点处}return s_2;}int ShenDu(BiTree &T,int l,int &h) { //用递归求二叉树的深度if (T!=NULL) { //非空二叉树l=l+1;if (l>h) h=l;ShenDu(T->lchild,l,h); //递归遍历左子树ShenDu(T->rchild,l,h); //递归遍历右子树}return 1;}int QingKong(BiTree &T) { //清空二叉树if (T!=NULL) {QingKong(T->lchild); //遍历清空左子树free(T->lchild);QingKong(T->rchild); //遍历清空右子树free(T->rchild);}return 1;}int main () { //主函数int i,a=0;Node *T; //定义一个二叉树Twhile(1) {system("cls");printf("\t|===========================================================|\t\n");printf ("\t| |\t\n");printf ("\t| 二叉树的链式存储|\t\n");printf ("\t| |\t\n");printf("\t|===========================================================|\t\n");printf ("\n\t【1】建立二叉树及先序输入!\t 【2】遍历二叉树打印!\n");printf ("\n\t【3】打印各结点并统计! \t 【4】求二叉树的深度!\n");printf ("\n\t【5】清空二叉树!\t\t 【0】退出程序!\n");system("color F0");printf ("\n\n\t\t\t请输入你的选择:"); //输入选择的功能序号scanf ("%d",&i);switch(i) {case 1: //建立二叉树T并输入数据printf ("请输入二叉树T的根:");JianShu(T);a=1;system("pause");break;case 2: //遍历打印二叉树中所有数据if(a==1) {if(T!=NULL) { //非空二叉树Tprintf ("先序遍历打印结果:"); //执行先序遍历并打印DLR_P(T);printf ("\n\n中序遍历打印结果:"); //执行中序遍历并打印LDR_P(T);printf ("\n\n后序遍历打印结果:"); //执行后序遍历并打印LRD_P(T);printf ("\n");}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 3: //先序遍历打印二叉树中0度1度2度结点if(a==1) {if(T!=NULL) { //非空二叉树Tint s_0=0,s_1=0,s_2=0;printf ("二叉树中叶子:");DLR_0(T,s_0); //执行先序遍历打印叶子并统计printf ("共有%d个叶子!\n",s_0);printf ("\n二叉树中1度结点:");DLR_1(T,s_1); //执行先序遍历打印1度结点并统计printf ("共有%d个1度结点!\n",s_1);printf ("\n二叉树中2度结点:");DLR_2(T,s_2); //执行先序遍历打印2度结点并统计printf ("共有%d个2度结点!\n",s_2);}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 4: //用递归求二叉树的深度if(a==1) {if(T!=NULL) { //非空二叉树Tint l=0,h=0;ShenDu(T,l,h);printf ("二叉树的深度为%d.\n",h);}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 5: //清空二叉树if(a==1) {if(T!=NULL) { //非空二叉树QingKong(T); //清空二叉树T=NULL;printf ("二叉树已清空!\n");}elseprintf ("二叉树T为空树,既不用清空!\n");}else //未建立二叉树printf ("未建立二叉树,既不用清空!\n");system("pause");break;case 0: //退出程序printf ("退出程序!\n");return 1;default: //重新输入选择的功能序号printf ("输入有误,请重新输入!\n");system("pause");break;}}}。

c++实现树（二叉树）的建立和遍历算法（一）（前序，中序，后序）

c++实现树（⼆叉树）的建⽴和遍历算法（⼀）（前序，中序，后序）最近学习树的概念，有关⼆叉树的实现算法记录下来。

不过学习之前要了解的预备知识：树的概念；⼆叉树的存储结构；⼆叉树的遍历⽅法。

⼆叉树的存储结构主要了解⼆叉链表结构，也就是⼀个数据域，两个指针域，（分别为指向左右孩⼦的指针），从下⾯程序1，⼆叉树的存储结构可以看出。

⼆叉树的遍历⽅法：主要有前序遍历，中序遍历，后序遍历，层序遍历。

（层序遍历下⼀篇再讲，本篇主要讲的递归法）下篇主要是，之后会有c++模板实现和。

如这样⼀个⼆叉树：它的前序遍历顺序为：ABDGHCEIF（规则是先是根结点，再前序遍历左⼦树，再前序遍历右⼦树）它的中序遍历顺序为：GDHBAEICF（规则是先中序遍历左⼦树，再是根结点，再是中序遍历右⼦树）它的后序遍历顺序为：GHDBIEFCA（规则是先后序遍历左⼦树，再是后序遍历右⼦树，再是根结点）如果不懂的话，可以参看有关数据结构的书籍。

1，⼆叉树的存储结构（⼆叉链表）//⼆叉树的⼆叉链表结构，也就是⼆叉树的存储结构，1个数据域，2个指针域（分别指向左右孩⼦）typedef struct BiTNode{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree;2，⾸先要建⽴⼀个⼆叉树，建⽴⼆叉树必须要了解⼆叉树的遍历⽅法。

//⼆叉树的建⽴，按前序遍历的⽅式建⽴⼆叉树，当然也可以以中序或后序的⽅式建⽴⼆叉树void CreateBiTree(BiTree *T){ElemType ch;cin >> ch;if (ch == '#')*T = NULL; //保证是叶结点else{*T = (BiTree)malloc(sizeof(BiTNode));//if (!*T)//exit(OVERFLOW); //内存分配失败则退出。

实现二叉树的各种基本运算的算法代码

实现二叉树的各种基本运算的算法代码（一）创建二叉树1. 二叉树的链表存储结构：//定义二叉树的链表存储结构typedef struct BiTNode{char data;struct BiTNode *lchild, *rchild;} BiTNode, *BiTree;2.利用二叉树的链表存储结构，创建一棵二叉树//根据二叉树的链表存储结构，创建一棵二叉树BiTree CreateBiTree(BiTree T){char c;scanf(&c);if(c=='#')T=NULL;else{T=(BiTree)malloc(sizeof(BiTNode)); // 产生根节点 T->data=c; // 生成根结点T->lchild = CreateBiTree(T->lchild); // 构造左子树 T->rchild = CreateBiTree(T->rchild); // 构造右子树 }return T;}（二）二叉树的遍历1.先序遍历// 先序遍历：根左右void PreOrderTraverse(BiTree T){if(T==NULL)return;printf('%c',T->data); // 访问根结点PreOrderTraverse(T->lchild); // 遍历左子树PreOrderTraverse(T->rchild); // 遍历右子树}2.中序遍历// 中序遍历：左根右void InOrderTraverse(BiTree T){if(T==NULL)return;InOrderTraverse(T->lchild); // 遍历左子树 printf('%c',T->data); // 访问根结点InOrderTraverse(T->rchild); // 遍历右子树 }3.后序遍历// 后序遍历：左右根void PostOrderTraverse(BiTree T){if(T==NULL)return;PostOrderTraverse(T->lchild); // 遍历左子树 PostOrderTraverse(T->rchild); // 遍历右子树 printf('%c',T->data); // 访问根结点}（三）二叉树的其他基本运算1.计算二叉树的结点数// 计算二叉树的结点数int CountTreeNode(BiTree T){if(T==NULL)return 0; // 二叉树T为空时，结点数为0elsereturnCountTreeNode(T->lchild)+CountTreeNode(T->rchild)+1; }2.计算二叉树的深度// 计算二叉树的深度int TreeDepth(BiTree T){int depL, depR;if(T==NULL)return 0; // 二叉树T为空时，深度为0else{depL = TreeDepth(T->lchild); // 左子树深度depR = TreeDepth(T->rchild); // 右子树深度if(depL > depR)return depL+1;elsereturn depR+1;}}。

二叉树的完整代码实现

⼆叉树的完整代码实现1 #include<stdio.h>2 #include<stdlib.h>3 #include<malloc.h>45 typedef struct Node//结构体6 {7char data;8struct Node *LChild;9struct Node *RChild;10 } BinNode,*BinTree;1112 BinTree CreateTree(BinTree T)13 {14char ch;15 scanf("%c",&ch);16if(ch=='#')17return NULL;18else19 {20 T=(BinTree)malloc(sizeof(BinNode));21 T->data=ch;22 T->LChild=CreateTree(T->LChild);/*创建左⼦树*/23 T->RChild=CreateTree(T->RChild);/*创建右⼦树*/24return T;25 }26 }2728void PreOrder(BinTree root)//先序遍历29 {30if (root != NULL)31 {32 printf("%c", root->data);33 PreOrder(root->LChild);34 PreOrder(root->RChild);35 }36 }3738void InOrder(BinTree root)//中序遍历39 {40if (root != NULL)41 {42 InOrder(root->LChild);43 printf("%c", root->data);44 InOrder(root->RChild);45 }46 }4748void PostOrder(BinTree root)//后序遍历49 {50if (root != NULL)51 {52 PostOrder(root->LChild);53 PostOrder(root->RChild);54 printf("%c", root->data);55 }56 }57/*求⼆叉树结点总数*/58int Count(BinTree T)59 {60if(T==NULL)61return0; /*空⼆叉树结点数为0*/62else/*左右⼦树结点总数加1*/63return Count(T->LChild)+Count(T->RChild)+1;64 }65//叶⼦数66int LeafCount(BinTree T){67if(T == NULL){68return0;69 }70else if ((T->LChild==NULL) && (T->RChild==NULL)){71return1;72 }73else{74return LeafCount(T->LChild)+LeafCount(T->RChild);75 }76 }77int main()78 {7980 BinTree bt;81 printf("⼀、请按先序的⽅式输⼊⼆叉树的结点元素（注：输⼊#表⽰节点为空）如:ABC##DE#G##F###\n");82 bt=CreateTree(bt);83 printf("⼆、前序遍历⼆叉树：\n");84 PreOrder(bt);85 printf("\n");86 printf("三、中序遍历⼆叉树：\n");87 InOrder(bt);88 printf("\n");89 printf("四、后序遍历⼆叉树：\n");90 PostOrder(bt);91 printf("\n");92 printf("五、⼆叉树结点数: %d\n",Count(bt));93 printf("六、叶⼦节点的个数：%d \n",LeafCount(bt));94 system("pause");95 }。

用C语言编写二叉树的建立与遍历

用C语言编写二叉树的建立与遍历1．对题目要有需求分析在需求分析中，将题目中要求的功能进行叙述分析，并且设计解决此问题的数据存储结构，设计或叙述解决此问题的算法。

给出实现功能的一组或多组测试数据，程序调试后，将按照此测试数据进行测试的结果列出来。

如果程序不能正常运行，写出实现此算法中遇到的问题和改进方法；2．对题目要有相应的源程序源程序要按照写程序的规则来编写。

要结构清晰，重点函数的重点变量，重点功能部分要加上清晰的程序注释。

(注释量占总代码的四分之一)程序能够运行，要有基本的容错功能。

尽量避免出现操作错误时出现死循环；3．最后提供的主程序可以象一个应用系统一样有主窗口，通过主菜单和分级菜单调用课程设计中要求完成的各个功能模块，调用后可以返回到主菜单，继续选择其他功能进行其他功能的选择。

二叉树的建立与遍历[问题描述]建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果。

[基本要求]从键盘接受输入，以二叉链表作为存储结构，建立二叉树，并对其进行遍历（先序、中序、后序），将遍历结果打印输出。

以下是我的数据结构实验的作业：肯定好用，里面还包括了统计树的深度和叶子数！记住每次做完一个遍历还要重新输入你的树哦！#include "stdio.h"#include "string.h"#define NULL 0typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild); }return T;}void Preorder(BiTree T){if(T){printf("%c",T->data); Preorder(T->lchild); Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}void zhongxu(BiTree T){if(T){zhongxu(T->lchild);printf("%c",T->data); zhongxu(T->rchild);}}void houxu(BiTree T){if(T){houxu(T->lchild);houxu(T->rchild);printf("%c",T->data);}}int Depth(BiTree T){int dep=0,depl,depr;if(!T) dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}main(){BiTree T;int sum,dep;T=Create(T);Preorder(T);printf("\n");zhongxu(T);printf("\n");houxu(T);printf("\n");sum=Sumleaf(T);printf("%d",sum);dep=Depth(T);printf("\n%d",dep);}在Turbo C的环境下，先按Ctrl+F9运行程序，此时就是建立二叉树的过程，例如输入序列ABC##DE#G##F###（其中的“#”表示空，并且输入过程中不要加回车，因为回车也有对应的ASCII码，是要算字符的，但是输入完之后可以按回车退出），然后再按ALT+F5显示用户界面，这时候就能够看到结果了。

建立二叉树的代码c语言

二叉树的建立与基本操作

c语言哈夫曼树的构造及编码

二叉排序树c语言代码实现

哈夫曼树的构造c语言代码

数据结构二叉树的基本操作代码

平衡二叉树的实现c语言

C语言实现创建二叉树，先序遍历、中序遍历、后序遍历输出

二叉树 c语言

关于树的各种C语言代码

c语言二叉树代码

c语言二叉树代码

摩斯密码 c语言 二叉树

二叉树c语言的程序代码

c++实现树（二叉树）的建立和遍历算法（一）（前序，中序，后序）

实现二叉树的各种基本运算的算法代码

二叉树的完整代码实现

用C语言编写二叉树的建立与遍历

摩斯密码 c语言二叉树