链表实现二叉树

最新推荐文章于 2023-05-31 16:27:38 发布
最新推荐文章于 2023-05-31 16:27:38 发布
阅读量199 收藏 1
点赞数
分类专栏： C语言数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43528481/article/details/115003292
版权 

#include<winuser.inl>
#include<stdio.h>
#include <time.h>
#include <cstdlib>
#include <string.h>

/*
	  3 5 8 2 6 9 7
	  前序遍历：3 5 2 6 8 9 7
	  中序遍历：2 6 5 3 9 8 7
	  后序遍历：2 6 5 9 7 8 3

		树：
				3（0）
		5（1）			 8（2）
	2（3）  6（4）   9（5）   7（6）
*/

#define left 1
#define right 2

typedef struct tag_node
{
	int data;
	int index;
	struct tag_node   *pLeftChild, * pRightChild, * pParent;
}Node;

typedef struct tag_tree
{
	//该结构体指向树的根节点
	Node* root;
}Tree;

bool CreateTree(Tree** pTree, Node* pRoot);
void DestroyTree(Tree* pTree);
Node* SearchNodeindex(Node* pNode, int nodeIndex);  //节点层面
Node* SearchNode(Tree* pTree, int nodeindex);      //树层面
bool AddNode(Tree* pTree, int nodeindex, Node* pNode, int d1irection);
void DeleteN(Node* pNode, int direaction); //节点层面
bool DeleteNode(Tree* pTree, int nodeindex, Node* pNode);
void PreorderNode(Node* pNode);
void PreorderPrintTree(Tree* pTree);
void MidOrderNode(Node* pNode);
void MidOrderPrintTree(Tree* pTree);
void FinOrderNode(Node* pNode);
void  FinOrderPrintTree(Tree* pTree);

bool CreateTree(Tree** pTree, Node* pRoot)
{
	*pTree = (Tree*)malloc(sizeof(Tree));
	if (*pTree == NULL)
	{
		printf("failed\n");
		return false;
	}
	else
	{
		(*pTree)->root = (Node*)malloc(sizeof(Node));
		if ((*pTree)->root == NULL)
		{
			printf("failed\n");
			free(*pTree);   //这里分配失败，就把前面的内存释放掉
			return false;
		}
		//else    采用链表形式，不需要再左初始化
		//{
		//	//给树的所有节点赋初值为0
		//	for (int i = 0; i < MAXSIZE; i++)
		//	{
		//		(*pTree)->root[i].data = 0;
		//	}

		//	//创建的数的第一个节点需要有数据，将传进来的数据复制给第一个节点
		//	
		else
		{
			//(*pTree)->root[0] = *pRoot;
			*((*pTree)->root) = *pRoot;  //对象拷贝，与下面等价

			//(*pTree)->root->data = pRoot->data;
			//(*pTree)->root->index = pRoot->index;
			//(*pTree)->root->pLeftChild = NULL;
			//(*pTree)->root->pRightChild = NULL;
			//(*pTree)->root->pParent = NULL;

			return true;
		}
			
	}
}

void DeleteN(Node* pNode, int direaction)
{
	//判断传入进来的指针是否为空
	if (pNode != NULL)
	{
		DeleteN(pNode->pLeftChild, left);
		DeleteN(pNode->pRightChild, right);

		/*
		删除某一结点的左右子节点之后，进一步删除自己，删除自己之前
		需要将判断当前节点是属于自己父节点的左节点还是右节点，然后进一步
		将父节点对一个的左节点（右节点）置为null,然后再释放当前节点的内存
		*/
		if (direaction == left)
		{
			pNode ->pParent ->pLeftChild = NULL;
		}

		if (direaction == right)
		{
			pNode->pParent ->pRightChild = NULL;
		}

		free(pNode);
		pNode = NULL;
	}
}

void DestroyTree(Tree* pTree)
{
	//需要逐一销毁每一个节点
	DeleteN(pTree->root->pLeftChild, left);
	DeleteN(pTree->root->pRightChild, right);

	free(pTree->root);
	free(pTree);
}

//bool SearchNode(Tree* pTree, int nodeindex ,Node *node)
//{
//	这里的Node *node是用来存放要查找的那个数据
//	if (nodeindex < 0 || nodeindex >= MAXSIZE)
//	{
//		return false;
//	}
//	else
//	{
//		if (pTree->root[nodeindex].data == 0)
//		{
//			return false;
//		}
//		else
//		{
//			node->data = pTree->root[nodeindex].data;
//			return true;
//		}
//	}
//}

