数据结构二叉排序树（带有链队列的层次遍历）的软件实现

/*
二叉排序树(带有链队列的层次遍历)
@hey超级巨星
*/
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;
#define ERROR 0
#define OK 1
typedef int Elemtype;
typedef int Status;
typedef struct BiNode
{
 Elemtype data;
 struct BiNode* lchild;
 struct BiNode* rchild;
}BiNode, * BSTree;
bool insert(BSTree& pTree, int key);
bool search_BSTree(BSTree pTree, int  key, BSTree parent, BSTree& p);
bool delete_Node(BSTree& pTree);

//创建二叉排序树
BSTree Creat_BSTree(int* arr, int len)
{
 BSTree pTree = NULL;
int i;
for (i = 0; i < len; i++)
{
insert(pTree, arr[i]);
}
return pTree;
}
//子函数 插入到合适位置
bool insert(BSTree& pTree, int key)
{
 BSTree p = NULL;
if (!search_BSTree(pTree, key, NULL, p))
{
  BSTree pNew = (BSTree)malloc(sizeof(BiNode));
  pNew->data = key;
  pNew->lchild = NULL;
  pNew->rchild = NULL;
if (!p)
{
   pTree = pNew;
}
else if (key < p->data)
{
   p->lchild = pNew;
}
else
{
   p->rchild = pNew;
}
return true;
}
else
return false;
}

//查找值 返回地址指针p
bool search_BSTree(BSTree pTree, int  key, BSTree parent, BSTree& p)
{
 if (!pTree)
 {
  p = parent;
  return false;
 }
 else
 {
  if (key == pTree->data)
  {
   p = pTree;
   return true;
  }
  else if (key < pTree->data)
  {
   return search_BSTree(pTree->lchild, key, pTree, p);
  }
  else
  {
   return search_BSTree(pTree->rchild, key, pTree, p);
  }
 }
}

//删除
bool delete_BSTree(BSTree& pTree, int key)
{
 if (!pTree)
 {
  return false;
 }
 else
 {
  if (key == pTree->data)
  {
   delete_Node(pTree);
   return true;
  }
  else if (key < pTree->data)
  {
   return delete_BSTree(pTree->lchild, key);
  }
  else
  {
   return delete_BSTree(pTree->rchild, key);
  }
 }
}
//具体删除的方法实现 把右子树插到左子树的右子树最末端
bool delete_Node(BSTree& pTree)
{
 if (!pTree)
 {
  return false;
 }
 else
 {
  BSTree p = pTree, s;
  if (pTree->lchild == NULL)
  {
   pTree = pTree->rchild;
   free(p);
  }
  else if (pTree->rchild == NULL)
  {
   pTree = pTree->lchild;
   free(p);
  }
  else
  {
   s = pTree->lchild;
   while (!s->rchild)
    s->rchild = pTree->rchild;
   s = pTree->rchild;
   pTree = pTree->lchild;
   free(p);
  }
 }
}

//为层次遍历 设置链队列
typedef struct QueueNode
{
 BSTree data;
 struct QueueNode* next;
}Node, QueueNode;
typedef struct Queue
{
 QueueNode* front;
 QueueNode* rear;
}Queue, * LinkQueue;
void InitQueue(LinkQueue& Q)
{
 Q->front = (QueueNode*)malloc(sizeof(Node));
 Q->rear = Q->front;
 if (!Q->front)
  exit(0);
 Q->rear->next = NULL;
}
void EnQueue(LinkQueue& Q, BSTree T)
{
 QueueNode* s = (QueueNode*)malloc(sizeof(Node));
 s->data = T;
 s->next = NULL;
 Q->rear->next = s;
 Q->rear = s;
 Q->rear->next = NULL;
}
void DeQueue(LinkQueue& Q)
{
 if (Q->front == Q->rear)
 {
  printf("空队列\n");
 }
 else if (Q->rear == Q->front->next)
 {
  Q->rear = Q->front;
 }
 else
 {
  Q->front = Q->front->next;
 }
}
bool EmptyQueue(LinkQueue Q)
{
 if (Q->front == Q->rear)
  return true;
 else
  return false;
}
BSTree getHead(LinkQueue Q)
{
 if (!EmptyQueue(Q))
 {
  BSTree p = Q->front->next->data;
  return p;
 }
 else return NULL;
}
//层次遍历函数
void travLevel(BSTree& T)
{
 LinkQueue Q = (LinkQueue)malloc(sizeof(Queue));
 InitQueue(Q);
 BSTree p = NULL;
 if (!T)
 {
  printf("空树\n");
 }
 else
 {
  EnQueue(Q, T);
  while (!EmptyQueue(Q))
  {
   p = getHead(Q);
   DeQueue(Q);
   printf("%d\t", p->data);
   if (p->lchild)
    EnQueue(Q, p->lchild);
   if (p->rchild)
    EnQueue(Q, p->rchild);
  }
 }
}

int main()
{
 BSTree bt = NULL;
 int arr[] = { 15,6,18,17,20,3,7 };
 bt = Creat_BSTree(arr, 7);
 printf("二叉排序树创建完毕 按层次遍历顺序为 :\n");
 travLevel(bt);
 int loc, val;
 char m;
 while (1)
 {
  printf("\n插入请按A，删除值请按B，查找请按C");
  //system("cls");
  cin >> m;
  switch (m)
  {
  case 'A':
   printf("开始插入，请输入插入值");
   scanf_s("%d", &val);
   insert(bt, val);
   break;
  case 'B':
   printf("开始删除，请输入删除位置");
   scanf_s("%d", &loc);
   delete_BSTree(bt, loc);
   break;
  case 'C':
   printf("当前层次遍历值如下");
   travLevel(bt);
   break;
  default:
   exit(0);
  }
 }
 return 0;
}