二叉搜索树C语言探讨与实现

合集下载

c语言实现二叉树的四种遍历和求深度与叶子个数

c语言实现二叉树的四种遍历和求深度与叶子个数二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。

在C语言中，我们可以使用指针来实现二叉树的操作。

本文将介绍四种常见的二叉树遍历方式，以及如何求解二叉树的深度和叶子节点个数。

首先，我们需要定义一个二叉树节点的结构体，包含一个数据域和两个指针域，分别指向左子节点和右子节点。

代码如下：```cstruct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;};```接下来，我们可以实现二叉树的四种遍历方式：前序遍历、中序遍历、后序遍历和层序遍历。

前序遍历是指先访问根节点，然后递归地遍历左子树和右子树。

代码如下：```cvoid preorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}printf("%d ", root->data);preorderTraversal(root->left);preorderTraversal(root->right);}```中序遍历是指先递归地遍历左子树，然后访问根节点，最后递归地遍历右子树。

代码如下：```cvoid inorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}inorderTraversal(root->left);printf("%d ", root->data);inorderTraversal(root->right);}```后序遍历是指先递归地遍历左子树和右子树，最后访问根节点。

代码如下：```cvoid postorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}postorderTraversal(root->left);postorderTraversal(root->right);printf("%d ", root->data);}```层序遍历是按照树的层次逐层遍历节点。

C语言递归生成二叉树探讨

～
＠
～
，
ｓａｆ” ” ）ｃｒ（％ｃ，；＆ｃ
ｃ＝ｔｒｎｔｒｔｍＵＬ＝ｅａｅｅｕＮＬｍｉ）
ｅｓｌｅ
ｔ、
‘
．
（
霞
。
蹶。
≮ 。
■‘ 、
ｒｏ＝Ｂｏｅ）ｌｃｓｅｆＮｄ）ｏｔ（Ｎｄｍａｏ（ｚｏ（ｏｅ；ｌｉＢ）
２二叉树递归生成．
可以利用二叉树基本性质．即从根结点开始。断不给当前叶子结点添加左、右新的子结点，成整棵完整生的二叉树。这里，以前序递归方法为例来介绍。需要注意的是输入时按先序遍历次序输入二叉树中结点的字符值．同时要把左右子树为空的结点也要表示出来，该文用、表示空树。下面给出几种Ｃ语言实现方案：使用的宏定义：
＃ｅｎｔｒｎｔｄｆｅｅｍｉａｅｉ
＃ｅｎＯＫｄｆｅｉ１
＃ｅｉｅＥＲＲＯＲｄｆｎ０
方法１：
Ｂｒｅｃｔ（Ｔｅ￣ａｃ）（
ＢＴｅｏｔＮＵＬｒｅｒｏ＝Ｌ：
ｃａ；ｈｃｒ源自④ ：法。【关键词】二叉树；：Ｃ语言；归递
１引言．
二叉树是一种基本的非线性数据结构．二叉链表是其常用的存储形式。用二叉链表实现生成二叉树的算法比较多．其中递归生成及递归遍历二叉树属于二叉树的基本操作。目前无论在教学或实用使用中，大都采用Ｃ、＋或ＣＣ＋＃编程实现，其中用面向过程基本Ｃ语言编程属于重要的基本实现方法。该文在基于基本Ｃ语言环境下对实现生成二叉树及遍历进行一些探

c语言实现二叉树的基本操作

c语言实现二叉树的基本操作
二叉树是一种基于树形结构的数据结构，它的每个节点最多有两个子节点。

在编程语言中，我们可以使用C语言来实现二叉树的基本操作，包括创建、插入、删除、遍历等。

首先，我们需要定义一个二叉树节点的结构体，包括节点值、左子节点、右子节点三个成员。

然后，我们可以通过递归的方式来创建一个二叉树，每个节点的左子节点和右子节点都可以作为一个新的二叉树的根节点进行创建，直到所有的节点都被创建完成。

接下来，我们可以实现二叉树的插入操作。

插入操作可以通过递归的方式来实现，如果插入节点的值比当前节点的值小，则插入到左子树中，否则插入到右子树中。

如果插入的节点已经存在于二叉树中，则不进行任何操作。

删除操作也可以通过递归的方式来实现。

首先我们需要找到要删除的节点，如果该节点没有子节点，则直接删除。

如果该节点只有一个子节点，则将其子节点提升到该节点的位置。

如果该节点有两个子节点，则找到其右子树中最小的节点，并将其值赋给该节点，然后删除这个最小节点。

最后，我们可以实现二叉树的遍历操作。

遍历操作分为前序遍历、中序遍历和后序遍历三种方式。

前序遍历先遍历根节点，然后遍历左子树和右子树；中序遍历先遍历左子树，然后遍历根节点和右子树；后序遍历先遍历左子树和右子树，最后遍历根节点。

通过实现这些基本操作，我们可以使用C语言来构建一个完整的
二叉树数据结构，实现各种应用场景的需求。

平衡二叉树的实现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++模板实现的二叉排序树