Node* SearchNodeindex(Node* pNode, int nodeIndex)
{
	if (pNode == NULL)
	{
		return NULL;
	}
	else
	{
		/*
		递归查找和传入索引一致的节点
		判断当前节点是否满足条件，不满足，则进一步查找当前节点的左子树，返回左子树
		的节点，以便递归进而寻炸左子树的左子树
		如果左子树是空的，那么只能进一步递归查找右子树
		*/
		if (pNode->index == nodeIndex)
		{
			return pNode;
		}
		else
		{
			Node* temp = NULL;
			temp = SearchNodeindex(pNode->pLeftChild, nodeIndex);
			if (temp != NULL)
			{
				return temp;
			}
			else
			{
				temp = SearchNodeindex(pNode->pRightChild, nodeIndex);
				return temp;
			}		
		}
	}
}

Node* SearchNode(Tree* pTree, int nodeindex)
{
	return SearchNodeindex(pTree->root, nodeindex); 
}

bool AddNode(Tree* pTree, int nodeindex, Node* pNode, int d1irection)
{
	/*
	1.找到要添加元素的节点
	2.判断该节点是否为空，为空，不能添加孩子，如果不为空，判断是要添加左孩子还是右
	，然后需要进一步判断（左）右孩子是否为空，为空才能添加子孩子
	*/
	Node* temp;
	Node* newNode = NULL;
	temp = SearchNode(pTree, nodeindex);

	//开辟一个节点的空间来存放传进来的 pNode节点数据，如果直接将temp指向pNode，
	//pNode申请的内存空间是在函数外面申请的，如果函数外面释放掉pNode的空间，那么Temp
	//就不知道指向哪了，所以最好的方式是在函数里面自己申请一个空间来存放节点数据

	if (temp != NULL)
	{
		if (d1irection == left)
		{
			if (temp->pLeftChild == NULL)
			{
				Node* newNode = (Node*)malloc(sizeof(Node));
				if (newNode == NULL)
				{
					return false;
				}
				else
				{
					*newNode = *pNode; //数据拷贝
					temp->pLeftChild = newNode;   //将temp的左孩子指向newnode

					//另外，每一个节点里面处理孩子节点，还有父亲节点
					newNode->pParent = temp; //将新节点的父节点指向temp

					return true;
				}			
			}
			else
			{
				return false;
			}
		}

		if (d1irection == right)
		{
			if (temp->pRightChild == NULL)
			{
				Node* newNode = (Node*)malloc(sizeof(Node));
				if (newNode == NULL)
				{
					return false;
				}
				else
				{
					*newNode = *pNode; //数据拷贝
					temp->pRightChild = newNode;   //将temp的左孩子指向newnode

					//另外，每一个节点里面处理孩子节点，还有父亲节点
					newNode->pParent = temp; //将新节点的父节点指向temp
					return true;
				}
			}
			else
			{
				return false;
			}
		}		
	}
	else
	{
		return false;
	}
}

bool DeleteNode(Tree* pTree, int nodeindex, Node* pNode)
{
	//DeleteNode这里是删除指定的节点，同时要删除指定节点之后的所有子节点
	//DeleteN作用是删除传入节点以下的全部节点，起始两个函数作用是一样的

	//需要先找到要删除的节点
	Node* temp;
	temp = SearchNode(pTree,nodeindex);
	if (temp != NULL)
	{
		//递归删除掉索引到的节点的全部子节点
		DeleteN(temp ->pLeftChild, left);
		DeleteN(temp ->pRightChild, right);

		//下面和在DeleteN里面一样，需要将当前的节点置为null，需要找到当前
		//节点的父节点，判断当前节点是父节点的左孩子还是右孩子
		if (temp->pParent->pLeftChild == temp)
		{
			temp->pParent->pLeftChild = NULL;
		}

		if (temp->pParent->pRightChild == temp)
		{
			temp->pParent->pRightChild = NULL;
		}
		free(temp);
		temp = NULL;
		return true;
	}
	else
	{
		return false;
	}
}

void PreorderNode(Node* pNode)
{
	if (pNode != NULL)
	{
		printf("%d ", pNode->data);
		PreorderNode(pNode->pLeftChild);
		PreorderNode(pNode->pRightChild);
	}
}

void PreorderPrintTree(Tree* pTree)
{
	//根左右
	printf("the tree is:\n");
	PreorderNode(pTree->root);
	printf("\n");
}

