二叉查找树带父节点指针的创建，销毁，查找，删除，插入，找前驱后继，找最小值最大值（递归和非递归的实现）

最新推荐文章于 2023-11-13 17:21:55 发布
最新推荐文章于 2023-11-13 17:21:55 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： Algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ustcjackylau/article/details/23281873
版权 
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<time.h>

typedef int  bool ;
#define true  1
#define false 0

#define SWAP(x,y,t) ((t=x),(x=y),(y=t))


#define INT
#ifdef  CHAR
typedef char DataType;
#else
typedef int DataType ;
#endif

typedef struct Node
{
	DataType data;
	struct Node *lchild;
	struct Node *rchild;
	struct Node *parent;
} BSTNode ,* pBSTNode ;

void InsertBST(pBSTNode *root,DataType x);
bool Delete_x_BST(pBSTNode *root,DataType x);   //两个都是删除节点元素但是一个是提供要删除元素的指针，另一个是要删除的元素
void DeleteBST(pBSTNode *root,pBSTNode p ,DataType *x);
pBSTNode SearchBST(pBSTNode root ,DataType x);

pBSTNode SearchMaxBST(pBSTNode root);
pBSTNode SearchMaxBST2(pBSTNode root);
pBSTNode SearchMinBST(pBSTNode root);
pBSTNode SearchMinBST2(pBSTNode root);

pBSTNode SearchPredecessor(pBSTNode p);
pBSTNode SearchSuccessor(pBSTNode p);

pBSTNode CreateBST();
void Visit(DataType data);
void DestroyBST( pBSTNode root);

void PreOrderTraverseBST(pBSTNode root);
void InOrderTraverseBST(pBSTNode root);



void InsertBST(pBSTNode *root,DataType x)
{

	pBSTNode ptr=(pBSTNode) malloc(sizeof(BSTNode) ) ;
	ptr->data=x;
	ptr->lchild=NULL;
	ptr->rchild=NULL;
	ptr->parent=NULL;
	if(! *root)
	{
		*root =ptr;
		return ;
	}

	pBSTNode cur=*root;
	pBSTNode pre=cur;
	while ( cur)
	{
		pre=cur;
		if(cur->data<x )
		{
			cur=cur->rchild;
		}
		//	else if(p->data ==x)
		//	{
		//		printf(" insert the %d is not illegal,BST mustn't have the same key\n ");
		//		exit(-1);
		//	}
		else
		{
			cur=cur->lchild;
		}

	}

	if( pre->data <x)
	{
		pre->rchild=ptr;
		ptr->parent=pre;
	}
	else
	{
		pre->lchild=ptr;
		ptr->parent=pre;
	}

}
/*
 *
 *根据某个节点的指针，删除某个元素，并传回它的值
 *
 * */