pParent->rightChild = p->leftChild; delete p; p = NULL;
m_Length--; return true; } if( p->leftChild != NULL && p->rightChild != NULL) { Node* pParent = getParent(p); Node* ptr = p->leftChild; while( ptr->rightChild != NULL )
if ( p->leftChild == NULL) {
Node* pParent = getParent(p); if( pParent->leftChild == p )
pParent->leftChild = p->rightChild; else
pParent->rightChild = p->rightChild; delete p; p = NULL;
}
template<typename Type> typename BSTrees<Type>::Node* BSTrees<Type>::getRoot()
{
return m_root;
}
template<typename Type> int
BSTrees<Type>::getLength()
{
return m_Length;
if( pParent == NULL ) m_root = pPre;
else if( pParent->leftChild == p) pParent->leftChild = pPre; else pParent->rightChild = pPre;

二叉树 c语言

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

C语言数据结构之二叉链表创建二叉树

C 语⾔数据结构之⼆叉链表创建⼆叉树⽬录⼀、思想（先序思想创建）⼆、创建⼆叉树(1)传⼀级参数⽅法(2)传⼆级参数⽅法⼀、思想（先序思想创建）第⼀步先创建根节点,然后创建根节点左⼦树,开始递归创建左⼦树，直到递归创建到的节点下不继续创建左⼦树，也就是当下递归到的节点下的左⼦树指向NULL ，结束本次左⼦树递归，返回这个节点的上⼀个节点，开始创建右⼦树，然后⼜开始以当下这个节点，继续递归创建左⼦树，左⼦树递归创建完，就递归创建右⼦树，直到递归结束返回到上⼀级指针节点（也就是根节点下），此时根节点左边⼦树创建完毕，开始创建右边⼦树，原理和根节点左边创建左右⼦树相同⼆、创建⼆叉树⼆叉树的操作通常使⽤递归⽅法，如果递归不太明⽩，建议去对此进⾏⼀下学习和练习。

⼆叉树的操作可以分为两类，⼀类是需要改变⼆叉树的结构的，⽐如⼆叉树的创建、节点删除等等，这类操作，传⼊的⼆叉树的节点参数为⼆叉树指针的地址，这种参⼊传⼊，便于更改⼆叉树结构体的指针（即地址）。

这⾥稍微有⼀点点绕，可能需要多思考⼀下如下是⼆叉数创建的函数，这⾥我规定，节点值为整数，如果输⼊的数为-1，则表⽰结束继续往下创建⼦节点的操作。

然后我们使⽤递归的⽅法以此创建左⼦树和右⼦树为了更⽅便的使⽤⼆叉树结构体，可以使⽤ typedef 对结构体进⾏命名123456typedef struct Tree{int data; // 存放数据域struct Tree *lchild; // 遍历左⼦树指针struct Tree *rchild; // 遍历右⼦树指针}Tree,*BitTree;这⾥展⽰两种传参类型的创建⽅法，其中深意可多次参考理解，加深指针理解(1)传⼀级参数⽅法123456789101112131415161718BitTree CreateLink(){ int data; int temp; BitTree T;scanf("%d",&data); // 输⼊数据temp=getchar(); // 吸收空格if(data == -1){ // 输⼊-1 代表此节点下⼦树不存数据，也就是不继续递归创建 return NULL; }else{ T = (BitTree)malloc(sizeof(Tree)); // 分配内存空间T->data = data; // 把当前输⼊的数据存⼊当前节点指针的数据域中printf("请输⼊%d 的左⼦树: ",data);T->lchild = CreateLink(); // 开始递归创建左⼦树192021222324printf("请输⼊%d 的右⼦树: ",data);T->rchild = CreateLink(); // 开始到上⼀级节点的右边递归创建左右⼦树return T; // 返回根节点 } }(2)传⼆级参数⽅法123456789101112131415161718192021222324252627282930BitTree CreateLink(BitTree *T) // 次数 T 为指向根节点的指针的地址{ int data; scanf("%d",&data); if(data == -1){*T=NULL; // 结束递归时，让指针当前节点的指针地址的指针指向NULL}else{*T = (BitTree)malloc(sizeof(Tree)); // 对指向节点指针地址的指针分配内存 if(!(*T) ){ // *T = NULL 表⽰分配内存失败，也就是结束递归创建了 printf("内存分配失败\n");exit(-1);}(*T)->data = data; // 给节点指针地址内的数据域，存⼊数据 printf("请输⼊%d 的左⼦树: ",data); CreateLink(&(*T)->lchild); // 开始遍历左⼦树printf("请输⼊%d 的右⼦树: ",data);CreateLink(&(*T)->rchild); // 开始遍历右⼦树，遍历的思想⽂章开头处解释} }1234567891011121314#include<stdio.h>#include<stdlib.h> typedef struct Tree{ int data; // 存放数据域 struct Tree *lchild; // 遍历左⼦树指针 struct Tree *rchild; // 遍历右⼦树指针 }Tree,*BitTree;151617181920212223242526272829303132333435363738394041424344454647484950515253545556BitTree CreateLink(){int data; int temp; BitTree T; scanf("%d",&data); // 输⼊数据 temp=getchar(); // 吸收空格if(data == -1){ // 输⼊-1 代表此节点下⼦树不存数据，也就是不继续递归创建return NULL;}else{T = (BitTree)malloc(sizeof(Tree)); // 分配内存空间 T->data = data; // 把当前输⼊的数据存⼊当前节点指针的数据域中 printf("请输⼊%d 的左⼦树: ",data); T->lchild = CreateLink(); // 开始递归创建左⼦树printf("请输⼊%d 的右⼦树: ",data);T->rchild = CreateLink(); // 开始到上⼀级节点的右边递归创建左右⼦树 return T; // 返回根节点 } } void ShowXianXu(BitTree T) // 先序遍历⼆叉树{if(T==NULL){return; } printf("%d ",T->data);ShowXianXu(T->lchild); // 递归遍历左⼦树ShowXianXu(T->rchild); // 递归遍历右⼦树} int main(){ BitTree S;printf("请输⼊第⼀个节点的数据:\n");S = CreateLink(); // 接受创建⼆叉树完成的根节点ShowXianXu(S); // 先序遍历⼆叉树 return 0; }123456789101112131415#include<stdio.h>#include<stdlib.h>typedef struct Tree{int data;struct Tree *lchild;struct Tree *rchild;}Tree,*BitTree; BitTree CreateLink(BitTree *T) // 次数 T 为指向根节点的指针的地址{ int data;16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 scanf("%d",&data);if(data == -1){*T=NULL; // 结束递归时，让指针当前节点的指针地址的指针指向NULL }else{*T = (BitTree)malloc(sizeof(Tree)); // 对指向节点指针地址的指针分配内存if(!(*T) ){ // *T = NULL 表⽰分配内存失败，也就是结束递归创建了printf("内存分配失败\n");exit(-1);}(*T)->data = data; // 给节点指针地址内的数据域，存⼊数据printf("请输⼊%d的左⼦树: ",data);CreateLink(&(*T)->lchild); // 开始遍历左⼦树printf("请输⼊%d的右⼦树: ",data);CreateLink(&(*T)->rchild); // 开始遍历右⼦树，遍历的思想⽂章开头处解释}}void ShowXianXu(BitTree T) // 先序遍历⼆叉树{if(T==NULL){return;}printf("%d ",T->data);ShowXianXu(T->lchild); // 遍历左⼦树ShowXianXu(T->rchild); // 遍历右⼦树}int main(){BitTree *S; // 创建指向这个结构体指针地址的指针printf("请输⼊第⼀个节点的数据:\n");CreateLink(&S); // 传⼆级指针地址ShowXianXu(S);return0;}到此这篇关于C语⾔数据结构之⼆叉链表创建⼆叉树的⽂章就介绍到这了,更多相关C语⾔⼆叉链表创建⼆叉树内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

二叉搜索树操作算法及代码实现

二叉搜索树操作算法及代码实现二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有快速插入、删除、查找等特点。

本文将介绍二叉搜索树的相关操作算法，并提供相应的代码实现。

一、二叉搜索树简介二叉搜索树是一种有序的二叉树，它具有以下特点：1. 每个节点的值大于其左子树中的所有节点的值，小于其右子树中的所有节点的值；2. 左右子树都是二叉搜索树。

二、二叉搜索树的操作算法1. 插入操作插入操作用于将一个新节点插入到二叉搜索树中，并保持树的有序性。

具体算法如下：（1）若树为空，则将新节点作为根节点；（2）若树不为空，则从根节点开始比较新节点的值与当前节点的值的大小关系，若新节点的值小于当前节点的值，则递归地将新节点插入当前节点的左子树中；若新节点的值大于当前节点的值，则递归地将新节点插入当前节点的右子树中；（3）重复（2）直到找到一个空位置，将新节点插入该位置。

2. 删除操作删除操作用于从二叉搜索树中删除指定节点，并保持树的有序性。

具体算法如下：（1）若要删除的节点为叶子节点，则直接删除该节点；（2）若要删除的节点只有左子树或右子树，则将其子树连接到其父节点的相应位置上；（3）若要删除的节点既有左子树又有右子树，则找到该节点右子树中最小的节点（即右子树的最左叶子节点），用该最小节点的值替换要删除的节点的值，然后再删除该最小节点。

3. 查找操作查找操作用于在二叉搜索树中查找指定值的节点。

具体算法如下：（1）从根节点开始，将指定值与当前节点的值进行比较；（2）若指定值等于当前节点的值，则返回该节点；（3）若指定值小于当前节点的值，则递归地在当前节点的左子树中查找；（4）若指定值大于当前节点的值，则递归地在当前节点的右子树中查找；（5）若没有找到匹配的节点，则返回空。

三、二叉搜索树的代码实现下面是用Python语言实现二叉搜索树的代码：```pythonclass Node:def __init__(self, key):self.left = Noneself.right = Noneself.val = keydef insert(root, key):if root is None:return Node(key)else:if root.val == key:return rootelif root.val < key:root.right = insert(root.right, key)else:root.left = insert(root.left, key)return rootdef delete(root, key):if root is None:return rootif key < root.val:root.left = delete(root.left, key)elif key > root.val:root.right = delete(root.right, key)else:if root.left is None:return root.rightelif root.right is None:return root.leftroot.val = minValue(root.right)root.right = delete(root.right, root.val) return rootdef minValue(root):current = rootwhile current.left is not None:current = current.leftreturn current.valdef search(root, key):if root is None or root.val == key:return rootif root.val < key:return search(root.right, key)return search(root.left, key)```以上代码包含了二叉搜索树的插入、删除和查找三个操作的实现。

二叉排序树的c语言实现

二叉排序树的c语言实现二叉排序树（Binary Sort Tree）也叫二叉查找树（Binary Search Tree），它的特点是对于任何节点，其左子树的所有节点的值都小于该节点的值，而其右子树的所有节点的值都大于该节点的值。

以下是二叉排序树的一个简单C语言实现：```c#include <stdio.h>#include <stdlib.h>typedef struct Node {int data;struct Node* left;struct Node* right;} Node;Node* newNode(int data) {Node* node = (Node*)malloc(sizeof(Node));node->data = data;node->left = NULL;node->right = NULL;return node;}Node* insert(Node* node, int data) {if (node == NULL) return newNode(data);if (data < node->data) {node->left = insert(node->left, data);} else if (data > node->data) {node->right = insert(node->right, data);} else { // Duplicate data, do nothingreturn node;}return node;}void inorder(Node* node) {if (node == NULL) return;inorder(node->left);printf("%d ", node->data);inorder(node->right);}int main() {Node* root = NULL;root = insert(root, 50);insert(root, 30);insert(root, 20);insert(root, 40);insert(root, 70);insert(root, 60);insert(root, 80);inorder(root); // Prints the elements in sorted order (20 30 40 50 60 70 80)return 0;}```这个程序首先定义了一个节点结构体，包括数据、左子节点和右子节点。

数据结构课程设计二叉排序树查找C语言代码1含测试序列

数据结构课程设计二叉排序树查找C语言代码1含测试序列#include "stdio. h" #include "stdlib・ h〃#include ，z malloc・ h"typedef int KeyType; typedef struct{KeyType key;}DataType;typedef struct node {DataType data;struct node *leftChild; struct node *rightChild; }BiTreeNode; BiTreeNode *root=NULL; DataType a[20], item; int i,n, num=0;/*査找*/void Search(BiTreeNode *root, DataType item){BiTreeNode *p;辻(root!=NULL){p=root;while(p!=NULL){if (p->data・ key二二item. key) { break;num=l;}if(item. key>p->data. key) {p=p->rightChiId;}else{p = p~>leftChild;}if(p二二NULL){num二0;}}}if (num~l){for(i=0;i<n;i++){if (item, key—a Li], key)break;}printf (/?\n Element %d exists in a[%d] \n", item, key, i); } elseprintf (z/\n Can，t find number %d! \n，z, item, key);}/*插入二叉树*/int Insert(BiTreeNode **root, DataType item) {BiTreeNode *current, *parent=NULL, *p;current=*root;while(current!=NULL){if(current一〉data・ key二二item・ key) return 0;parent二current;if(current->data・ key<item. key) current二current一〉rightChiId; else current二current->leftChiId;}p=(BiTreeNode *)malloc(sizeof(BiTreeNode));if(p二二NULL){printf(，z Lack of space!");exit(l);}p->data=item;p->leftChild二NULL;p->rightChild=NULL;if(parent二二NULL) *root=p;else if(item. key<parent->data・ key) parent->leftChild=p;else parent->rightChi1d=p;return 1;}/*插入数组*/void InsertN(){printf ("Please enter some integer：\n z，); for(i=0;i<20;i++){scanf (，/%d，/，&a[i]);if (a[i]. key=-l) /*判断是否非数字*/ {n=i;break;}else if(a[il. key<=0){printf (z/Number must >0. \n");i—；}if (i=19) n 二20;break;}}printf (，z\nThe number you entered are:\n，z): for(i=0;i<n;i++){printf ("%d "，&[i]);Insert(&root, aLi]) ; }printf C\n");}/*中序遍历*/void InTraverse(BiTreeNode *root) {if(root==NULL)return;辻(root->leftChiId!二NULL)InTraverse(root->leftChild);printf (z/%d ", root->data・ key);if(root->rightChiId!=NULL)InTraverse(root->rightChiId) ; }/*删除*/ /*DataType item*/void Destroy (){/*BiTreeNode **root:辻((*root)!=NULL&&(*root)->leftChild!=NULL)Destroy(&(*root)->leftCh订d); if((*root)!=NULL&&(*root)-Might Chi Id!二NULL)Destroy(&(*root)->rightChiId); free(*root);*/printf (^Destory has been finished!z/);}/*打印二叉树*/void PrintBiTree(BiTreeNode *bt, int n) {if (bt二二NULL)return;PrintBiTree(bt->rightChild, n+1); for(i二0;i<n;i++)printf C”)；if(n>二0){printf C--- ”)；printf("%d\n", bt->data);}PrintBiTree(bt->leftChiId, n+1) ; }/*主函数*/void main(){int d, t二0;do{printf("\n");printfC 1. Insert""); /*y第二次插入的重复数字没有被记录，记录了新的数字，相同数值被忽略*/printf C 2. Search'll");printf (，z 3. Destroy'n");printf C 4. Print\n z，);printf C 5. InTraverse'n"); /*y*/printf C 6. Exit! \n\n z/);printf ("Input command number:\n，z): scanf ("%d", &d);switch(d)case 1: InsertNO ; break;case 2:printf C\n Search number: \n，z):scanf&item・ key);Search (root, item);break;}case 3： /*判断是否存在该数值*/{printf ("'Destroy number: \n z/); scanf (，z%d，z, &item. key);Search(root, item);if (num==0)printf (''Destroy could not be done・ \n");break;}elseDestroy ();break;}case 4: PrintBiTree(root, 0): break;case 5: InTraverse (root): break;case 6: t=l: break;default: printf("The number should between 1 and 6. \n"); }} while(!t);}测试序列二义排疗;树查找1・ Insert2.Search3.Destroy4.Print3.InTraverse6. Exit!1Input command number:Please enter some integer: 110503257694088-1The number you entered are: 1050 32 5 76 9 40 881・ Insert2.Search3.Destroy4.Print5.InTraverse6.Exit!Input command number:4——88-- 7640——32-- 5040——32一一一10-- 51.Insert2.Search3.Destroy4.Print3.InTraverse6. Exit!Input command number: 2 Search number: 9Element 9 exists in a[5J1.Insert2.Search3.Destroy4.Print5.InTraverse6.Exit!Input command number: 1 Please enter some integer: 1206-1The number you entered are: 6. Exit!120 61. Insert2. Search3. Destroy4. Print5. InTraverse6. Exit!Input command number: 4——120——88-- 76-- 50——40——32一―10一01. Insert2. Search3. Destroy4. Print5. InTraverseInput command number:55 6 9 10 32 40 50 76 88 120 1・ Insert2.Search3.Destroy4.Print5.InTraverse6.Exit!Input command number:6. Exit!。

浅析一种二叉树非递归遍历算法的C语言实现论文.doc

浅析一种二叉树非递归遍历算法的C语言实现论文一种二叉树非递归遍历算法的C语言实现论文导读：本论文是一篇关于一种二叉树非递归遍历算法的C语言实现的优秀论文范文,对正在写有关于递归论文的写有一定的参考和指导作用,摘要：针对二叉树的链式存储结构，分析了二叉树的各种遍历算法，探讨了递归算法的递推消除理由，提出了一种改善的非递归遍历算法并用C语言予以实现。

关键词：二叉树；遍历算法；非递归；C语言实现1009-3044（2014）01-0223-031 概述树形结构是一种非常常见的数据结构，而二叉树又是其中最重要的一种树形结构。

二叉树的遍历是指按照一定的规则和次序将二叉树中的每一个结点都访问一次，既不能重复，也不能漏掉。

一般而言，对二叉树的遍历有前序遍历、中序遍历、后序遍历和按层遍历等几种方式。

在具体的算法设计上，以上遍历方式一般采取递归算法来实现，该文将探讨采用非递归算法来实现二叉树的遍历。

2 二叉树的数据结构描述二叉树作为一种非线性结构，每个结点最多有一个双亲结点和两个子结点。

二叉树可以采用顺序存储结构和链式存储结构。

对于完全二叉树而言，采用顺序存储是非常方便并且节省空间的，但是对于大部分的非完全二叉树而言，采用顺序存储将导致空间浪费严重且结构混乱、效率低下。

因此，更多的时候，大家都更愿意用链式存储结构来表示二叉树，这样结构更加清晰，尤其是对于一种二叉树非递归遍历算法的C语言实现由写论文的好帮手.zbjy.提供,.左右子树的描述和双亲节点的描述更加方便。

该文中拟采用链式结构来表示二叉树。

用链式存储结构来表示二叉树，一个结点至少由3个域组成，即数据域、左子结点域和右子结点域（如图1所示）。

3 二叉树的遍历及递归算法实现3.1 二叉树的遍历二叉树的遍历就是一个不漏的访问树中的每个结点，同时也不能重复。

所谓“访问”，就是指对结点的数据域进行某种操作，比如说读取、删除、更新、求该节点深度等等。

对于二叉树中的任意一个部分，都可以把它看作三部分，根节点、左子树、右子树，我们用D表示访问跟结点，用L表示遍历左子树，用R表示遍历右子树，则共有以下6种遍历方式[1]。

数据结构：二叉查找树（C语言实现）

数据结构：⼆叉查找树（C语⾔实现）►写在前⾯关于⼆叉树的基础知识，请看我的⼀篇博客: 说明：⼆叉排序树或者是⼀棵空树，或者是具有下列性质的⼆叉树： 1.若其左⼦树不空，则左⼦树上所有结点的值均⼩于它的根结点的值； 2.若其右⼦树不空，则右⼦树上所有结点的值均⼤于它的根结点的值; 3.其左、右⼦树也分别为⼆叉排序树►⼆叉查找树的建⽴(插⼊)：说明：⼆叉树的创建是⼆叉树反复插⼊节点所构造出来的！若⼆叉树为空树，则插⼊元素作为树根节点。

若根结点的键值等于key，则插⼊失败；若key⼩于根结点的键值，则插⼊到根的左⼦树上；否则，插⼊到根的右⼦树上新插⼊的节点⼀定是⼀个叶⼦节点！代码分析：void InsertBST(BiStree &Tree,ElemType e){BiStree T =Tree; //定义执⾏副本，！BiStree father =NULL; //定义while (T&&T->data.key!=e.key){father=T;if(e.key>T->data.key)T=T->Rchild;elseT=T->Lchild;}if(T) //跳出循环的只有两种情况，要么就是T不存在，要么就是找到了对应元素！T 存在说明，只能是对应元素也存在，那我我们就不⽤插⼊了 return;BiSnode *s = (BiSnode*)malloc(sizeof(BiSnode));//能到这⾥，说明节点不存在，新建⼀个节点，并初始化！s->data=e;s->Rchild=s->Lchild=NULL;if(father==NULL) //如果farther不存在，那说明就是没有执⾏While语句，也即是树是空的，因为⼀旦执⾏，就不会为NULL！Tree=s;else if(e.key>father->data.key) //到这⾥说明Farther存在,那么剩下的就是往farther左右节点插⼊元素了father->Rchild=s;elsefather->Lchild=s;}►删除运算说明：删除运算是的基础是查找元素，⾸先要查找要删除的元素，如果找到就删除，找不到就不⽤删除了。

二叉树查找算法c语言

二叉树查找算法c语言二叉树查找算法可以通过递归或者迭代的方式实现。

以下是一个用C语言实现二叉树查找的示例代码：c#include <stdio.h>#include <stdlib.h>二叉树节点定义struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};创建一个新的节点struct TreeNode* createNode(int val) {struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));newNode->val = val;newNode->left = NULL;newNode->right = NULL;return newNode;}向二叉树中插入一个节点struct TreeNode* insertNode(struct TreeNode* root, int val) { 如果根节点为空，直接插入为根节点if (root == NULL) {return createNode(val);}如果插入的值小于根节点的值，则递归插入到左子树中else if (val < root->val) {root->left = insertNode(root->left, val);}如果插入的值大于等于根节点的值，则递归插入到右子树中else {root->right = insertNode(root->right, val);}return root;}在二叉树中查找一个值struct TreeNode* search(struct TreeNode* root, int val) {如果根节点为空或者找到了对应的节点，则返回根节点if (root == NULL root->val == val) {return root;}如果查找的值小于根节点的值，则继续在左子树中查找else if (val < root->val) {return search(root->left, val);}如果查找的值大于根节点的值，则继续在右子树中查找else {return search(root->right, val);}}int main() {创建一个示例二叉树: [5, 3, 6, 2, 4, null, null, 1]struct TreeNode* root = createNode(5);root->left = createNode(3);root->right = createNode(6);root->left->left = createNode(2);root->left->right = createNode(4);root->left->left->left = createNode(1);int target = 4;struct TreeNode* result = search(root, target);if (result == NULL) {printf("Node %d not found\n", target);} else {printf("Node %d found\n", target);}return 0;}在上述代码中，首先定义了一个二叉树的节点结构体`TreeNode`，并实现了创建节点的函数`createNode`。

c语言二叉树详解

c语言二叉树详解一、概述。

树是一种常见的数据结构，其中二叉树是最简单、最基本的树结构。

二叉树是由结点构成的树型结构，其中每个结点最多有两个子节点：左子节点和右子节点。

二叉树有以下特点：-每个结点最多有两个子节点；-左子节点的值小于等于它的父节点的值；-右子节点的值大于等于它的父节点的值；二、树的遍历。

树的遍历是指按一定规则遍历树中所有结点，分为三种方式：1.前序遍历：先遍历根结点，然后是左子树，最后是右子树；2.中序遍历：先遍历左子树，然后是根结点，最后是右子树；3.后序遍历：先遍历左子树，然后是右子树，最后是根结点；三、C语言二叉树实现。

C语言中，可以用结构体来定义二叉树结点：typedef struct TreeNode。

int data; //结点数据。

struct TreeNode *left; //左子节点。

struct TreeNode *right; //右子节点。

}TreeNode;。

可以用以下函数来创建二叉树：TreeNode* createTree()。

int val;。

scanf("%d",&val);。

if(val == -1){ //如果值为-1，则表示结束。

return NULL;。

}。

TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));//动态申请内存空间。

root->data = val; 。

root->left = createTree();//递归构建左子树。

root->right = createTree();//递归构建右子树。

return root;。

}。