void MidOrderNode(Node* pNode)
{
	if (pNode != NULL)
	{
		MidOrderNode(pNode->pLeftChild);
		printf("%d ", pNode->data);
		MidOrderNode(pNode->pRightChild);
	}
}

void MidOrderPrintTree(Tree* pTree)
{
	//左中右
	printf("the tree is:\n");
	MidOrderNode(pTree->root);
	printf("\n");
}

void FinOrderNode(Node* pNode)
{
	if (pNode != NULL)
	{
		FinOrderNode(pNode->pLeftChild);
		FinOrderNode(pNode->pRightChild);
		printf("%d ", pNode->data);
	}
}

void  FinOrderPrintTree(Tree* pTree)
{
	//左右根
	printf("the tree is:\n");
	FinOrderNode(pTree->root);
	printf("\n");
}

int main()
{
	Tree* pTree = NULL;
	Node node = { 3 ,0, NULL, NULL ,NULL };  //给一个初值
	Node node1 = { 5 ,1, NULL, NULL ,NULL };
	Node node2 = { 8 ,2, NULL, NULL ,NULL };
	Node node3 = { 2 ,3, NULL, NULL ,NULL };
	Node node4 = { 6 ,4, NULL, NULL ,NULL };
	Node node5 = { 9 ,5, NULL, NULL ,NULL };
	Node node6 = { 7 ,6, NULL, NULL ,NULL };
	Node *node_d;

	CreateTree(&pTree, &node);
	AddNode(pTree, 0, &node1, left);
	AddNode(pTree, 0, &node2, right);
	AddNode(pTree, 1, &node3, left);
	AddNode(pTree, 1, &node4, right);
	AddNode(pTree, 2, &node5, left);
	AddNode(pTree, 2, &node6, right);
	PreorderPrintTree(pTree);

	//node_d = SearchNode(pTree, 3);
	//printf("index is %d ,data is %d\n", 3, node_d->data);

	printf("after delete node,");
	node_d = (Node*)malloc(sizeof(Node));
	DeleteNode(pTree, 2, node_d);
	PreorderPrintTree(pTree);

	DestroyTree(pTree);

	return 0;
}

在这里插入图片描述

