二叉树的二叉链表实现

最新推荐文章于 2021-10-03 23:55:15 发布
原创 最新推荐文章于 2021-10-03 23:55:15 发布 · 553 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 

#ifndef HEAD_H__
#define HEAD_H__

#include<stdlib.h>
#include<stdio.h>
#include<string.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2

typedef int status;
typedef int boolean;

//元素定义合集//////////////////////////////
typedef int ElementType;
//typedef int SElementType;//调用conversion()函数的时候使用此类型
//typedef int QElementType;

//二叉树数据结构////////////////////////////
typedef int TElementType;
typedef struct biTreeNode{
	TElementType data;
	struct biTreeNode *lChild;
	struct biTreeNode *rChild;
}biTreeNode,*biTree;
typedef biTree QElementType;
typedef biTree SElementType;

/*/定义迷宫的结构体//////////////////////////
typedef struct{
	int x;
	int y;
}PositionType;
typedef struct{
	int ord;
	PositionType seat;
	int di;
}SElementType;
///////////////////////////////////////////////*/

//常用函数合集////////////////////////////////////
#define MAX 100
//void view(ElementType *);
//void view(SElementType *);
//void view(QElementType *);
status visit(TElementType e);
status compare(ElementType ,ElementType);
void buildSet(ElementType a[],int length,int beg,int end);
void printSet(ElementType a[],int length);
void swap(ElementType *e1,ElementType *e2);
int maxInt(int m,int n);

//match.c的函数集合，用于模式匹配///////////////////
int index(char *S,char *T,int pos);
int indexKMP(char *S,char *T,int pos);

//快速排序////////////////////////////////////////
void quickSort(ElementType a[],int p,int r);
void randomizedQuickSort(ElementType a[],int p,int r);

//使用栈实现的数制转换/////////////////////////////
void conversion(SElementType N,int d);

#endif

#ifndef QUEUE_H__
#define QUEUE_H__

#include"head.h"

typedef struct QueueNode{
	QElementType elem;
	struct QueueNode *next;
}QueueNode,*QueuePtr;

typedef struct{
	QueuePtr front;
	QueuePtr rear;
}linkQueue;

status initQueue(linkQueue *Q);
status destroyQueue(linkQueue *Q);
status clearQueue(linkQueue *Q);
boolean queueEmpty(linkQueue Q);
int queueLength(linkQueue Q);
status getHead(linkQueue Q,QElementType *e);
status enQueue(linkQueue *Q,QElementType e);
status deQueue(linkQueue *Q,QElementType *e);
void queueTraverse(linkQueue Q,void (*view)(QElementType *));

#endif

#ifndef SQSTACK_H__
#define SQSTACK_H__

#include"head.h"

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

struct stack{
	SElementType *base;
	SElementType *top;
	int stackSize;
};
typedef struct stack sqStack;

status initStack(sqStack *S);
status destroyStack(sqStack *S);
status clearStack(sqStack *S);
int stackLength(sqStack S);
boolean stackEmpty(sqStack S);
boolean push(sqStack *S,SElementType e);
boolean pop(sqStack *S,SElementType *e);
status getTop(sqStack S,SElementType *e);
void stackTraverse(sqStack S,void (*view)(SElementType*));

#endif

#ifndef BITREE_H__
#define BITREE_H__

#include"head.h"

status initBiTree(biTree *T);
void destroyBiTree(biTree *T);

#define clearBiTree destroyBiTree

void createBiTree(biTree *T);
boolean biTreeEmpty(biTree T);
int depth(biTree T);
TElementType root(biTree T);
TElementType value(biTree p);
void assign(biTree p,TElementType value);

#include"Queue.h"

TElementType parent(biTree T,TElementType e);
biTree pointer(biTree T,TElementType e);
TElementType leftChild(biTree T,TElementType e);
TElementType rightChild(biTree T,TElementType e);
TElementType leftSibling(biTree T,TElementType e);
TElementType rightSibling(biTree T,TElementType e);
status insertChild(biTree p,int LR,biTree c);
status deleteChild(biTree p,int LR);
void preOrderTraverse(biTree T,status (*visit)(TElementType));
void inOrderTraverse(biTree T,status (*visit)(TElementType));
void postOrderTraverse(biTree T,status (*visit)(TElementType));
void levelOrderTraverse(biTree T,status (*visit)(TElementType));