其中，scanf用来输入结点的值，若该值为-1，则表示该分支结束，返回NULL；利用递归来构建左子树和右子树。

遍历二叉树的代码如下：void preOrder(TreeNode* root){ 。

if(root == NULL){ //如果结点为空，则返回。

C语言实现二叉树的搜索及相关算法示例

C语⾔实现⼆叉树的搜索及相关算法⽰例本⽂实例讲述了C语⾔实现⼆叉树的搜索及相关算法。

分享给⼤家供⼤家参考，具体如下：⼆叉树（⼆叉查找树）是这样⼀类的树，⽗节点的左边孩⼦的key都⼩于它，右边孩⼦的key都⼤于它。

⼆叉树在查找和存储中通常能保持logn的查找、插⼊、删除，以及前驱、后继，最⼤值，最⼩值复杂度，并且不占⽤额外的空间。

这⾥演⽰⼆叉树的搜索及相关算法：#include<stack>#include<queue>using namespace std;class tree_node{public:int key;tree_node *left;tree_node *right;int tag;tree_node(){key = 0;left = right = NULL;tag = 0;}~tree_node(){}};void visit(int value){printf("%d\n", value);}// 插⼊tree_node * insert_tree(tree_node *root, tree_node* node){if (!node){return root;}if (!root){root = node;return root;}tree_node * p = root;while (p){if (node->key < p->key){if (p->left){p = p->left;}else{p->left = node;break;}}else{if (p->right){p = p->right;}else{p->right = node;break;}}}return root;}// 查询key所在nodetree_node* search_tree(tree_node* root, int key){tree_node * p = root;while (p){if (key < p->key){p = p->left;}else if (key > p->key){p = p->right;}}}return NULL;}// 创建树tree_node* create_tree(tree_node *t, int n){tree_node * root = t;for (int i = 1; i<n; i++){insert_tree(root, t + i);}return root;}// 节点前驱tree_node* tree_pre(tree_node* root){if (!root->left){ return NULL; }tree_node* p = root->left;while (p->right){p = p->right;}return p;}// 节点后继tree_node* tree_suc(tree_node* root){if (!root->right){ return NULL; }tree_node* p = root->right;while (p->left){p = p->left;}return p;}// 中序遍历void tree_walk_mid(tree_node *root){if (!root){ return; }tree_walk_mid(root->left);visit(root->key);tree_walk_mid(root->right);}// 中序遍历⾮递归void tree_walk_mid_norecursive(tree_node *root){ if (!root){ return; }tree_node* p = root;stack<tree_node*> s;while (!s.empty() || p){while (p){s.push(p);p = p->left;}if (!s.empty()){p = s.top();s.pop();visit(p->key);p = p->right;}}}// 前序遍历void tree_walk_pre(tree_node *root){if (!root){ return; }visit(root->key);tree_walk_pre(root->left);tree_walk_pre(root->right);}// 前序遍历⾮递归void tree_walk_pre_norecursive(tree_node *root){ if (!root){ return; }stack<tree_node*> s;tree_node* p = root;s.push(p);while (!s.empty()){tree_node *node = s.top();s.pop();visit(node->key);if (node->right){s.push(node->right);}}}}// 后序遍历void tree_walk_post(tree_node *root){if (!root){ return; }tree_walk_post(root->left);tree_walk_post(root->right);visit(root->key);}// 后序遍历⾮递归void tree_walk_post_norecursive(tree_node *root){ if (!root){ return; }stack<tree_node*> s;s.push(root);while (!s.empty()){tree_node * node = s.top();if (node->tag != 1){node->tag = 1;if (node->right){s.push(node->right);}if (node->left){s.push(node->left);}}else{visit(node->key);s.pop();}}}// 层级遍历⾮递归void tree_walk_level_norecursive(tree_node *root){ if (!root){ return; }queue<tree_node*> q;tree_node* p = root;q.push(p);while (!q.empty()){tree_node *node = q.front();q.pop();visit(node->key);if (node->left){q.push(node->left);}if (node->right){q.push(node->right);}}}// 拷贝树tree_node * tree_copy(tree_node *root){if (!root){ return NULL; }tree_node* newroot = new tree_node();newroot->key = root->key;newroot->left = tree_copy(root->left);newroot->right = tree_copy(root->right);return newroot;}// 拷贝树tree_node * tree_copy_norecursive(tree_node *root){ if (!root){ return NULL; }tree_node* newroot = new tree_node();newroot->key = root->key;stack<tree_node*> s1, s2;tree_node *p1 = root;tree_node *p2 = newroot;s1.push(root);s2.push(newroot);while (!s1.empty()){tree_node* node1 = s1.top();s1.pop();tree_node* node2 = s2.top();s2.pop();tree_node* newnode = new tree_node();newnode->key = node1->right->key;node2->right = newnode;s2.push(newnode);}if (node1->left){s1.push(node1->left);tree_node* newnode = new tree_node();newnode->key = node1->left->key;node2->left = newnode;s2.push(newnode);}}return newroot;}int main(){tree_node T[6];for (int i = 0; i < 6; i++){T[i].key = i*2;}T[0].key = 5;tree_node* root = create_tree(T, 6);//tree_walk_mid(root);//tree_walk_mid_norecursive(root);//tree_walk_pre(root);//tree_walk_pre_norecursive(root);//tree_walk_post(root);//tree_walk_post_norecursive(root);//tree_walk_level_norecursive(root);visit(search_tree(root, 6)->key);visit(tree_pre(root)->key);visit(tree_suc(root)->key);//tree_node* newroot = tree_copy_norecursive(root);//tree_walk_mid(newroot);return 0;}希望本⽂所述对⼤家C语⾔程序设计有所帮助。

二叉查找树C++实现（含完整代码）

⼆叉查找树C++实现（含完整代码）⼀般⼆叉树的查找是通过遍历整棵⼆叉树实现，效率较低。

⼆叉查找树是⼀种特殊的⼆叉树，可以提⾼查找的效率。

⼆叉查找树⼜称为⼆叉排序树或⼆叉搜索树。

⼆叉查找树的定义⼆叉排序树（Binary Search Tree）⼜称⼆叉排序树（Binary Sort Tree）,或者是⼀颗空⼆叉树，或者是具有⼀下特性的⼆叉树：1. 若它的左⼦树不为空，则左⼦树上的所有结点的值均⼩于根节点的值。

2. 若它的右⼦树不为空，则右⼦树上的所有结点的值均⼩于根节点的值。

3. 它的左右⼦树⼜分别是⼆叉排序树。

由定义可知，⼆叉查找树中结点的值不允许重复。

图a是⼀棵⼆叉查找树。

当加⼊结点90后如图b，图b的⼆叉树不是⼆叉查找树，因其不满⾜⼆叉排序树的特性1. 图a 图b⼆叉树的C++实现1. ⼆叉查找树的结点结构template<typename T>//树结点结构class BSTNode{public:T _key; //关键在字（键值）BSTNode *_lchild; //左孩BSTNode *_rchild; //右孩BSTNode *_parent; // 双亲//构造函数BSTNode(T key ,BSTNode *lchild,BSTNode *rchild,BSTNode *parent):_key(key),_lchild(lchild),_rchild(rchild),_parent(parent){};};结点结构BSTNode中含有三个指针域，分别是：1. _lchild，指向结点的左孩⼦。

2. _rchild，指向结点的右孩⼦。

3. _parent，指向结点的双亲。

包含⼀个数据域 _key，为结点的关键字值。

使⽤构造函数初始化表列对以上四个数据进⾏初始化。

2. ⼆叉查找树的操作template<typename T>class BSTree{private:BSTNode<T> *_Root ; //根结点public:BSTree():_Root(NULL){};~BSTree(){};void insert (T key);//⼆叉树的插⼊BSTNode<T>* search (T key) ;//⼆叉树的查找void preOrder() ; //先序输出void inOrder() ; //中序输出void postOrder() ; //后序输出BSTNode<T>* maximumNode ();//查找最⼤的节点T minimumKey();//查找最⼩的键值T maximumKey();//查找最⼩的键值void print();//打印⼆叉树void remove(T key);BSTNode<T>* predecessor(BSTNode<T>* x);//查找某个结点的前驱BSTNode<T>* sucessor(BSTNode<T>* x); //查找某个结点的后继void destory ();//内部使⽤函数，供外部接⼝调⽤private:void insert(BSTNode<T>* &tree,BSTNode<T>* z);BSTNode<T>* search(BSTNode<T>* &tree,T key) const;void preOrder(BSTNode<T>*&tree) const;void inOrder(BSTNode<T>*&tree) const;void postOrder(BSTNode<T>*&tree) const;BSTNode<T>* minimumNode(BSTNode<T> *&tree);BSTNode<T>* maximumNode (BSTNode<T> *&tree);void print(BSTNode<T>*& tree);BSTNode<T>* remove(BSTNode<T>* &tree, BSTNode<T> *z);void destory(BSTNode<T>*& tree);};BSTree类包含了⼀个BSTNode指针数据成员，代表⼆叉查找树的根结点。

二叉排序树及其C++实现

二叉排序树Binary sort tree（BST）二叉排序树又称二叉查找树、二叉搜索树。

或者为空树，或者是具有以下性质的二叉树：①：二叉搜索树的左节点永远小于父节点。

②：二叉搜索树的右节点永远大于父节点。

③：它的左右子树也分别为二叉搜索树中序遍历二叉排序树可以得到一个有序的序列。

二叉排序树有一些基本的应用，可以用于查找，查找的长度与树的深度有关。

其平均查找长度为logN（以2位底的对数，N为结点个数）。

一个序列的排序二叉树有多种构造情况。

下面考虑两种极端情况：深度最小和深度最大的二叉排序树。

关键字序列（45,24,53,12,37,93），假设6个记录的查找概率相等都为1/6容易看出这是一棵完全二叉树，该数的深度（最大层次）为3，它的平均查找长度为：ASL = 1/6（1+2+2+3+3+3）= 14/6再来看该关键字序列构成深度最大的二叉排序树这是一棵单支树，其深度为6，它的平均查找长度为：ASL = 1/6（1+2+3+4+5+6）= 21/6在随机情况下,该数的平均查找长度总是介于这两种情况之间，即14/6 <log6 < 21/6。

二叉排序树的平均查找长度和logN是等数量级的。

二叉排序树的构造过程以上述完全叉树序列为例，构造该二叉排序数的过程如下图：容易看出，每次插入新的结点都是二叉排序树上的叶子结点，则在插入时，不必移动其他结点，只需改动某个结点的指针，由空变为非空即可。

结点的插入操作与二叉排序树的定义紧密相关，即左<根<右，新插入一个关键字时，从根结点开始比较，直到找到合适的插入位置为止。

还有一种情况就是一个序列中可能有两个相同的关键字，对于这种情况，向树中插入关键字时遇到相同关键字时，什么都不做，不进行重复插入操作。

二叉排序树的删除过程删除二叉排序树中任意一个结点，需要分成以下三种情况讨论：（1）删除的是叶子结点这种情况最简单，由于删除叶子结点不会破坏整棵树的结构，只需要修改其双亲结点的指针即可。

C语言实现二叉树的中序遍历

C语言实现二叉树的中序遍历中序遍历是二叉树遍历的一种方式，按照“左子树-根节点-右子树”的顺序遍历二叉树。

非递归实现中序遍历需要借助栈来辅助实现。

首先，我们需要定义二叉树的结构，包含节点的值和指向左右子树的指针。

```ctypedef struct TreeNodeint val;struct TreeNode* left;struct TreeNode* right;} TreeNode;```接下来，我们定义一个栈结构，用于存储节点的指针。

```ctypedef struct StackNodestruct TreeNode* data;struct StackNode* next;} StackNode;typedef structStackNode* top;} Stack;```然后，我们需要实现栈的基本操作函数，包括创建栈、入栈、出栈和判断栈是否为空。

```cStack* createStacStack* stack = (Stack*)malloc(sizeof(Stack));stack->top = NULL;return stack;void push(Stack* stack, TreeNode* node)StackNode* newNode = (StackNode*)malloc(sizeof(StackNode));newNode->data = node;newNode->next = stack->top;stack->top = newNode;TreeNode* pop(Stack* stack)if (stack->top == NULL)return NULL;}StackNode* node = stack->top;stack->top = stack->top->next;TreeNode* data = node->data;free(node);return data;int isEmpty(Stack* stack)return stack->top == NULL;```现在，我们可以定义一个函数来实现二叉树的非递归中序遍历。

C#实现二叉查找树

//删除二叉查找树中的节点，最麻烦的操作 public Node Delete(int key) { Node parent = rootNode; Node current = rootNode; //首先找到需要被删除的节点&其父节点 while (true) { if (key < current.data) { if (current.left == null) break; parent = current; current = current.left; } else if (key > current.data) { if (current == null) break; parent = current; current = current.right; } //找到被删除节点，跳出循环 else { break; } } //找到被删除节点后，分四种情况进行处理 //情况一，所删节点是叶子节点时，直接删除即可 if (current.left == null && current.right == null) { //如果被删节点是根节点，且没有左右孩子 if (current == rootNode&&rootNode.left==null&&rootNode.right==null) { rootNode = null; } else if (current.data < parent.data) parent.left = null; else parent.right = null; } //情况二，所删节点只有左孩子节点时 else if(current.left!=null&&current.right==null) { if (current.data < parent.data) parent.left = current.left; else