简单二叉树的创建,删除,查找
二叉树的基本操作
二叉树的基本操作二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
二叉树在计算机领域中得到广泛应用,它的基本操作包括插入、删除、查找、遍历等。
1.插入操作:二叉树的插入操作是将一个新的节点添加到已有的二叉树中的过程。
插入操作会按照一定规则将新节点放置在正确的位置上。
插入操作的具体步骤如下:-首先,从根节点开始,比较新节点的值与当前节点的值的大小关系。
-如果新节点的值小于当前节点的值,则将新节点插入到当前节点的左子树中。
-如果新节点的值大于当前节点的值,则将新节点插入到当前节点的右子树中。
-如果当前节点的左子树或右子树为空,则直接将新节点插入到该位置上。
-如果当前节点的左子树和右子树都不为空,则递归地对左子树或右子树进行插入操作。
2.删除操作:二叉树的删除操作是将指定节点从二叉树中删除的过程。
删除操作有以下几种情况需要考虑:-如果待删除节点是叶子节点,则直接将其从二叉树中删除即可。
-如果待删除节点只有一个子节点,则将其子节点替换为待删除节点的位置即可。
-如果待删除节点有两个子节点,则需要找到其左子树或右子树中的最大节点或最小节点,将其值替换为待删除节点的值,然后再删除最大节点或最小节点。
3.查找操作:二叉树的查找操作是在二叉树中查找指定值的节点的过程。
查找操作的具体步骤如下:-从根节点开始,将待查找值与当前节点的值进行比较。
-如果待查找值等于当前节点的值,则返回该节点。
-如果待查找值小于当前节点的值,则在当前节点的左子树中继续查找。
-如果待查找值大于当前节点的值,则在当前节点的右子树中继续查找。
-如果左子树或右子树为空,则说明在二叉树中找不到该值。
4.遍历操作:二叉树的遍历操作是按照一定规则依次访问二叉树中的每个节点。
有三种常用的遍历方式:- 前序遍历(Preorder Traversal):先访问根节点,然后递归地前序遍历左子树和右子树。
- 中序遍历(Inorder Traversal):先递归地中序遍历左子树,然后访问根节点,最后递归地中序遍历右子树。
树结构的定义和基本操作
树结构的定义和基本操作树结构是一种非线性的数据结构,其形状类似于自然界中的树。
树由一组节点(或称为顶点)和一组连接这些节点的边组成。
树结构的常见学习对象有二叉树、二叉树、AVL树、红黑树等。
树结构的基本操作包括创建、插入、删除、查找和遍历。
首先,创建树结构需要定义树节点的结构。
每个节点至少包含一个数据元素以及指向其子节点的指针。
树结构可以使用链式存储结构或数组存储结构。
1.创建树结构:树结构的创建有多种方式。
其中一种常见的方法是通过递归实现。
递归函数首先创建根节点,然后再递归地创建根节点的左子树和右子树。
2.插入节点:要插入一个新节点,首先要定位到合适的位置。
比较要插入的节点值与当前节点值的大小,如果小于当前节点,则进入左子树,如果大于当前节点,则进入右子树。
最终找到合适的位置插入新节点。
如果要插入的节点已经存在,可以替换或忽略该节点。
3.删除节点:删除节点分为三种情况:删除叶子节点、删除只有一个子节点的节点、删除有两个子节点的节点。
-删除叶子节点:直接删除即可。
-删除只有一个子节点的节点:将子节点与父节点连接起来,删除当前节点。
-删除有两个子节点的节点:找到当前节点的后继节点(比当前节点大的最小节点),将后继节点的值复制到当前节点,然后删除后继节点。
4.查找节点:树的查找可以使用递归或迭代的方式实现。
递归方式从根节点开始,根据节点值与目标值的大小关系递归地遍历左子树或右子树,直到找到目标值或遍历完成。
迭代方式使用循环和栈或队列的数据结构来实现。
5.遍历节点:树的遍历有三种方式:前序遍历、中序遍历和后序遍历。
-前序遍历:根节点->左子树->右子树-中序遍历:左子树->根节点->右子树-后序遍历:左子树->右子树->根节点树的遍历也可以通过递归或迭代的方式实现。
递归方式较为简单,使用迭代方式需要借助栈或队列来保存遍历的节点。
除了上述基本操作外,树结构还有一些扩展的操作,如树的深度计算、查找最大值或最小值、查找前驱节点或后继节点等。
二叉树的顺序存储及基本操作
二叉树的顺序存储及基本操作二叉树的顺序存储是将树中的节点按照完全二叉树从上到下、从左到右的顺序依次存储到一个一维数组中,采用这种方式存储的二叉树也被称为完全二叉树。
一、在使用顺序存储方式时,可以使用以下公式来计算一个节点的左右子节点和父节点:
1. 左子节点:2i+1(i为父节点的在数组中的下标)
2. 右子节点:2i+2
3. 父节点:(i-1)/2(i为子节点在数组中的下标)
二、基本操作:
1. 创建二叉树:按照上述公式将节点存储到数组中。
2. 遍历二叉树:可采用递归或非递归方式,进行前序、中序、后序、层次遍历。
3. 插入节点:先将节点插入到数组末尾,然后通过比较节点和其父节点的大小,进行上浮操作直到满足二叉树的性质。
4. 删除节点:先将待删除节点和最后一个节点交换位置,然后通过比较交换后的节点和其父节点的大小,进行下沉操作直到满足二
叉树的性质。
5. 查找节点:根据节点值进行查找,可采用递归或非递归方式。
6. 修改节点:根据节点值进行查找,然后进行修改操作。
二叉树的创建和初始化步骤
二叉树的创建和初始化步骤一、确定二叉树的节点数首先,我们需要确定二叉树中节点的数量。
这可以通过输入用户的需求来确定,或者根据具体的问题背景和数据结构要求来确定。
二、确定节点的值接下来,我们需要为每个节点分配一个唯一的值。
这些值可以是数字、字符或其他数据类型,具体取决于我们的需求和应用场景。
三、创建根节点在确定了节点数和节点值之后,我们可以开始创建二叉树的根节点。
根节点是二叉树中最重要的节点,它没有父节点,并且存储了整个二叉树的信息。
四、初始化二叉树接下来,我们需要初始化二叉树。
这包括为每个节点分配内存空间,并将其初始化为一个空节点。
在初始化过程中,我们需要为每个节点分配一个唯一的位置,以便后续的插入和删除操作。
五、构建左子树接下来,我们需要构建二叉树的左子树。
这可以通过递归地插入节点来完成。
在插入节点时,我们需要判断节点的左子节点是否为空,如果不为空则插入到右子树中。
在构建左子树时,我们需要遵循二叉树的性质,确保左子树的所有节点的值小于根节点的值。
六、构建右子树类似地,我们需要构建二叉树的右子树。
在构建右子树时,我们需要遵循二叉树的性质,确保右子树的所有节点的值大于根节点的值。
我们可以通过递归地插入节点来完成右子树的构建。
七、插入节点如果需要向二叉树中插入新的节点,我们可以按照以下步骤进行:1. 首先,我们需要找到要插入新节点的位置。
这可以通过递归地搜索二叉树来完成。
在搜索过程中,我们需要判断当前节点的左子节点和右子节点是否为空,如果为空则插入新节点,如果不为空则继续搜索。
2. 插入新节点时,我们需要更新节点的指针和引用计数器。
指针指向新节点,引用计数器加一。
同时,我们需要调整父节点的指针,指向新节点。
3. 最后,我们需要重新平衡二叉树,以确保其保持平衡和高效性能。
平衡二叉树的方法有很多种,包括AVL树、红黑树等。
八、遍历二叉树遍历二叉树是另一种重要的操作。
遍历可以帮助我们更好地理解二叉树的构造和结构,并能够更好地应用和处理二叉树中的数据。
C平衡二叉树(AVL)创建和删除
C平衡⼆叉树(AVL)创建和删除 AVL是最先发明的⾃平衡⼆叉查找树算法。
在AVL中任何节点的两个⼉⼦⼦树的⾼度最⼤差别为⼀,所以它也被称为⾼度平衡树,n个结点的AVL树最⼤深度约1.44log2n。
查找、插⼊和删除在平均和最坏情况下都是O(log n)。
增加和删除可能需要通过⼀次或多次树旋转来重新平衡这个树。
定义 ⽤LH,EH,RH分别表⽰左⼦树⾼,等⾼,右⼦树⾼,即平衡因⼦1、0、-1#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define LH 1 // 左⾼#define EH 0 // 等⾼#define RH -1 // 右⾼typedef struct TreeNode{int data;int bf;struct TreeNode *left, *right;}TreeNode; 旋转处理 左旋和右旋,记住“左逆右顺”就可以/************************************************* 对以*p为根的⼆叉排序树作右旋处理,处理之后p指向新的树根结点,* A B* / / \* B 旋转后变为 C A* / \ /* C D D* 即旋转处理之前的左⼦树的结点。
************************************************/void r_rotate(TreeNode **p){TreeNode *l = (*p)->left;(*p)->left = l->right;l->right = (*p);*p = l;}/************************************************* 对以*p为根的⼆叉排序树作左旋处理,处理之后p指向新的树根结点,* A B* \ / \* B 旋转后变为 A D* / \ \* C D C* 即旋转处理之前的右⼦树的结点。
二叉树用途
二叉树用途二叉树是一种常用的数据结构,由节点和连接节点的边组成,其中每个节点最多有两个子节点,被称为左子节点和右子节点。
二叉树具有以下特点:1. 有层次结构:节点按照层次排列,每层从左到右。
2. 可以拥有零个、一个或两个子节点。
3. 二叉树的子树也是二叉树。
4. 深度为d的二叉树最多含有2^d-1个节点,其中d为二叉树的深度。
二叉树的用途非常广泛,下面将详细讨论几个主要的应用场景。
1. 搜索、排序和查找:二叉树可以用于快速搜索、排序和查找数据。
二叉搜索树是一种常用的二叉树类型,其中每个节点的值大于左子树的所有节点的值,小于右子树的所有节点的值。
通过二分查找算法,在二叉搜索树中可以快速定位目标值。
2. 堆:二叉堆是一种用于实现优先队列的数据结构。
它具有以下特点:任意节点的关键字值都小于(或大于)或等于其子节点的关键字值,根节点的关键字值最小(或最大);并且堆是一颗完全二叉树。
二叉堆的插入和删除操作的时间复杂度为O(log n),适用于一些需要高效的优先级操作的场景,例如任务调度。
3. 表达式树:二叉树可以用于存储和计算数学表达式。
表达式树是一种二叉树,其叶节点是操作数,内部节点是操作符。
通过遍历表达式树,我们可以通过递归的方式计算整个表达式的值。
4. 文件系统:二叉树可以用于组织和管理文件系统中的文件和文件夹。
每个节点代表一个文件或文件夹,左子节点代表文件夹下的子文件夹,右子节点代表同一层级下的其他文件或文件夹。
通过遍历二叉树,可以实现文件的查找、创建、删除等操作。
5. 数据压缩:哈夫曼树是一种常用的数据压缩算法,通过构建二叉树来实现。
在哈夫曼树中,出现频率较高的字符对应的节点位于树的较低层,而出现频率较低的字符对应的节点位于树的较高层。
通过对字符进行编码,并使用相对较短的编码表示高频字符,可以实现对数据的高效压缩和解压缩。
6. 平衡树:平衡树是一种特殊类型的二叉树,其左子树和右子树的高度差不超过1。
数据结构实验报告—二叉树
数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构,它由节点和边构成,每个节点最多有两个子节点。
在本次实验中,我们将对二叉树的基本结构和基本操作进行实现和测试,并深入了解它的特性和应用。
实验目的1. 掌握二叉树的基本概念和特性2. 熟练掌握二叉树的基本操作,包括创建、遍历和查找等3. 了解二叉树在实际应用中的使用场景实验内容1. 二叉树的定义和存储结构:我们将首先学习二叉树的定义,并实现二叉树的存储结构,包括节点的定义和节点指针的表示方法。
2. 二叉树的创建和初始化:我们将实现二叉树的创建和初始化操作,以便后续操作和测试使用。
3. 二叉树的遍历:我们将实现二叉树的前序、中序和后序遍历算法,并测试其正确性和效率。
4. 二叉树的查找:我们将实现二叉树的查找操作,包括查找节点和查找最大值、最小值等。
5. 二叉树的应用:我们将探讨二叉树在实际应用中的使用场景,如哈夫曼编码、二叉搜索树等。
二叉树的定义和存储结构二叉树是一种特殊的树形结构,它的每个节点最多有两个子节点。
节点被表示为一个由数据和指向其左右子节点的指针组成的结构。
二叉树可以分为三类:满二叉树、完全二叉树和非完全二叉树。
二叉树可以用链式存储结构或顺序存储结构表示。
- 链式存储结构:采用节点定义和指针表示法,通过将节点起来形成一个树状结构来表示二叉树。
- 顺序存储结构:采用数组存储节点信息,通过计算节点在数组中的位置来进行访问和操作。
二叉树的创建和初始化二叉树的创建和初始化是二叉树操作中的基础部分。
我们可以通过手动输入或读取外部文件中的数据来创建二叉树。
对于链式存储结构,我们需要自定义节点和指针,并通过节点的方式来构建二叉树。
对于顺序存储结构,我们需要定义数组和索引,通过索引计算来定位节点的位置。
一般来说,初始化一个二叉树可以使用以下步骤:1. 创建树根节点,并赋初值。
2. 创建子节点,并到父节点。
3. 重复步骤2,直到创建完整个二叉树。
树的操作实验报告
实验名称:树的操作实验实验目的:1. 理解树的基本概念和操作。
2. 掌握树的创建、插入、删除、查找等基本操作。
3. 熟悉树在计算机科学中的应用。
实验环境:1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse实验内容:1. 树的基本概念2. 树的创建3. 树的插入4. 树的删除5. 树的查找6. 树的应用实验步骤:一、树的基本概念1. 树的定义:树是一种非线性数据结构,由若干节点组成,每个节点有一个唯一的父节点(根节点除外),除了根节点外,其他节点都有一个子节点。
2. 树的术语:- 节点:树中的数据元素。
- 父节点:节点的直接前驱节点。
- 子节点:节点的直接后继节点。
- 根节点:没有父节点的节点。
- 叶节点:没有子节点的节点。
- 节点的度:节点拥有的子节点个数。
- 树的深度:根节点到叶节点的最长路径长度。
二、树的创建1. 创建二叉树:```javapublic class BinaryTree {private TreeNode root;public BinaryTree() {root = null;}public void createTree(int[] data) {if (data == null || data.length == 0) {return;}root = new TreeNode(data[0]);int i = 1;Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root);while (!queue.isEmpty()) {TreeNode node = queue.poll();if (i < data.length && data[i] != 0) {node.left = new TreeNode(data[i]); queue.offer(node.left);i++;}if (i < data.length && data[i] != 0) { node.right = new TreeNode(data[i]); queue.offer(node.right);i++;}}}}```2. 创建二叉搜索树:```javapublic class BinarySearchTree {private TreeNode root;public BinarySearchTree() {root = null;}public void createTree(int[] data) {if (data == null || data.length == 0) {return;}for (int i = 0; i < data.length; i++) {root = insert(root, data[i]);}}private TreeNode insert(TreeNode node, int data) { if (node == null) {return new TreeNode(data);}if (data < node.data) {node.left = insert(node.left, data);} else if (data > node.data) {node.right = insert(node.right, data);}return node;}}```三、树的插入1. 在二叉树中插入节点:```javapublic void insert(TreeNode node, int data) {if (node == null) {return;}if (data < node.data) {insert(node.left, data);} else if (data > node.data) {insert(node.right, data);}}```2. 在二叉搜索树中插入节点:```javaprivate TreeNode insert(TreeNode node, int data) { if (node == null) {return new TreeNode(data);}if (data < node.data) {node.left = insert(node.left, data);} else if (data > node.data) {node.right = insert(node.right, data);}return node;}```四、树的删除1. 在二叉树中删除节点:```javapublic void delete(TreeNode node, int data) {if (node == null) {return;}if (data < node.data) {delete(node.left, data);} else if (data > node.data) {delete(node.right, data);} else {if (node.left == null && node.right == null) { node = null;} else if (node.left == null) {node = node.right;} else if (node.right == null) {node = node.left;} else {TreeNode minNode = findMin(node.right);node.data = minNode.data;delete(node.right, minNode.data);}}}```2. 在二叉搜索树中删除节点:```javaprivate TreeNode delete(TreeNode node, int data) {if (node == null) {return null;}if (data < node.data) {node.left = delete(node.left, data);} else if (data > node.data) {node.right = delete(node.right, data);} else {if (node.left == null && node.right == null) { node = null;} else if (node.left == null) {node = node.right;} else if (node.right == null) {node = node.left;} else {TreeNode minNode = findMin(node.right);node.data = minNode.data;node.right = delete(node.right, minNode.data); }}return node;}```五、树的查找1. 在二叉树中查找节点:```javapublic TreeNode search(TreeNode node, int data) {if (node == null) {return null;}if (data == node.data) {return node;} else if (data < node.data) {return search(node.left, data);} else {return search(node.right, data);}}```2. 在二叉搜索树中查找节点:```javapublic TreeNode search(TreeNode node, int data) {if (node == null) {return null;}if (data == node.data) {return node;} else if (data < node.data) {return search(node.left, data);} else {return search(node.right, data);}}```六、树的应用1. 堆排序:利用二叉堆的属性,实现高效排序。
二叉树实验报告
二叉树实验报告1. 引言二叉树是一种常用的数据结构,广泛应用于计算机科学和信息技术领域。
本实验旨在通过对二叉树的理解和实现,加深对数据结构与算法的认识和应用能力。
本报告将介绍二叉树的定义、基本操作以及实验过程中的设计和实现。
2. 二叉树的定义二叉树是一个有序树,其每个节点最多有两个子节点。
树的左子节点和右子节点被称为二叉树的左子树和右子树。
3. 二叉树的基本操作3.1 二叉树的创建在实验中,我们通过定义一个二叉树的节点结构来创建一个二叉树。
节点结构包含一个数据域和左右指针,用于指向左右子节点。
创建二叉树的过程可以通过递归或者迭代的方式来完成。
3.2 二叉树的插入和删除二叉树的插入操作是将新节点插入到树中的合适位置。
插入时需要考虑保持二叉树的有序性。
删除操作是将指定节点从树中删除,并保持二叉树的有序性。
在实验中,我们可以使用递归或者循环的方式实现这些操作。
3.3 二叉树的遍历二叉树的遍历是指按照某种次序访问二叉树的所有节点。
常见的遍历方式包括前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后按照左孩子-右孩子的顺序递归遍历左右子树。
中序遍历按照左孩子-根节点-右孩子的顺序递归遍历左右子树。
后序遍历按照左孩子-右孩子-根节点的顺序递归遍历左右子树。
3.4 二叉树的查找查找操作是指在二叉树中查找指定的值。
可以通过递归或者循环的方式实现二叉树的查找操作。
基本思路是从根节点开始,通过比较节点的值和目标值的大小关系,逐步向左子树或者右子树进行查找,直到找到目标节点或者遍历到叶子节点。
4. 实验设计和实现在本实验中,我们设计并实现了一个基于Python语言的二叉树类。
具体实现包括二叉树的创建、插入、删除、遍历和查找操作。
在实验过程中,我们运用了递归和迭代的方法实现了这些操作,并进行了测试和验证。
4.1 二叉树类的设计我们将二叉树的节点设计为一个类,其中包括数据域和左右子节点的指针。
另外,我们设计了一个二叉树类,包含了二叉树的基本操作方法。
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('程序已退出。
二叉树的基本操作实验报告
二叉树的基本操作实验报告二叉树的基本操作实验报告引言:二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
二叉树的基本操作包括创建、遍历、插入和删除等。
本实验旨在通过实践来深入了解二叉树的基本操作,并通过实验结果验证其正确性和有效性。
一、创建二叉树创建二叉树是二叉树操作中的第一步。
在本实验中,我们使用了递归算法来创建二叉树。
递归算法是一种重要的算法思想,通过将问题划分为更小的子问题来解决复杂的问题。
在创建二叉树时,我们首先创建根节点,然后递归地创建左子树和右子树。
二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后递归遍历左子树和右子树;中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树;后序遍历先递归遍历左子树和右子树,最后访问根节点。
三、插入节点插入节点是向二叉树中添加新节点的操作。
插入节点的过程需要遵循二叉树的特性,即左子节点的值小于父节点的值,右子节点的值大于父节点的值。
在插入节点时,我们需要找到合适的位置,将新节点插入到正确的位置上。
四、删除节点删除节点是从二叉树中移除节点的操作。
删除节点的过程相对复杂,需要考虑多种情况。
如果要删除的节点是叶子节点,直接删除即可。
如果要删除的节点只有一个子节点,将其子节点连接到父节点上。
如果要删除的节点有两个子节点,我们需要找到其后继节点或前驱节点来替代被删除的节点。
实验结果:通过实验,我们成功地实现了二叉树的基本操作。
创建二叉树的递归算法能够正确地创建出符合要求的二叉树。
遍历二叉树的算法能够按照指定的顺序遍历每个节点。
插入节点和删除节点的操作也能够正确地修改二叉树的结构。
讨论与总结:二叉树的基本操作是数据结构中的重要内容,对于理解和应用其他数据结构具有重要意义。
通过本次实验,我们深入了解了二叉树的创建、遍历、插入和删除等操作,并通过实验验证了其正确性和有效性。
头歌二叉排序表的基本操作
头歌二叉排序表的基本操作一、概述二叉排序树,也称为二叉搜索树(Binary Search Tree, BST),是一种特殊的二叉树,其中每个节点都满足以下性质:对于任意节点,其左子树中所有节点的值都小于该节点的值,而其右子树中所有节点的值都大于该节点的值。
这种特性使得二叉排序树成为一种非常有效的数据结构,用于在各种算法中实现快速查找、插入和删除操作。
二、基本操作1. 插入操作插入操作是二叉排序树中最常用的操作之一。
其基本步骤如下:(1)创建一个新节点,并将要插入的值赋给该节点。
(2)如果二叉排序树为空,则将新节点作为根节点。
(3)否则,从根节点开始比较新节点的值与当前节点的值。
如果新节点的值小于当前节点的值,则将新节点插入到当前节点的左子树中;否则,将新节点插入到当前节点的右子树中。
(4)重复步骤3,直到找到一个空位置来插入新节点。
2. 删除操作删除操作是二叉排序树中比较复杂的操作之一。
其基本步骤如下:(1)找到要删除的节点。
如果找不到要删除的节点,则无法进行删除操作。
(2)如果找到要删除的节点,则将其从树中删除。
如果该节点只有一个子节点,则直接删除该节点;如果该节点有两个子节点,则可以选择将其中的一个子节点“提升”到该节点的位置,然后删除该子节点。
在提升子节点时,需要考虑子节点的值与要删除的节点的值之间的关系,以确保二叉排序树的性质不变。
(3)如果被提升的子节点仍然包含要删除的节点,则需要重复步骤2,直到找到要删除的节点并将其删除。
3. 查找操作查找操作用于在二叉排序树中查找指定的值。
其基本步骤如下:(1)从根节点开始,比较当前节点的值与要查找的值。
如果它们相等,则查找成功,返回当前节点的位置。
(2)如果当前节点的值大于要查找的值,则进入当前节点的左子树中进行查找;否则进入当前节点的右子树中进行查找。
(3)重复步骤2,直到找到要查找的值或者搜索路径上的所有节点都已访问过。
如果最终没有找到要查找的值,则返回空指针。
二叉树操作实验报告
二叉树操作实验报告一、实验背景二叉树是一种常用的数据结构,它由节点和连接节点的边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。
在二叉树的操作中,常用的操作包括创建二叉树、插入节点、删除节点、查找节点、遍历等。
本次实验旨在通过对二叉树的操作,加强对二叉树数据结构的理解,并熟练掌握其操作方法。
二、实验目的1.掌握二叉树的创建方法,能够编写代码创建一个二叉树;2.了解二叉树的插入节点操作,掌握节点的插入方法;3.掌握二叉树的删除节点操作,了解节点删除的细节和方法;4.熟练掌握二叉树的查找节点操作;5.掌握二叉树的遍历方法,能够实现对二叉树的前序、中序、后序、层次遍历。
三、实验原理1.二叉树的创建方法:通过递归的方式,先创建根节点,再依次创建左子树和右子树;2.二叉树的插入节点操作:从根节点开始,根据节点值的大小关系,将待插入节点放到适当的位置;3.二叉树的删除节点操作:首先查找待删除的节点,然后根据其子节点的情况,进行相应的删除处理;4.二叉树的查找节点操作:从根节点开始遍历,根据节点值的大小关系,在左子树或右子树中继续查找,直到找到目标节点或遍历到叶子节点;5.二叉树的遍历方法:前序遍历先访问根节点,再遍历左子树和右子树;中序遍历先遍历左子树,再访问根节点和右子树;后序遍历先遍历左子树和右子树,再访问根节点;层次遍历按层次逐个访问节点。
四、实验过程1.创建二叉树:首先,定义二叉树的节点类,包含节点值和左右子节点;然后,通过递归的方式创建根节点、左子树和右子树。
2.插入节点:要插入一个节点,首先需要找到插入位置。
如果待插入节点大于当前节点的值,则插入到右子树中,否则插入到左子树中。
如果节点为空,则表示找到了插入位置。
3.删除节点:删除节点有以下几种情况:(1) 待删除节点为叶子节点:直接删除即可;(2) 待删除节点只有一个子节点:用子节点替换待删除节点的位置;(3) 待删除节点有两个子节点:找到待删除节点的后继节点(右子树的最左下角节点),用后继节点替换待删除节点的位置。
C语言 二叉树的建立,撤销与遍历
C语言二叉树的建立,撤销与遍历二叉树是一种特殊的树,每个节点只能有最多二个孩子节点,或者没有孩子节点。
建立,与撤销或遍历二叉树主要是靠递归的方法。
#include<stdio.h>#include<stdlib.h>typedef struct stud/*定义二叉树的结构,只有一个数据项,和两个孩子节点*/{char data;struct stud *left;struct stud *right;} bitree;void destroy(bitree **root)/*撤销二叉树,这里用的是递归和二级指针*/ {if(*root!=NULL&&(*root)->left!=NULL)/*当前结点与左子树不空,递归撤销左子树*/destroy(&(*root)->left);if(*root!=NULL&&(*root)->right!=NULL)/*当前结点与右子树不空,递归撤销右子树*/destroy(&(*root)->right);free(*root);/*左右子树都为空,撤销该节点,并递归撤销其上的所有节点*/ }void inititate(bitree **root)/*初始化二叉树的头结点,并分配空间*/ {*root=(bitree *)malloc(sizeof(bitree ));(*root)->left=NULL;(*root)->right=NULL;}bitree *insert_left(bitree *curr,char x)/*在左子树插入数据*/{bitree *s,*t;if(curr==NULL)return NULL;t=curr->left;/*保存当前左子树的数据*/s=(bitree *)malloc(sizeof(bitree));s->data=x;s->left=t;/*新结点指向原来的左子树*/s->right=NULL;curr->left=s;/*原来的节点指向新结点*/return curr->left;}bitree *insert_right(bitree *curr,char x)/*在这个节点的右子树插入数据*/{bitree *s,*t;if(curr==NULL)return NULL;t=curr->right;s=(bitree *)malloc(sizeof(bitree));s->data=x;s->left=NULL;s->right=t;curr->right=s;return curr->right;}bitree *delete_left(bitree *curr)/*删除当前结点的左子树*/{if(curr!=NULL&&curr->left!=NULL)destroy(&curr->left);/*删除左子树本身及其以后的所有节点*/curr->left=NULL;return curr;}bitree *delete_right(bitree *curr)/*删除右子树*/{if(curr!=NULL&&curr->right!=NULL)destroy(&curr->right);curr->right=NULL;return curr;}void preorder(bitree *root)/*递归先序遍历根节点*/ {if(root!=NULL){printf("%c ",root->data);preorder( root->left);preorder( root->right);}}void midorder(bitree *root)/*递归中序遍历根节点*/ {if(root!=NULL){midorder( root->left);printf("%c ",root->data);midorder(root->right);}}void postorder(bitree *root))/*递归后序遍历根节点*/ {if(root!=NULL){postorder(root->left);postorder( root->right);printf("%c ",root->data);}}bitree *search(bitree *root,char x))/*递归某一数值*/ {bitree *find=NULL;if(root!=NULL){if(root->data==x)find=root;else{find=search (root->left,x);)/*在左子树查找*/ if(find==NULL))/*左子树没有找到的话*/find=search (root->right,x);/*右子树找*/}}return find;}void main(){bitree *root,*s,*p,*find;int i,j,k;char c='E';inititate(&root);p=insert_left(root,'A');p=insert_left(p,'B');p=insert_left(p,'D');p=insert_right(p,'G');p=insert_right(root->left,'C');insert_left(p,'E');insert_right(p,'F');printf("前序遍历为\n");preorder(root->left);printf("\n中序遍历为\n");midorder(root->left);printf("\n后序遍历为\n");postorder(root->left);find=search(root->left,c);if(find)printf("这个元素%c在二叉树中\n",c);elseprintf("这个元素%c不在二叉树中\n",c);printf("撤销根节点的左子树为\n");delete_left(root->left);printf("\n前序遍历为\n");preorder(root->left);printf("\n中序遍历为\n");midorder(root->left);printf("\n后序遍历为\n");postorder(root->left);printf("\n撤销根节点的右子树为\n"); delete_right(root->left);printf("前序遍历为\n");preorder(root->left);printf("\n中序遍历为\n");midorder(root->left);printf("\n后序遍历为\n");postorder(root->left);destroy(&root);}。
二叉树实现及应用实验报告
二叉树实现及应用实验报告实验名称:二叉树实现及应用实验目的:1. 实现二叉树的创建、插入和删除操作。
2. 学习二叉树的遍历方法,并能够应用于实际问题。
3. 掌握二叉树在数据结构和算法中的一些常用应用。
实验内容:1. 实现二叉树的创建、插入和删除操作,包括二叉树的构造函数、插入函数和删除函数。
2. 学习二叉树的三种遍历方法:前序遍历、中序遍历和后序遍历,并应用于实际问题。
3. 掌握二叉树的一些常用应用,如二叉搜索树、平衡二叉树和哈夫曼树等。
实验步骤:1. 创建二叉树的结构体,包括树节点和树的根节点。
2. 实现二叉树的构造函数,用于创建二叉树的根节点。
3. 实现二叉树的插入函数,用于将元素插入到二叉树中的合适位置。
4. 实现二叉树的删除函数,用于删除二叉树中的指定元素。
5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。
6. 运用二叉树的遍历方法解决实际问题,如查找二叉树中的最大值和最小值。
7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。
实验结果:1. 成功创建、插入和删除二叉树中的元素,实现了二叉树的基本操作。
2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历,并能够正确输出遍历结果。
3. 通过二叉树的遍历方法成功解决了实际问题,如查找二叉树中的最大值和最小值。
4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构,丰富了对二叉树的理解。
实验分析:1. 二叉树是一种重要的数据结构,具有较好的数据存储和查找性能,广泛应用于计算机科学和算法领域。
2. 通过实验,我们深入了解了二叉树的创建、插入和删除操作,以及前序遍历、中序遍历和后序遍历的原理和应用。
3. 实际问题往往可以转化为二叉树的遍历问题进行求解,通过实验,我们成功应用了二叉树的遍历方法解决了实际问题。
4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用,对于提高我们在数据结构和算法方面的设计能力具有重要意义。
二叉树的各种算法
二叉树的各种算法1.二叉树的前序遍历算法:前序遍历是指先访问根节点,再访问左子树,最后访问右子树的遍历顺序。
具体算法如下:-如果二叉树为空,则直接返回。
-访问根节点,并输出或进行其他操作。
-递归地前序遍历左子树。
-递归地前序遍历右子树。
2.二叉树的中序遍历算法:中序遍历是指先访问左子树,再访问根节点,最后访问右子树的遍历顺序。
具体算法如下:-如果二叉树为空,则直接返回。
-递归地中序遍历左子树。
-访问根节点,并输出或进行其他操作。
-递归地中序遍历右子树。
3.二叉树的后序遍历算法:后序遍历是指先访问左子树,再访问右子树,最后访问根节点的遍历顺序。
具体算法如下:-如果二叉树为空,则直接返回。
-递归地后序遍历左子树。
-递归地后序遍历右子树。
-访问根节点,并输出或进行其他操作。
4.二叉树的层序遍历算法:层序遍历是按照从上到下、从左到右的顺序逐层遍历二叉树的节点。
具体算法如下:-如果二叉树为空,则直接返回。
-创建一个队列,将根节点入队。
-循环执行以下步骤,直到队列为空:-出队并访问当前节点,并输出或进行其他操作。
-若当前节点的左子节点不为空,则将左子节点入队。
-若当前节点的右子节点不为空,则将右子节点入队。
5.二叉树的深度算法:二叉树的深度是指从根节点到叶节点的最长路径的节点数。
具体算法如下:-如果二叉树为空,则深度为0。
-否则,递归地计算左子树的深度和右子树的深度,然后取较大的值加上根节点的深度作为二叉树的深度。
6.二叉树的查找算法:二叉树的查找可以使用前序、中序或后序遍历来完成。
具体算法如下:-如果二叉树为空,则返回空。
-如果当前节点的值等于目标值,则返回当前节点。
-否则,先在左子树中递归查找,如果找到则返回找到的节点。
-如果左子树中未找到,则在右子树中递归查找,如果找到则返回找到的节点。
-如果左右子树中都未找到,则返回空。
7.二叉树的插入算法:二叉树的插入可以使用递归或循环来实现。
具体算法如下:-如果二叉树为空,则创建一个新节点作为根节点,并返回根节点。
二叉树
例.设结点的权集W ={10,12,4,7,5,18,2},建立一棵 哈夫曼树,并求出其带权路径长度。
5.什么是哈夫编码? 在数据通讯中,经常需要将传送的文字转换成由二进制 字符0,1组成的二进制代码,称之为编码。 如果在编码时考虑字符出现的频率,让出现频率高的字 符采用尽可能短的编码,出现频率低的字符采用稍长的编 码,构造一种不等长编码,则电文的代码就可能更短。哈 夫曼编码是一种用于构造使电文的编码总长最短的编码方 案。 6.求哈夫曼编码的方法 (1)构造哈夫曼树 设需要编码的字符集合为{d1,d2,…,dn},它们在电文 中出现的次数集合为{w1,w2,…,wn},以d1,d2,…, dn作为叶结点,w1,w2,…,wn作为它们的权值,构造 一棵哈夫曼树。
6.Insert操作 二叉树的插入操作与查找操作类似,为了将X插入到树 中,实际上就是先对二叉树进行查找操作。如果找到X,则 什么也不做或做一些“更新”。否则,将X插入到遍历路径 的最后一个节点上。 7.Delete操作 删除操作要比插入操作困难,主要是因为其要考虑的 情况比插入多。 如果要删除的节点是一片树叶,那么可以直接删除。 如果节点有一个儿子,则该节点可以在其父节点调整指针 绕过该节点后被删除。复杂的情况是处理有两个儿子的节 点。一般的删除策略是用其右子树的最小数据代替该节点 的数据并递归地删除那个节点。因为有子树中的最小节点 不可能有左儿子,所以第二次Delete要容易。
例.设有A,B,C,D,E,F 6个数据项,其出现的频度分别 为6、5、4、3、2、1,构造一棵哈夫曼树,并确定它们的 哈夫曼编码。
(2)在哈夫曼树上求叶结点的编码。 规定哈夫曼树中的左分支代表0,右分支代表1,则从根 结点到每个叶结点所经过的路径分支组成的0和1的序列便 为该结点对应字符的编码,上图编码为: A=11;B=01;C=00;D=100;E=1011;F=1010。 在哈夫曼编码树中,树的带权路径长度的含义是各个字 符的码长与其出现次数的乘积之和,也就是电文的代码总 长。采用哈夫曼树构造的编码是一种能使电文代码总长为 最短的、不等长编码。 求哈夫曼编码,实质上就是在已建立的哈夫曼树中,从 叶结点开始,沿结点的双亲链域回退到根结点,每回退一 步,就走过了哈夫曼树的一个分支,从而得到一位哈夫曼 码值,由于一个字符的哈夫曼编码是从根结点到相应叶结 点所经过的路径上各分支所组成的0,1序列,因此先得到 的分支代码为所求编码的低位码,后得到的分支代码为所 求编码的高位码。
树、二叉树、查找算法总结
树、⼆叉树、查找算法总结树的定义形式化定义树:T={D,R }。
D是包含n个结点的有限集合(n≥0)。
当n=0时为空树,否则关系R满⾜以下条件:l 有且仅有⼀个结点d0∈D,它对于关系R来说没有前驱结点,结点d0称作树的根结点。
l 除根结点外,每个结点有且仅有⼀个前驱结点。
l D中每个结点可以有零个或多个后继结点。
递归定义树是由n(n≥0)个结点组成的有限集合(记为T)。
其中:l 如果n=0,它是⼀棵空树,这是树的特例;l 如果n>0,这n个结点中存在⼀个唯⼀结点作为树的根结点(root),其余结点可分为m (m≥0)个互不相交的有限⼦集T1、T2、…、Tm,⽽每个⼦集本⾝⼜是⼀棵树,称为根结点root的⼦树。
ð 树中所有结点构成⼀种层次关系!树的基本术语度结点的度:⼀个结点的⼦树的个数树的度:各节点的度的最⼤值。
通常将度为m的树成为m次树或m叉树结点分⽀结点:度不为0的结点(也称⾮终端结点)度为1的结点成为单分⽀结点,度为2的结点称为双分⽀结点叶结点:度为0的结点路径与路径长度路径:两个结点di和dj的结点序列(di,di1,di2,…,dj)。
其中<dx,dy>是分⽀。
路径长度:等于路径所通过的结点数⽬减1(即路径上的分⽀数⽬)结点的层次和树⾼度层次:根结点层次为1,它的孩⼦结点层次为2。
以此类推。
树的⾼度(深度):结点中的最⼤层次;有序树和⽆序树有序树:若树中各结点的⼦树是按照⼀定的次序从左向右安排的,且相对次序是不能随意变换的⽆序树:和上⾯相反森林只要把树的根结点删去就成了森林。
反之,只要给n棵独⽴的树加上⼀个结点,并把这n棵树作为该结点的⼦树,则森林就变成了⼀颗树。
树的性质性质1:树中的结点数等于所有结点的度数之和加1。
证明:树的每个分⽀记为⼀个度,度数和=分⽀和,⽽再给根节点加个分⽀性质2:度为m的树中第i层上⾄多有mi-1个结点(i≥1)。
性质3 ⾼度为h的m次树⾄多有个结点。
二叉排序树与文件操作的设计与实现
一、二叉排序树的基本概念二叉排序树又称为二叉查找树,是一种特殊的二叉树。
它的定义是:若左子树不空,则左子树上所有节点的值均小于它的根节点的值;若右子树不空,则右子树上所有节点的值均大于它的根节点的值;左、右子树也分别为二叉排序树。
二叉排序树的中序遍历结果是递增的。
二、二叉排序树的操作1. 查找操作在二叉排序树中查找一个值为key的节点时,可以按照以下步骤进行:1)若树为空,则查找失败;2)若树的根节点值等于key,则查找成功;3)若key小于树的根节点值,则在左子树中递归查找;4)若key大于树的根节点值,则在右子树中递归查找。
2. 插入操作插入一个新节点时,需要按照以下步骤进行:1)若树为空,则将新节点直接插入为根节点;2)若key小于树的根节点值,则将新节点插入到左子树中;3)若key大于树的根节点值,则将新节点插入到右子树中。
3. 删除操作删除一个值为key的节点时,需要考虑以下几种情况:1)若待删除节点无子节点,则直接删除;2)若待删除节点只有一个子节点,则将子节点替换为该节点;3)若待删除节点有两个子节点,则需要找到它的前驱或后继节点来替换。
三、文件操作的设计与实现1. 文件操作的基本概念文件操作是指对计算机文件进行的各种处理操作,包括创建、打开、读取、写入、关闭等。
在实际开发中,文件操作是非常常见的操作之一。
2. 文件操作的流程在进行文件操作时,一般需要按照以下流程进行:1)打开文件:通过指定文件名和打开方式,打开要进行操作的文件;2)读取或写入数据:根据需要进行读取或写入文件的操作;3)关闭文件:在操作完成后,需要关闭文件,释放资源。
3. 文件操作的设计与实现在进行文件操作的设计与实现时,需要考虑以下几点:1)文件存在性检查:在进行打开操作前,需要对文件是否存在进行检查,避免因文件不存在而导致的错误;2)错误处理:在进行文件操作时,需要对可能发生的错误进行处理,保证程序的稳定性和健壮性;3)资源释放:在操作完成后,需要及时关闭文件,并释放相关资源,以避免资源泄露。
c语言实现二叉树各种基本运算的算法
c语言实现二叉树各种基本运算的算法二叉树是一种常见的数据结构,可以应用于许多算法和问题中。
在C语言中,我们可以使用指针和结构体来实现二叉树的各种基本运算。
本文将详细介绍二叉树的创建、插入、删除、查找以及遍历等基本操作的算法。
1.创建二叉树创建二叉树可以通过递归的方式来实现。
首先定义一个表示二叉树节点的结构体,包含一个值和左右子节点指针。
然后,通过递归地创建左右子树来构建整个二叉树。
```ctypedef struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;} TreeNode;//创建二叉树TreeNode* createBinaryTree() {int data;scanf("%d", &data);if (data == -1) { // -1表示空节点return NULL;}TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->data = data;node->left = createBinaryTree();node->right = createBinaryTree();return node;}```2.插入节点在二叉树中插入节点可以按照二叉搜索树的性质进行。
如果要插入的值小于当前节点的值,则将其插入到左子树中,否则插入到右子树中。
如果子树为空,则直接创建一个新节点作为子树。
```c//插入节点TreeNode* insertNode(TreeNode* root, int data) {if (root == NULL) {TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;}if (data < root->data) {root->left = insertNode(root->left, data);} else {root->right = insertNode(root->right, data);}return root;}```3.删除节点删除二叉树中的节点可以分为三种情况:删除叶子节点、删除只有一个子节点的节点、删除有两个子节点的节点。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《数据结构》实验报告
姓名:
班级:
学号:
一、算法简介
简单二叉树的创建,删除,查找
二、基本原理
定义节点的结构体,内部成员包括数据data,父节点指针*parent,左子节点指针*lchild,右子结点指针*rchild,以及指针next,然后通过add()和move()函数建立一个二叉树;最后通过del()删除整个二叉树。
三、实现步骤
第一,创建二叉树结点
第二,创建构造二叉树的函数add()和move().在add()中调用move();然后在主函数中初始化二叉树为7个结点(通过建立二叉树的函数)。
创建的二叉树如图:
1 2
3 4 5 6
第三,最后一个个通过查找的方式进行删除结点。
该方式不局限于顺序删除,可以
从任何一个结点开始删除,删除后会通过move重新构建,直到删除为止。
四、实验结果如下图
五、结论
本套算法在创建二叉树同时增加了有序检查,通过创建和删除一棵完全二叉树,还可以实现查找结点的功能,未实现遍历、插入、修改、替换等算法,程序较为简单,但是代码工整严谨,时间复杂度和空间复杂度可忽略不计。
六、源程序
#include<stdio.h>
struct node
{ int data;
struct node *parent;
struct node *lchild;
struct node *rchild;
struct node *next;
}*head=NULL;
int num=0,b[10];
void move(struct node *p,struct node *s)
{
while(0)
{
if(s->data > p->data )
{
if(p->rchild==NULL)
{
p->rchild=s;
break;
}
else
{
p=p->rchild;
}
}
else
{
if(p->lchild==NULL)
{
p->lchild=s;
break;
}
}
}
}
void add(int x)
{
struct node *s=malloc(sizeof(struct node)),*p=malloc(sizeof(struct node));
s->data=x;
s->lchild=NULL;
s->rchild=NULL;
s->parent=NULL;
if(head==NULL)
{
head=s;
}
else
{
p=head;
move(p,s);
}
int a=1,v=1,k=6,f=1;
struct node *print(struct node *head,int x,int y)//打印或查找功能,x=1,打印
{
struct node *p=malloc(sizeof(struct node));
p=head;
if(p!=NULL)
{
print(p->lchild,x,y);
b[++num]=p->data;
if(x==1)
{
if(v==0)
{
printf("creat node %d: %d \n",a,p->data);
a=a+1;
}
}
print(p->rchild,x,y);
}
}
void del(int x)
{
struct node *m=malloc(sizeof(struct node));
if(head->data==x)//删除头结点
{
if(head->lchild==NULL && head->rchild==NULL)//头结点无左右子树
{
head=NULL;
}
else if(head->rchild==NULL)//头结点无右子树
{
head=head->lchild;
head->parent=NULL;
}
else //头结点左右子树均有(这里让左子树继位)
{
move(head->lchild,head->rchild);
head=head->lchild;
}
}
else
{
if(m->lchild==NULLL)
{
if(m->data > m->parent->data) //右子树
{
m->parent->rchild=NULL;
}
else
{
m->parent->lchild=NULL;
}
}
else if(m->lchild==NULL)
{
if(m->data > m->parent->data) //右子树
{
m->parent->rchild=m->rchild;
}
else
{
m->parent->lchild=m->rchild;
}
}
else if(m->rchild!=NULL)
{
m-> rchild=m->lchild;
}
else//这里让左子树继位
{
m->lchild-> parent;
}
}
free(m);
}
void main()
{
int a[]={0,1,2,3,4,5,6},i;
printf("program start!\n");
printf("Now create a binary tree:\n\n");
v=0;
for(i=0;i<7;i++)
{
add(a[i]);//建立二叉树
}
print(head,1,0);//屏幕输出
printf("\n");
printf("Now delete begin:\n\n");
v=1;
for(k;k>=0;k--)
{
printf("Delete node %d:\n",a[k]);
del(a[k]);//删除节点
}
num=0;
print(head,1,0);
printf("\n");
scanf("%d",a);
}。