#include"sqStack.h"
status inOrderTraverse1(biTree T,status (*visit)(TElementType));
status inOrderTraverse2(biTree T,status (*visit)(TElementType));

#endif

#include"head.h"
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

void view(QElementType *e)
{
	printf("%d\t",*e);
}

status visit(TElementType e)
{
	printf("%d\t",e);
	return OK;
}

status compare(ElementType e1,ElementType e2)
{
	if(e1==e2)
		return TRUE;
	else
		return FALSE;
}

void buildSet(ElementType a[],int length,int beg,int end)
{
	int i;

	srand((unsigned)time(NULL));
	for(i=0;i<length;i++)
		a[i]=rand()%(end-beg+1)+beg;
}

void printSet(ElementType a[],int length)
{
	int i,count=1;
	
	for(i=0;i<length;i++,count++)
	{
		printf("%d\t",a[i]);
		if(count%10==0)
			printf("\n");
	}
}

void swap(ElementType *e1,ElementType *e2)
{
	ElementType tmp;
	tmp=*e1;
	*e1=*e2;
	*e2=tmp;
}

int maxInt(int m,int n)
{
	return m>n?m:n;
}

#include"Queue.h"

status initQueue(linkQueue *Q)
{
	Q->front=(QueuePtr)malloc(sizeof(QueueNode));
	if(!Q->front)
		exit(1);

	Q->rear=Q->front;
	Q->front->next=NULL;

	return OK;
}

status destroyQueue(linkQueue *Q)//很巧，，可以多看看
{
	while(Q->front)
	{
		Q->rear=Q->front->next;
		free(Q->front);
		Q->front=Q->rear;
	}
	return OK;
}

status clearQueue(linkQueue *Q)
{
	while(Q->front!=Q->rear)
	{
		QueuePtr p;
		p=Q->front->next;
		free(Q->front);
		Q->front=p;
	}

	return OK;
}
boolean queueEmpty(linkQueue Q)
{
	return (Q.front==Q.rear)?TRUE:FALSE;
}
int queueLength(linkQueue Q)
{
	QueuePtr p;
	int i=0;

	p=Q.front;
	while(p!=Q.rear)
	{
		i++;
		p=p->next;
	}

	return i;
}

status getHead(linkQueue Q,QElementType *e)
{
	if(queueEmpty(Q))
		exit(1);
	*e=Q.front->next->elem;

	return OK;
}
status enQueue(linkQueue *Q,QElementType e)
{
	QueuePtr p;

	p=(QueuePtr)malloc(sizeof(QueueNode));
	if(!p)
		exit(1);
	p->elem=e;
	p->next=NULL;

	Q->rear->next=p;
	Q->rear=p;

	return OK;
}

status deQueue(linkQueue *Q,QElementType *e)
{
	QueuePtr p;

	if(queueEmpty(*Q))
		return ERROR;
	p=Q->front->next;
	*e=p->elem;
	Q->front->next=p->next;
	if(Q->rear==p)//如果仅有一个元素的时候，该情形发生,鲁棒性不够好
		Q->rear=Q->front;
	free(p);

	return OK;
}


void queueTraverse(linkQueue Q,void (*view)(QElementType *))
{
	QueuePtr p;
	
	p=Q.front->next;
	while(p)
	{
		view(&p->elem);
		p=p->next;
	}
}

#include"sqStack.h"

status initStack(sqStack *S)
{
	S->base=(SElementType*)malloc(STACK_INIT_SIZE*sizeof(SElementType));

	if(!S->base)
		exit(OVERFLOW);

	S->top=S->base;
	S->stackSize=STACK_INIT_SIZE;

	return OK;
}