void DeleteBST(pBSTNode *root,pBSTNode p ,DataType *x)
{
	if( !p)
	{
		printf("the list is null\n ");
		exit(-1);
	}
        else
        {
         *x=p->data;
        if(p->lchild==NULL && p->rchild==NULL) //待删除节点为叶子节点时
		{
			if( p->parent ==NULL)  //只有一个节点时，根节点发生变化　
			{
				*root=NULL;
			}	
			else
			{
				if(p==p->parent->lchild)
				{
					p->parent->lchild=NULL;
				}
				else if(p==p->parent->rchild)
				{
					p->parent->rchild=NULL;
				}
			}

			free(p) ;
		}

		else if(p->lchild==NULL&& p->rchild!=NULL)  //待删除节点左子树为空，右子树不为空
		{
			if(p->parent==NULL) //待删除节点为根节点时
			{
				*root=p->rchild;
				p->rchild->parent=NULL;
			}
			else
			{
				if(p==p->parent->lchild)
				{
					p->parent->lchild=p->rchild;
					p->rchild->parent=p->parent;
				}
				else
				{
					p->parent->rchild=p->rchild;
					p->rchild->parent=p->parent;
				}
			}
			free(p);

		}

		else if( p->lchild!=NULL && p->rchild==NULL)  //待删除节点左子树不为空，右子树为空
		{
			if(p->parent==NULL)  //待删除节点为根节点时
			{
				*root=p->lchild;
				p->lchild->parent=NULL;
			}
			else
			{
				if(p==p->parent->lchild)
				{
					p->parent->lchild=p->lchild;
					p->lchild->parent=p->parent;
				}
				else
				{
					p->parent->rchild=p->lchild;
					p->lchild->parent=p->parent;
				}
			}
			free(p);

		}

		else  //左右子树都存在的时候
		{
			pBSTNode q=SearchSuccessor(p); //或者是该节点的前驱，由于前驱节点或者后继节点为左子树的最大节点或者为右子树的最小节点
			//则前驱或者后继节点的度必为０或１，由于这个结论我们就可以递归调用Delete_x_BST
			DataType temp;
			SWAP(p->data,q->data,temp) ;
	
			if(q->lchild==NULL && q->rchild==NULL) //待删除节点为叶子节点时
			{
				if( q->parent ==NULL)  //只有一个节点时，根节点发生变化　
				{
					*root=NULL;
				}	
				else
				{
					if(q==q->parent->lchild)
					{
						q->parent->lchild=NULL;
					}
					else
					{
						q->parent->rchild=NULL;
					}

				}
				free(q) ;
			}

			else if(q->lchild==NULL&& q->rchild!=NULL)  //待删除节点左子树为空，右子树不为空
			{
				if(q->parent==NULL) //待删除节点为根节点时
				{
					*root=q->rchild;
					q->rchild->parent=NULL;
				}
				else
				{
					if(q==q->parent->lchild)
					{
						q->parent->lchild=q->rchild;
						q->rchild->parent=q->parent;
					}
					else
					{
						q->parent->rchild=q->rchild;
						q->rchild->parent=q->parent;
					}
				}
				free(q) ;

			}

			else if( q->lchild!=NULL && q->rchild==NULL)  //待删除节点左子树不为空，右子树为空
			{
				if(q->parent==NULL)  //待删除节点为根节点时
				{
					*root=q->lchild;
					q->lchild->parent=NULL;
				}
				else
				{
					if(q==q->parent->lchild)
					{
						q->parent->lchild=q->lchild;
						q->lchild->parent=q->parent;
					}
					else
					{
						q->parent->rchild=q->lchild;
						q->lchild->parent=q->parent;
					}
				}
				free(q) ;
			}

		}

               }

}
/*
 *
 *删除关键字为x的节点
 * 
 * */
