2022.2.18
排序二叉树的建立,删除,以及前中后序遍历,层次遍历(链队实现)
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <stdlib.h>
//树结点
typedef struct Node
{
int data;
struct Node *lchild, *rchild;
} Node;
//树
typedef struct Tree
{
struct Node *root;
int size;
} Tree;
//链队结点
typedef struct Qnode
{
struct Node *p;
struct Qnode *next;
} Qnode;
//链队
typedef struct Queue
{
struct Qnode *head, *rear;
} Queue;
//创一个结点
Node *GetNode(int val)
{
Node *p = (Node *)malloc(sizeof(Node));
p->data = val;
p->lchild = p->rchild = NULL;
return p;
}
//创一个树
Tree *GetTree()
{
Tree *tree = (Tree *)malloc(sizeof(Tree));
tree->root = NULL;
tree->size = 0;
return tree;
}
//清除传入结点下的所有结点
bool ClearNode(Node *node)
{
if (node == NULL)
return true;
ClearNode(node->lchild);
ClearNode(node->rchild);
free(node);
return true;
}
//清除树
bool ClearTree(Tree *tree)
{
ClearNode(tree->root);
free(tree);
return true;
}
//排序插入结点
Node *InsertNode(Node *node, int val, int *flag)
{
if (node == NULL)
{ //树空第一次进来的时候 (即tree->root=NULL)直接返回结点地址 在外面用tree->root接(tree->root=),有了根结点后(tree->root!=NULL) 此步返回的结点地址被上一层的函数接收(node->r/lchild=),这样就完成了排序插入结点,而整个函数在递归调用结束后 返回的总是传进来的node即tree-root(栈);
*flag = 1;
return GetNode(val);
}
if (val == node->data)
{
return node;
}
if (val > node->data)
{
node->rchild = InsertNode(node->rchild, val, flag);
}
else
node->lchild = InsertNode(node->lchild, val, flag);
return node;
}
//给树插入结点
void Insert(Tree *tree, int val)
{
int flag = 0;
tree->root = InsertNode(tree->root, val, &flag);
if (flag == 1)
tree->size++;
return;
}
//中序遍历
void InOrder(Node *node)
{
if (node == NULL)
return;
InOrder(node->lchild);
printf(" %d", node->data);
InOrder(node->rchild);
return;
}
//前序遍历
bool PreOrder(Node *node)
{
if (node == NULL)
return true;
printf(" %d", node->data);
PreOrder(node->lchild);
PreOrder(node->rchild);
return true;
}
//后序遍历
bool PostOrder(Node *node)
{
if (node == NULL)
return true;
PostOrder(node->lchild);
PostOrder(node->rchild);
printf(" %d", node->data);
return true;
}
//初始化链队
Queue *InitQueue()
{
Queue *s = (Queue *)malloc(sizeof(Queue));
Qnode *p = (Qnode *)malloc(sizeof(Qnode));
p->p = NULL;
s->head = s->rear = p;
return s;
}
//入队
bool EnQueue(Queue *p, Node *node)
{
Qnode *s = (Qnode *)malloc(sizeof(Qnode));
s->p = node;
s->next = NULL;
p->rear->next = s;
p->rear = s;
return true;
}
//出队
Node *OutQueue(Queue *p)
{
if (p->head->next == NULL)
return false;
Qnode *s = p->head->next;
p->head->next = s->next;
if (p->head->next == NULL) //如果队空 首尾结点指向头节点
p->rear = p->head;
return s->p;
}
//层序遍历
bool LeveOrderNode(Node *root)
{
Queue *p = InitQueue();
EnQueue(p, root);
while (p->head->next != NULL)
{
Node *s = OutQueue(p);
printf(" %d", s->data);
if (s->lchild != NULL)
{
EnQueue(p, s->lchild);
}
if (s->rchild != NULL)
{
EnQueue(p, s->rchild);
}
}
}
int main()
{
srand(time(0));
Tree *p = GetTree();
for (int i = 0; i < 50; i++)
{
int val = rand() % 100;
Insert(p, val);
}
InOrder(p->root), putchar('\n');
PreOrder(p->root), putchar('\n');
PostOrder(p->root), putchar('\n');
LeveOrderNode(p->root), putchar('\n');
}