status destroyStack(sqStack *S)
{
	free(S->base);
	S->base=NULL;
	S->top=NULL;
	S->stackSize=0;
	
	return OK;
}

status clearStack(sqStack *S)
{
	S->top=S->base;

	return OK;
}

int stackLength(sqStack S)
{
	return S.top-S.base;//这个速度是O(1)；
/*	
	SElementType *p;
	int i=0;

	p=S.base;
	for(p;p!=S.top;++p)
		++i;

	return i;
*/
}

boolean stackEmpty(sqStack S)
{
	return (S.top==S.base)?1:0;
}
boolean push(sqStack *S,SElementType e)
{
	if(S->top-S->base>=S->stackSize)//此处注意stackSize有可能扩展过
	{
		S->base=(SElementType *)realloc(S->base,(S->stackSize+STACKINCREMENT)*sizeof(SElementType));
		if(!S->base)
			exit(OVERFLOW);
		S->top=S->base+S->stackSize;
		S->stackSize+=STACKINCREMENT;
	}

	*S->top++=e;

	return OK;
}

boolean pop(sqStack *S,SElementType *e)
{
	if(S->top==S->base)
		return ERROR;

	*e=*--S->top;

	return OK;
}
status getTop(sqStack S,SElementType *e)
{
	if(S.base==S.top)
		return ERROR;

	*e=*(S.top-1);//此处并不是要弹出元素，只是获得元素故不能使用*--S.top。

	return OK;
}
void StackTraverse(sqStack S,void (*view)(SElementType*))
{
	SElementType *p;

	p=S.base;
	while(p!=S.top)
		view(p++);
}

#include"biTree.h"
#define INF 0			//以0作为空元素，也可以根据实际需要定义

TElementType NIL=0;

status initBiTree(biTree *T)
{
	*T=NULL;//构造一个空二叉树,T就是树的根，只是没有指定数据和孩子
	return OK;
}

void destroyBiTree(biTree *T)
{
	if(*T)
	{
		if((*T)->lChild)
			destroyBiTree(&(*T)->lChild);
		if((*T)->rChild)
			destroyBiTree(&(*T)->rChild);
		free(*T);
		*T=NULL;
	}
}

void createBiTree(biTree *T)//需要进一步改进
{
	TElementType element;

	scanf("%d",&element);//此处如果是使用复杂结构体的话，可以修改成一个getElement()函数
	if(element==NIL)//通过输入一个无穷的数来创建一个空树,也是为了控制创建树的退出方式
		*T=NULL;
	else
	{
		*T=(biTree)malloc(sizeof(biTreeNode));

		if(!*T)
			exit(OVERFLOW);

		(*T)->data=element;
		createBiTree(&(*T)->lChild);
		createBiTree(&(*T)->rChild);
	}
}

boolean biTreeEmpty(biTree T)
{
	return T==NULL?TRUE:FALSE;
}

int depth(biTree T)//二叉树的深度,递归实现
{
	int l,r;

	if(!T)
		return 0;

	if(T->lChild)
		l=depth(T->lChild);
	else
		l=0;

	if(T->rChild)
		r=depth(T->rChild);
	else
		r=0;
	
	return l>r?l+1:r+1;
}

TElementType root(biTree T)
{
	if(biTreeEmpty(T))
		return NIL;
	else
		return T->data;
}

TElementType value(biTree p)
{
	return p->data;
}

void assign(biTree p,TElementType value)
{
	p->data=value;
}

//这个是递归版本的,还未测试
/*TElementType parent(biTree T,TElementType e)
{
	biTree p;

	if(T)
	{
		p=T;

		if(p->lChild && p->lChild->data==e || p->rChild && p->rChild->data==e)
			return p->data;
		else
		{
			parent(p->lChild,e);
			parent(p->rChild,e);
		}
	}

	return NULL;
}*/
TElementType parent(biTree T,TElementType e)//使用队列来求parent
{
	linkQueue Q;
	QElementType x;

	if(T)
	{
		initQueue(&Q);
		enQueue(&Q,T);

		while(!queueEmpty(Q))
		{
			deQueue(&Q,&x);
			if(x->lChild && x->lChild->data==e || x->rChild && x->rChild->data==e)
				return x->data;
			else
			{
				if(x->lChild)
					enQueue(&Q,x->lChild);
				if(x->rChild)
					enQueue(&Q,x->rChild);
			}
		}
	}
	return NIL;
}