bool Delete_x_BST(pBSTNode *root,DataType x)
{
	pBSTNode p=SearchBST(*root ,x) ;
	if(!p)
	{ 
		printf("没有值为x的节点或者二叉树为空(不过二叉树为空也是没有值为x的节点的情况)\n");
		return false;
	}
	else
	{

		if(p->lchild==NULL && p->rchild==NULL) //待删除节点为叶子节点时
		{
			if( p->parent ==NULL)  //只有一个节点时，根节点发生变化　
			{
				*root=NULL;
			}	
			else
			{
				if(p==p->parent->lchild)
				{
					p->parent->lchild=NULL;
				}
				else if(p==p->parent->rchild)
				{
					p->parent->rchild=NULL;
				}
			}

			free(p) ;
		}

		else if(p->lchild==NULL&& p->rchild!=NULL)  //待删除节点左子树为空，右子树不为空
		{
			if(p->parent==NULL) //待删除节点为根节点时
			{
				*root=p->rchild;
				p->rchild->parent=NULL;
			}
			else
			{
				if(p==p->parent->lchild)
				{
					p->parent->lchild=p->rchild;
					p->rchild->parent=p->parent;
				}
				else
				{
					p->parent->rchild=p->rchild;
					p->rchild->parent=p->parent;
				}
			}
			free(p);

		}

		else if( p->lchild!=NULL && p->rchild==NULL)  //待删除节点左子树不为空，右子树为空
		{
			if(p->parent==NULL)  //待删除节点为根节点时
			{
				*root=p->lchild;
				p->lchild->parent=NULL;
			}
			else
			{
				if(p==p->parent->lchild)
				{
					p->parent->lchild=p->lchild;
					p->lchild->parent=p->parent;
				}
				else
				{
					p->parent->rchild=p->lchild;
					p->lchild->parent=p->parent;
				}
			}
			free(p);

		}

		else  //左右子树都存在的时候
		{
			pBSTNode q=SearchSuccessor(p); //或者是该节点的前驱，由于前驱节点或者后继节点为左子树的最大节点或者为右子树的最小节点
			//则前驱或者后继节点的度必为０或１，由于这个结论我们就可以递归调用Delete_x_BST
			DataType temp;
			SWAP(p->data,q->data,temp) ;
			//Delete_x_BST( &*root ,q->data); 但是递归调用会出现问题，如果节点元素相同时，但是带有卫星数据时，删除的数据不是我们要删除的数据

			if(q->lchild==NULL && q->rchild==NULL) //待删除节点为叶子节点时
			{
				if( q->parent ==NULL)  //只有一个节点时，根节点发生变化　
				{
					*root=NULL;
				}	
				else
				{
					if(q==q->parent->lchild)
					{
						q->parent->lchild=NULL;
					}
					else
					{
						q->parent->rchild=NULL;
					}

				}
				free(q) ;
			}

			else if(q->lchild==NULL&& q->rchild!=NULL)  //待删除节点左子树为空，右子树不为空
			{
				if(q->parent==NULL) //待删除节点为根节点时
				{
					*root=q->rchild;
					q->rchild->parent=NULL;
				}
				else
				{
					if(q==q->parent->lchild)
					{
						q->parent->lchild=q->rchild;
						q->rchild->parent=q->parent;
					}
					else
					{
						q->parent->rchild=q->rchild;
						q->rchild->parent=q->parent;
					}
				}
				free(q) ;

			}

			else if( q->lchild!=NULL && q->rchild==NULL)  //待删除节点左子树不为空，右子树为空
			{
				if(q->parent==NULL)  //待删除节点为根节点时
				{
					*root=q->lchild;
					q->lchild->parent=NULL;
				}
				else
				{
					if(q==q->parent->lchild)
					{
						q->parent->lchild=q->lchild;
						q->lchild->parent=q->parent;
					}
					else
					{
						q->parent->rchild=q->lchild;
						q->lchild->parent=q->parent;
					}
				}
				free(q) ;
			}

		}

		return true ;
	}

}


pBSTNode SearchBST(pBSTNode root ,DataType x)
{
	if(! root)
		return NULL;
	if(root->data==x)
		return root;
	else if(root->data < x )
		return SearchBST(root->rchild , x);
	else
		return SearchBST(root->lchild , x);

}

/*
 *查找二叉查找树最大值的递归形式
 *
 * */

pBSTNode SearchMaxBST(pBSTNode root)
{
	if(!root)
		return NULL;
	else if(root->rchild==NULL)
		return root ;
	else
		return SearchMaxBST(root->rchild) ;
}

/*
 *
 *查找二叉查找树的最大值　非递归形式
 *
 * */
pBSTNode SearchMaxBST2(pBSTNode root)
{
	if( !root)
		return NULL;
	else
	{
		pBSTNode cur=root;
		pBSTNode pre=cur;
		while(cur)
		{
			pre=cur;
			cur=cur->rchild;
		}
		return pre;

	}
}

/*
 *查找二叉查找树最小值递归形式
 *
 * */
pBSTNode SearchMinBST(pBSTNode root)
{
	if(!root)
		return NULL;
	else if (root->lchild==NULL)
		return root;
	else return SearchMinBST(root->lchild) ;
}

/*
 *查找二叉查找树最小值非递归形式
 *
 * */

pBSTNode SearchMinBST2(pBSTNode root)
{
	if(!root)
		return NULL;
	else
	{
		pBSTNode cur=root;
		pBSTNode pre=cur;
		while( cur)
		{
			pre=cur;
			cur=cur->lchild;
		}
		return pre;

	}
}


/*
 *
 *查找某个节点的前驱
 *
 * */

pBSTNode SearchPredecessor(pBSTNode p)
{
	if(!p)
	{
		printf("the input is null.don't have the Predecessor\n ") ;
		exit(-1);
	}
	else
	{
		if( p->lchild==NULL)
		{
			pBSTNode pre=p->parent; //父节点
			while(pre)
			{
				if(pre->rchild==p) //如果父节点是爷爷节点的有孩子则爷爷节点就是前驱
				{
					return pre;
				}
				else
				{
					p=pre;
					pre=pre->parent;
				}
			}
			return NULL;
		}
		else
		{
			return SearchMaxBST(p->lchild) ; //如果左子树存在，前驱为左子树的最大值节点
		}

	}
}