猪猪虾的业余生活
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于链表实现二叉树(java算法源码)
01-20
/* * 基于链表实现二叉树 */ package dsa; public class BinTree_LinkedList implements BinTree { protected BinTreePosition root;//根节点 /**************************** 构造函数 ****************************/ public BinTree_LinkedList() { this(null); } public BinTree_LinkedList(BinTreePosition r) { root = r; } /**************************** BinaryTree接口方法 ****************************/ //返回树根 public BinTreePosition getRoot() { return root; } //判断是否树空 public boolean isEmpty() { return null == root; } //返回树的规模（即树根的后代数目） public int getSize() { return isEmpty() ? 0 : root.getSize(); } //返回树（根）的高度 public int getHeight() {return isEmpty() ? -1 : root.getHeight(); } //前序遍历 public Iterator elementsPreorder() { return root.elementsPreorder(); } //中序遍历 public Iterator elementsInorder() { return root.elementsInorder(); } //后序遍历 public Iterator elementsPostorder() { return root.elementsPostorder(); } //层次遍历 public Iterator elementsLevelorder() { return root.elementsLevelorder(); } }
使用链表实现二叉树
08-30
在这个场景中，我们将使用C++编程语言通过链表来实现二叉树，这将帮助我们更灵活地管理内存，同时便于实现二叉树的各种操作。 首先，我们需要定义一个二叉树节点结构。在C++中，可以创建一个名为`Node`的结构体或类...
链表实现 二叉树
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-30 2115
链表实现二叉树
用链表来实现二叉树
weixin_51270766的博客
01-24 1245
二叉树最多只能有两个子节点，也就是说分支度小于或等于2.所谓二叉树的链表表示法，就是利用链表来存储二叉树。 使用链表来表示二叉树的好处是节点的增加与删除操作相对容易，缺点是很难找到父节点，除非在每一节点多增加一个指向父字段。 代码实现： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /** * @author admin $ * @title $ *
吐血整理 二叉树(链表实现)的基本操作详解！
weixin_62976968的博客
05-31 2984
本文是对二叉树这种数据结构基本操作与部分练习题的总结，内容庞大、详细、易懂，是你学习路上不容错过的优质博客！
数据结构——链式二叉树
一怀明月的博客
05-30 1323
数据结构——链式二叉树
使用C++链表实现二叉树的存储及基本操作
10-06
本项目通过结合链表的基本操作来实现二叉树的存储，以及包括前序、中序、后序遍历在内的各种基本操作。以下是关于这个主题的详细讲解。 首先，我们需要理解二叉树的基本概念。二叉树是由节点（或称为顶点）构成的...
用二叉链表实现二叉树的基本操作.pdf
11-25
"用二叉链表实现二叉树的基本操作.pdf" 本资源为一份关于使用二叉链表实现二叉树的基本操作的教程，包括构造、遍历等基本操作。文中提供了C++代码，展示了如何使用二叉链表实现二叉树的基本操作，包括先序遍历、...
基于二叉链表的二叉树实现
01-12
基于二叉链表的二叉树实现：依据最小完备性和常用性相结合的原则，以函数形式定义了二叉树的创建二叉树、销毁二叉树、清空二叉树、判定空二叉树和求二叉树深度等14种基本运算。依据最小完备性和常用性相结合的原则，...
树：二叉链表的实现
重庆李四
02-12 7314
二叉链表介绍二叉树每个结点最多有2个孩子，所以为它设计一个数据域和2个指针域是比较自然的想法，我们称这样的链表叫做二叉链表。二叉链表思路二叉链表的数据结构，数据域，左右孩子指针域。每个树结点都有左右孩子，如果没有孩子那么孩子指针域为NULL。我们用char类型的数据来模拟二叉链表的创建和遍历。我们知道二叉链表的遍历有3种，前序遍历，中序遍历，后序遍历。那么创建链表的时候同样我们可以约定是前序、中序...
链表二叉树
07-12
链表二叉树实际用于验 收课程设计里面有 中序 后序 递归和非递归
二叉树的二叉链表实现
07-03
使用二叉链表实现二叉树，提供常见的操作：各种遍历，求树高，节点数。
[数据结构]二叉树之二叉链表的类模板实现
借你一秒
07-29 5014
该类模板实现了一个二叉树的模板类，采用二叉链表实现。定义二叉树节点类，采用二叉链表实现。///////////////////////// #include #include #include #include using namespace std; template struct BinTreeNode //二叉树节点类的定义，使用二叉链表 { T data; B
用二叉链表建立二叉树
dizp47129的博客
05-10 1718
1 #include<stdio.h> 2 #include<stdlib.h> 3 typedef struct node 4 { 5 int data; 6 struct node *l,*r; 7 8 }tree; 9 tree* Creattree(void)//层次建立二叉树 10 {...
“二叉树”——链表表示
weixin_30326745的博客
02-04 294
二叉树相关定义： 二叉树有三种表示方法，今天就以这三种表示方法分别讨论。 1.二叉链表表示 那么二叉树的基本遍历方式有三种（前序、中序、后序） 代码层次： tree.h #ifndef _TREE_H #define _TREE_H typedef struct node { char data; struct node *lchild,*rchild...
二叉树（链表表示）
Cdreamfly的博客
02-17 380
Node.h #pragma once class Node { public: Node(); Node* SearchNode(int indexnode); void DeleteNode(); void PreorderTraversal(); void InorderTraversal(); void PostorderTraversal(); int index; i...
基于链表树的实现
冯斌
04-09 1203
package algorithtms.tree；/** *@Title: *@Description:树ADT接口 *@Author:fengbin *@Since:2018年4月8日 *@Version:1.1.0 */public interface Tree {    /**     * @return     * @Author:fengbin     * @Since:2018年4月9...
二叉树的遍历（先序、中序、后序和层次遍历）
热门推荐
DX奥特曼的博客
12-29 3万+
采用二叉链表结构实现二叉树，并以递归遍历思想实现二叉树的创建、二叉树的遍历（先序、中序、后序和层次遍历）、二叉树叶子节点统计、二叉树深度统计的算法；同时，结合课件和实例代码，实现二叉树的中序非递归遍历算法。存储结构和操作接口定义如下: /*①二叉树的二叉链表存储结构定义*/ typedef struct BiTNode { ElemType data; struct BiTNode *l
C语言链表实现二叉树
最新发布
11-14
链表实现二叉树是一种常见的数据结构，可以用于存储和操作树形结构的数据。下面是C语言链表实现二叉树的方法： 定义结构体： ```c typedef struct TreeNode { int data; struct TreeNode *left; struct ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值