biTree pointer(biTree T,TElementType e)
{
	linkQueue Q;
	QElementType x;

	if(T)
	{
		initQueue(&Q);
		enQueue(&Q,T);

		while(!queueEmpty(Q))
		{
			deQueue(&Q,&x);

			if(x->data==e)
				return x;

			if(x->lChild)
				enQueue(&Q,x->lChild);
			if(x->rChild)
				enQueue(&Q,x->rChild);
		}
	}
	return NULL;
}

TElementType leftChild(biTree T,TElementType e)//使用了pointer函数
{
	biTree x;

	if(T)
	{
		x=pointer(T,e);

		if(x && x->lChild)
			return x->lChild->data;
	}
	return NIL;
}

TElementType rightChild(biTree T,TElementType e)
{
	biTree x;

	if(T)
	{
		x=pointer(T,e);

		if(x && x->rChild)
			return x->rChild->data;
	}
	return NIL;
}

TElementType leftSibling(biTree T,TElementType e)
{
	biTree x;
	TElementType e1;

	if(T)
	{
		e1=parent(T,e);
		x=pointer(T,e1);

		if(x->lChild && x->rChild && x->rChild->data==e)
			return x->lChild->data;
	}
	return NIL;
}

TElementType rightSibling(biTree T,TElementType e)
{
	biTree x;
	TElementType e1;

	if(T)
	{
		e1=parent(T,e);
		x=pointer(T,e1);

		if(x->lChild && x->rChild && x->lChild->data==e)
			return x->rChild->data;
	}
	return NIL;
}

status insertChild(biTree p,int LR,biTree c)
{
	if(p)
	{
		if(LR==0)
		{
			c->rChild=p->lChild;
			p->lChild=c;
		}
		else
		{
			c->rChild=p->rChild;
			p->rChild=c;
		}
		return OK;
	}
	return ERROR;
}

status deleteChild(biTree p,int LR)
{
	if(p)
	{
		if(LR==0)
			clearBiTree(&p->lChild);
		else
			clearBiTree(&p->rChild);
		return OK;
	}
	return ERROR;
}

void preOrderTraverse(biTree T,status (*visit)(TElementType))
{
	if(T)
	{
		visit(T->data);
		preOrderTraverse(T->lChild,visit);
		preOrderTraverse(T->rChild,visit);
	}
}

void inOrderTraverse(biTree T,status (*visit)(TElementType))
{
	if(T)
	{
		inOrderTraverse(T->lChild,visit);
		visit(T->data);	
		inOrderTraverse(T->rChild,visit);
	}
}

void postOrderTraverse(biTree T,status (*visit)(TElementType))
{
	if(T)
	{
		postOrderTraverse(T->lChild,visit);
		postOrderTraverse(T->rChild,visit);
		visit(T->data);
	}
}

void levelOrderTraverse(biTree T,status (*visit)(TElementType))
{
	linkQueue Q;
	QElementType x;

	if(T)
	{
		initQueue(&Q);
		enQueue(&Q,T);

		while(!queueEmpty(Q))
		{
			deQueue(&Q,&x);

			visit(x->data);
			if(x->lChild)
				enQueue(&Q,x->lChild);
			if(x->rChild)
				enQueue(&Q,x->rChild);
		}
		putchar('\n');
	}
}


status inOrderTraverse1(biTree T,status (*visit)(TElementType))
{
	sqStack S;
	biTree p;

	initStack(&S);
	push(&S,T);
	while(!stackEmpty(S))
	{
		while(getTop(S,&p) && p)
			push(&S,p->lChild);

		pop(&S,&p);
		if(!stackEmpty(S))
		{
			pop(&S,&p);
			if(!visit(p->data))
				return ERROR;
			push(&S,p->rChild);
		}
	}
	return OK;
}