pBSTNode SearchSuccessor(pBSTNode p)
{
	if( !p)
	{
		printf("the input is null. don't have the predecessor\n");
		exit(-1);
	}
	else
	{
		if( p->rchild ==NULL)
		{
			pBSTNode pre=p->parent;
			while( pre)
			{
				if(pre->lchild==p)
				{
					return pre;
				}
				else
				{
					p=pre;
					pre=pre->parent;
				}
			}
			return NULL;
		}

		else
		{
			return SearchMinBST(p->rchild);
		}
	}

}

/*
   pBSTNode CreateBST()
   {
   int i;
   int a[10];
   pBSTNode T=NULL;
   srand( (unsigned int) time(NULL) ) ;
   for ( i=0 ;i<10 ;i++)
   a[i]=rand()%30;
   printf("the original data:\n");

   for ( i=0 ;i<10 ;i++)
   printf("%d ",a[i]);
   printf("\n");
   for( i=0 ;i<10 ;i++)
   InsertBST(&T ,a[i]) ;
   return T;
   }
   */


pBSTNode CreateBST()
{
	int i;
	int a[8]={4,7,8,2,3,5,6,9};
	pBSTNode T=NULL;
	printf("the original data:\n");

	for ( i=0 ;i<8 ;i++)
		printf("%d ",a[i]);
	printf("\n");
	for( i=0 ;i<8 ;i++)
		InsertBST(&T ,a[i]) ;
	return T;
}

void Visit(DataType data)
{
	printf(" %d ",data) ;
}

void PreOrderTraverseBST(pBSTNode root)
{
	if(!root)
		return ;
	else
	{
		Visit(root->data);
		PreOrderTraverseBST(root->lchild) ;
		PreOrderTraverseBST(root->rchild) ;
	}
}


void InOrderTraverseBST(pBSTNode root)
{
	if(!root)
		return ;
	else
	{
		InOrderTraverseBST(root->lchild) ;
		Visit(root->data) ;
		InOrderTraverseBST(root->rchild) ;
	}
}

void DestroyBST( pBSTNode root)
{
	if( !root)
		return ;
	else
	{
		DestroyBST( root->lchild) ;
		DestroyBST( root->rchild) ;
		free(root) ;
	}
}

int main()
{
	pBSTNode T=CreateBST() ;
	PreOrderTraverseBST(T) ;
	printf("\n");
	InOrderTraverseBST(T) ;
	printf("\n");
	int i=2;
	pBSTNode p=SearchBST( T ,i) ;
	if( p)
              {
		printf("\nyou search the %d .Success!\n",i);
                printf("\nso you receive the poniter,we can delete it\n");
                DataType x;
                DeleteBST(&T,p,&x);
                printf("要删除的元素是%d \n",x);
                printf("after delete the %d\n",x);
                InOrderTraverseBST(T) ;
	        printf("\n");
              }
	else
		printf("\nyou can't search the %d.\n",i) ;
	pBSTNode predecessor=SearchPredecessor(p) ;
	if( predecessor)
		printf("\nthe predecessor is %d.\n",predecessor->data);
	else
		printf("\n%d don't have the predecessor\n",i) ;
        

	pBSTNode succesor=SearchSuccessor(p) ;
	if( succesor)
		printf(" \nthe successor is %d.\n" ,succesor->data);
	else
		printf(" \n%d don't have the successor\n",i ) ;
    
	DataType del_num=5;
	if( Delete_x_BST(&T ,del_num) )
	{	
                printf("要删除的元素是%d \n",del_num);
                printf("after delete the %d\n",del_num);	
		InOrderTraverseBST(T);
		printf("\n");
	}
     

	p=SearchMaxBST(T) ;
	if (p)
		printf("the BST's MAX 递归形式 is %d\n", p->data) ;

	p=SearchMaxBST2(T) ;
	if (p)
		printf("the BST's MAX 非递归形式 is %d\n" , p->data) ;
	p=SearchMinBST(T) ;
	if(p)
		printf("the BST's Min 递归形式 is %d\n" , p->data) ;

	p=SearchMinBST2(T) ;
	if (p)
		printf("the BST's Min 非递归形式 is %d\n" , p->data) ;


	DestroyBST(T);
	return 1;
}