status inOrderTraverse2(biTree T,status (*visit)(TElementType))
{
	sqStack S;
	
	initStack(&S);
	while(T || !stackEmpty(S))
	{
		if(T)
		{
			push(&S,T);
			T=T->lChild;
		}
		else
		{
			pop(&S,&T);
			if(!visit(T->data))
				return ERROR;
			T=T->rChild;
		}
	}
	return OK;
}
#include"head.h"
#include"Queue.h"
#include"sqStack.h"
#include"biTree.h"

/*
status inOrderTraverse1(biTree T,status (*visit)(TElementType));
status inOrderTraverse2(biTree T,status (*visit)(TElementType));
*/

int main()
{
	biTree T,p,ptr,T1;
	int deep;
	TElementType r,e1,e2;

	initBiTree(&T);
	printf("the address of binary tree is :%d\n",T);

	
	createBiTree(&T);//先根遍历的测试用例：986215743
	printf("traverse the binary tree\n");
	preOrderTraverse(T,visit);
	putchar('\n');

	if(!biTreeEmpty(T))
		printf("the binary tree is not empty\n");

	deep=depth(T);
	printf("the deep of the binary tree is :%d\n",deep);

	r=root(T);
	printf("the root is :%d\n",r);

	p=T->lChild->rChild;//左孩子的右孩子
	printf("the value of the current pointer is :%d\n",value(p));

	assign(p,10);
	printf("after assign 10 to the current pointer the value is :%d\n",value(p));

	e1=parent(T,4);
	printf("element 4's parent is :%d\n",e1);//应该是7

	ptr=pointer(T,6);
	printf("point to 6,and the data is :%d\n",ptr->data);

	e1=leftChild(T,8);
	e2=rightChild(T,8);
	printf("the 8's left child is :%d,and the right child is :%d\n",e1,e2);

	e1=rightSibling(T,8);
	printf("the 8's right sibling is :%d\n",e1);

	e2=leftSibling(T,7);
	printf("the 7's left sibling is :%d\n",e2);

	printf("create a subtree and insert\n");
	createBiTree(&T1);//使用：12,11作为创建的子树
	printf("visit the new subtree\n");
	levelOrderTraverse(T1,visit);
	putchar('\n');

	p=T->lChild;
	insertChild(p,1,T1);
	printf("after insert a subtree into the tree \n");
	preOrderTraverse(T,visit);
	putchar('\n');

	p=T->rChild;
	deleteChild(p,0);
	printf("after delete a subtree using level order traverse\n");
	levelOrderTraverse(T,visit);
	putchar('\n');

	printf("after delete a subtree using in order traverse 1\n");
	inOrderTraverse1(T,visit);
	putchar('\n');

	printf("after delete a subtree using in order traverse 2\n");
	inOrderTraverse2(T,visit);
	putchar('\n');

	destroyBiTree(&T);
	printf("after destroy the tree the adress is :%d\n",T);

	return 0;
}






                

        

    

    
  



    

      

        

            

              
                
                  alex_chao2012
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
二叉树、链表算法

				
			

			

				

					肖的博客
				

				

					01-09
					
					364
					
				

			

		

		

			
				
// 创建节点
function Node(data, left, right) {
    this.data = data
    this.left = left
    this.right = right
    this.show = () => this.data
}

// 二叉查找树
function BST() {
    this.root = null

    th...

			
		

	



                

            
              



	

		

			

				
					
二叉树（二叉链表实现）

				
			

			

				

					lovecontry
				

				

					07-24
					
					404
					
				

			

		

		

			
				
二叉链表结构的二叉树模型，栈用自己写的模版，队列就不了 ，直接用STL的，不然代码太长了
文件"tree.h"
#include&lt;iostream&gt;
#include&lt;queue&gt;
#include&lt;stack&gt;
using namespace std;

template&lt;class T&gt;
class My_stack;

template&l...

			
		

	



              


  
              

                


	

		

			

				
					
二叉树的二叉链表的简单实现及操作

				
			

			

				

					TECH_PRO的博客
				

				

					06-05
					
					5776
					
				

			

		

		

			
				
本文主要简单的说一说二叉树的二叉链表的简单实现及操作。简单的说一说二叉链表的结点定义，树的创建，结点的插入，子树的销毁、树的拷贝等常用操作。


一、创建二叉树、拷贝二叉树
本文创建的二叉树采用二叉链表的形式来创建，二叉链表定义的树的结点通常包含一个数据域，两个地址域（分别用来指向左右子树），所以在创建树之前需要定义一个表示结点的结构体，具体实现如下：
/* 定义一个结构体用于表示二叉树

			
		

	





	

		

			

				
					
二叉链表实现二叉树

				
			

			

				

					u012426042的专栏
				

				

					11-27
					
					1188
					
				

			

		

		

			
				
/*
  Name: 二叉链表实现二叉树 
  Copyright: 
  Author: 
  Date:
  Description: 
*/
#ifndef BINTREE_H_INCLUDED
#define BINTREE_H_INCLUDED
#include 
#include "ds.h"
//数据元素的缺省类型用char 
#ifndef ElemType

			
		

	



		

			
		



	

		

			

				
					
二叉树的二叉链表表示与实现

				
			

			

				

					11-16
				

			

		

		

			
				
二叉树的二叉链表表示与实现，包括二叉树的建立、遍历、深度、叶子节点数等

			
		

	





	

		

			

				
					
头歌数据结构二叉树的二叉链表存储及基本操作

				
			

			

				

					05-18
				

			

		

		

			
				
首先，二叉链表存储的二叉树是一种通过链表结构来表示二叉树的方式。每个结点包含一个数据元素、一个指向左子结点的指针和一个指向右子结点的指针。在C语言中，可以定义一个结构体类型`BiTNode`来表示这样的结点：  ...

			
		

	





	

		

			

				
					
erchashu.rar_二叉树 二叉链表

				
			

			

				

					09-19
				

			

		

		

			
				
在这个“erchashu.rar”压缩包中，我们主要探讨如何将一个给定的二叉树转化为二叉链表存储结构，并使用栈来实现二叉树的先序、中序和后序遍历。  首先，二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，...

			
		

	





	

		

			

				
					
根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。

				
			

			

				

					12-07
				

			

		

		

			
				
二叉树的基本功能： 1、二叉树的建立 2、前序遍历二叉树 3、中序遍历二叉树 4、后序遍历二叉树 5、按层序遍历二叉树 6、求二叉树的深度 7、求指定结点到根的路径 8、二叉树的销毁 9、其他：自定义操作

			
		

	





	

		

			

				
					
二叉树二叉链表存储结构的C语言代码，包括先序、中序、后序层序遍历，判断完全二叉树，计算二叉树宽度

					
最新发布

				
			

			

				

					04-07
				

			

		

		

			
				
二叉链表存储结构是二叉树实现的一种形式，它通过使用链表来存储二叉树的节点信息以及节点之间的关系，每个节点通常包含三个部分：数据域以及两个指针域，分别指向该节点的左孩子和右孩子。这种结构便于对二叉树进行...

			
		

	





	

		

			

				
					
二叉树的二叉链表源码

				
			

			

				

					11-17
				

			

		

		

			
				
二叉树的二叉链表源码

			
		

	





	

		

			

				
					
二叉树的链式存储结构-二叉链表

				
			

			

				

					11-09
				

			

		

		

			
				
数据结构-二叉树的基本操作。
二叉树的链式存储结构-二叉链表 各种操作都有。
二叉树使用链表能避免顺序储存浪费空间的问题，算法和结构相对简单。

			
		

	





	

		

			

				
					
二叉树的画法

				
			

			

				

					06-22
				

			

		

		

			
				
二叉树的概念 什么是二叉树 怎么来画二叉树怎么它的怎它的步骤是什么 通过这个例题可明白

			
		

	





	

		

			

				
					
二叉树二叉链表实现基本操作

				
			

			

				

					Aprilcxn的专栏
				

				

					12-05
					
					3709
					
				

			

		

		

			
				
<br />花了一天时间写了个二叉树用二叉链表实现基本操作，主要是对链表不熟悉，所以花了很多时间。<br />其次是对之前的线性表不熟，所以想了一些更麻烦的方法来实现。慢慢来吧。<br />今天至少还是想明白了二叉链表的大概结构和基本操作方法的。<br />附上代码，以后如果强化了再来贴。<br /> <br /> <br />/**************************用二叉链表法实现二叉树*********************************************/<br />/

			
		

	





	

		

			

				
					
二叉树(二叉链表）

				
			

			

				

					流痕的博客
				

				

					10-03
					
					1118
					
				

			

		

		

			
				
定义
n个结点的有限集合 由一个根节点以及两棵互不相交的 分别称为左子树 和 右子树的二叉树组成
逻辑结构
一对二
基本特征
每个结点最多只有两棵子树（不存在大于2的结点）
左子树和右子树次序不能颠倒
基本形态

性质
1） 二叉树的第i层上 至多有2的i-1次方个结点
2）深度为K的二叉树至多有2的K次方-1个结点
3）对于二叉树 2度的结点数有n个 则叶子有n+1个
4）具有n个结点的完全二叉树 其深度必为以二为底n的对数+1
5） 对完全二叉树 从上到下 从左到右 编号 则编号为i的结点 其左孩子编号

			
		

	





	

		

			

				
					
二叉树遍历方式

				
			

			

				

					litao55555的博客
				

				

					06-13
					
					298
					
				

			

		

		

			
				
遍历方式：前序遍历、中序遍历和后序遍历。这三种方式是以访问父节点的顺序来进行命名的 
父节点是N，左节点是L，右节点是R 
前序遍历    N－&gt;L－&gt;R 
中序遍历    L－&gt;N－&gt;R 
后序遍历    L－&gt;R－&gt;N

二叉树特点 
特性A，对于前序遍历，第一个肯定是根节点； 
特性B，对于后序遍历，最后一个肯定是根节点； 
特性C，利用前序或后序遍历，确...

			
		

	





	

		

			

				
					
18.建立二叉树的二叉链表

				
			

			

				

					杳杳_柒的博客
				

				

					06-23
					
					565
					
				

			

		

		

			
				
#include<stdio.h>
#include<stdlib.h>

typedef struct BTNode
{
	char data;
	struct BTNode *lchild;
	struct BTNode *rchild;
}BTNode;

char pre[100],mid[100];
int num;

void init()
{
...

			
		

	





	

		

			

				
					
数据结构--二叉树的二叉链表实现

				
			

			

				

					qq_35297945的博客
				

				

					02-19
					
					6563
					
				

			

		

		

			
				
1 二叉树的二叉链表示意图
  二叉链表的每个结点由三个域组成:数据域，左指针域和右指针域。左右指针分别用来保存左右孩子结点的存储地址。

2 二叉链表实现二叉树
2.1 头文件及其定义



			
		

	





	

		

			

				
					
数据结构（18）：二叉树的二叉链表表示

				
			

			

				

					欢迎来到关关雎鸠儿的博客
				

				

					08-31
					
					547
					
				

			

		

		

			
				
程序代码：
#include<iostream>
using namespace std;
#define TElemType char
//二叉链表
typedef struct BiNode{
	TElemType data;
	struct BiNode *lchild, *rchild;
}BiTNode, *BiTree;

//建立二叉链表
void CreateBiTre...

			
		

	





	

		

			

				
					
深入理解二叉树的二叉链表实现及操作

				
			

			

				

					
				

			

		

		

			
				
接下来，我们将详细介绍二叉树的二叉链表表示与实现中的关键知识点。  **1. 二叉树的定义**  在计算机科学中，二叉树是一种每个节点最多有两个子节点的树形数据结构。每个节点由三部分组成：节点值、指向左子节点的...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值