liuyongvs2009
关注
专栏目录
二叉搜索树的初始化、插入、删除、查找、销毁等操作
Calm的博客
09-15 2340
二叉搜索树的概念 二叉搜索树又称二叉排序树，它或者是一颗空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有结点的值都小于根结点的值 若它的右子树不为空，则右子树上所有结点的值都大于根结点的值 它的左右子树也分别为二叉搜索树 例： 我们要实现这些操作。先定义一个二叉搜索树的结构体，这个结构体成员包括左右孩子两个指针，还有它的数据： typedef int B...
【数据结构树表的查找】二叉排序树详解和代码（生成、插入、查找、最大值、最小值、删除、中序遍历、销毁）
牧之
04-27 6949
二叉排序树（简称BST）又称二叉查找（搜索）树，其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：       （1）若它的左子树非空，则左子树上所有记录的值均小于根记录的值；       （2）若它的右子树非空,则右子树上所有记录的值均大于根记录的值；       （3）左、右子树本身又各是一棵二叉排序树。 注意：二叉排序树中没有相同关键字的节点。 对二叉排序树进行中序遍
编程之美2.10：寻找数组中的最大值和最小值
weixin_34032792的博客
01-06 286
编程之美2.10： 对于一个有N个整数组成的数组，需要比较多少次才能把最大值和最小值找出来呢? 算法的思想是: 分而治之 测试数据：---------------------------------------------------- int [] input1 = { 94, 40, 49, 65, 21, 21, 106, 80, 92, 81, 679, 4, 61, 6, 237,...
运用非递归方法在数组中找出最大值和最小值
Jeff_Winger的博客
06-19 2300
经典程序拿来分享。把数组元素看作二叉树的叶子，两两比较，把较小的和较大的分别记录。当数组长度为n，n为偶数，比较次数为3*(n/2-1)，n为奇数，比较次数为3*(n-1)/2。可以证明这种非递归算法的比较次数最少。原理如下图所示，实际上运用非递归的方法实现递归。代码如下：template&lt;typename T&gt; { }...
带有父节点的二叉查找树实现
weixin_34080903的博客
12-05 152
看来得要个父节点，因为后面的红黑树很需要啊！！   代码 #include &lt;iostream&gt;using namespace std;struct tree{ int data; tree *left,*right,*parent;};void tree_insert(tree *&amp;, int);//二叉查找树的初始化构建void tree_init(t...
数组中最大值与最小值的求取（递归与非递归两种方法）.C
wildot的博客
07-21 1054
基本思想：通过局部最值找到整体最值。 算法：从头开始将数组元素两两相比找出两数中的最值，然后用此局部最值与后面相邻的数比较再找出两数中的最值，如此循环直到数组遍历结束，最后得出的局部最值就是整体最值。 代码： int main() { int num[10]; int i; printf("请输入10个整数：\n"); for (i = 0; i < 10; i++) { scanf("%d", &num[i]); } int pMax=0, pMin=0;//用于保
根据二叉排序树的抽象数据类型的定义，使用二叉链表实现一个二叉排序树。 二叉排序树的基本功能： •二叉排序树的建立 2、二叉排序树的查找 3、二叉排序树的插入 4、 二叉排序树的删除 5、 二叉排序树的销毁 6、其他：自定义操作 编写测试 main()函数测试二叉排序树的正确性。
最新发布
06-25
- 可以实现如最小值、最大值、前驱后继节点查找、范围查找等高级操作。 **测试main()函数**: - 创建一个二叉排序树实例。 - 遍历并打印树中的所有元素，检查是否按顺序排列。 - 插入元素，检查是否成功插入。 - ...
二叉查找树(BST)及红黑树
Anna4的博客
05-18 455
一、定义： 或者是一棵空树 或者是具有下列性质的二叉树 (1)当左子树不空，则左子树上所有结点的值均小于它的根结点的值； (2)它的右子树上所有结点的值均大于它的根节点的值 (3)它的左、右子树也分别为二叉排序树 二、分类 1、平衡二叉树 是自平衡的二叉查找树，又被称为AVL树(有别于AVL算法) 它的左右两个子树的高度差(平衡因子)的绝对值不超过1，并且左右两个子树都是一颗平衡二叉树 2、红黑树...
二叉查找树
solar一抹阳光的专栏
05-30 1339
参考链接：
单链表递归操作详解：遍历、查找与结构实现
- **前驱和后继**：在链表中查找当前节点的前一个或后一个节点，这通常涉及到调整递归调用的位置和比较节点指针。 3. **统计信息**： - **链表长度**：递归计算链表中节点的数量，每次递归调用减少一个节点。 - ...
求最大值，递归与非递归方法
侯文博的专栏
08-28 680
#include #include #include int recursive(unsigned int num, int data[]) { int nextdata, curdata = *data; if (num == 1) { return curdata; } nextdata = recursive(--num, ++data); return curdata > nextdata ? curdata : nextdata; }
LeetCode之递归与非递归求二叉树最大最小深度
weixin_42579072的博客
08-17 307
104. 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 利用递归我们很容易就可以写出来： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x),
用递归法求解一个数组中的最大值和最小值的问题
10-29 5262
用递归法求一个给定的数组中的最大值和最小值。 分析，分治法，类似二分查找，可以先求解出左半部分的最大值和最小值，再求解出又半部分的最大值和最小值然后合并求解，就可以求解出整个数组中的最大值和最小值。 那么递归的出口条件是什么呢？当划分以后只有一个元素的情况下，这个元素既是这个子数组的最大值也是子数组中的最小值，这时候就是递归的出口。下面就让代码开口说话吧。 #include "iostrea
自主建立二叉搜索树（一），插入、建立、查询、最大最小关键字、前驱、后继...
weixin_38168838的博客
11-03 138
目录： 1.什么是二叉搜索树 2.二叉搜索树的由来与作用 3.二叉搜索树的建立 1.什么是二叉搜索树？ 二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有一下性质的树： 　　若它的左子树不空，则左子树上所有的结点的值均不大于它根结点的值； 　　若它的左子树不空，则左子树上所有的结点的值均不小于它根结点的值； 　　它的左右子树也是二叉搜索树。 2.二叉搜...
二叉搜索树(BST)的查找(分为递归和迭代)，创建，插入，删除
言叶之庭
02-26 636
1.二叉搜索树的概念        二叉搜索树又称二叉排序树，它有如下性质：                1.若左子树不为空，左子树上的所有节点的key值都小于根节点。                2.若右子树不为空，右子树上的所有节点的key值都大于根节点。                3.中序遍历可以得到有序序列。                4.不存在key值相同的节点。2.二叉搜索...
排序算法-选择排序（递归和非递归）
qq_44627822的博客
11-21 734
赶时间的学习记录，没来得及精写。 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 非递归： void selectsort1(int *a,int n) { int i,j,min_pos; for(i=0;i<n-1;i++) { m
LeetCode-- 恢复二叉搜索树(中序遍历 双指针)
weixin_41563161的博客
10-02 295
恢复二叉搜索树 二叉搜索树中的两个节点被错误地交换。 请在不改变其结构的情况下，恢复这棵树。 示例1: 输入: [1,3,null,null,2] 1 / 3 \ 2 输出: [3,1,null,null,2] 3 / ...
数据结构与算法---复习：树 父指针表示法
weixin_43990171的博客
08-17 1221
数据结构与算法—复习：树 父指针表示法 /** * 程序说明：复习 树的三种实现方式 树的周游 */ #include <stdio.h> #include <malloc.h> /** * 树 结点类型 */ struct ParTreeNode{ char info; //结点信息 int parent; //父结点位置 }; /** * 树类型 */ struct ParTree{ int MAXNUM; //当前可存放最大结点数
【数据结构】树与二叉树（十四）：二叉树的基础操作：查找给定结点的父亲（算法Father ）
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
11-13 1618
本文介绍了二叉树的基础操作——查找给定结点的父亲（算法Father ）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值