查找二叉树的实现与演示

/*
* SearchTree.h
*
*  Created on: Jan 13, 2016
*      Author: youngwan
*/

#ifndef SEARCHTREE_H_
#define SEARCHTREE_H_

typedef int ElementType;

typedef struct _TreeNode_ {
ElementType Element;
struct _TreeNode_ *Left;
struct _TreeNode_ *Right;
}TreeNode, *Tree, *SearchTree, *Position;

SearchTree MakeEmpty(SearchTree T);
Position   Find(ElementType X, SearchTree T);
Position   FindMin(SearchTree T);
Position   FindMax(SearchTree T);
SearchTree Insert(ElementType X, SearchTree T);
SearchTree Delete(ElementType X, SearchTree T);
int        Height(SearchTree T);

#endif /* SEARCHTREE_H_ */

/*
* SearchTree.c
*
*  Created on: Jan 13, 2016
*      Author: youngwan
*/
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include "SearchTree.h"

using namespace std;
SearchTree MakeEmpty(SearchTree T)
{
if (NULL != T)
{
MakeEmpty(T->Left);
MakeEmpty(T->Right);
free(T);
}
return NULL;
}

Position Find(ElementType X, SearchTree T)
{
if (NULL == T)
return NULL;

if (X < T->Element)
return Find(X, T->Left);
else if (X > T->Element)
return Find(X, T->Right);
else
return T;
}

Position FindMin(SearchTree T)
{
if (NULL == T)
return NULL;
else if (NULL == T->Left)
return T;
else
return FindMin(T->Left);
}

Position FindMax(SearchTree T)
{
if (NULL == T)
return NULL;
else if (NULL == T->Right)
return T;
else
return FindMax(T->Right);
}

/*非递归实现 查找最小*/
Position FindMin2(SearchTree T)
{
if (NULL != T)
while(NULL != T->Left)
T = T->Left;

return T;
}
/*非递归实现 查找最大*/
Position FindMax2(SearchTree T)
{
if (NULL != T)
while(NULL == T->Right)
T = T->Right;

return T;
}

SearchTree Insert(ElementType X, SearchTree T)
{
if (NULL == T)
{
T = (SearchTree)malloc(sizeof(TreeNode));
if (NULL == T)
{
fprintf(stderr, "malloc Error");
return NULL;
}
else
{
T->Element = X;
T->Left = T->Right = NULL;
}
}
else if (X < T->Element)
{
T->Left = Insert(X, T->Left);
}
else if (X > T->Element)
{
T->Right = Insert(X, T->Right);
}

return T;
}

SearchTree Delete(ElementType X, SearchTree T)
{
Position TmpCell;

if (NULL == T)
{
fprintf(stderr, "Element not found");
return NULL;
}
else if (X < T->Element)
{
T->Left = Delete(X, T->Left);
}
else if (X > T->Element)
{
T->Right = Delete(X, T->Right);
}
else if (T->Left && T->Right)    /*have two child*/
{
TmpCell = FindMin(T->Right);    /*find the smallest in right sub tree, set it be root node*/
T->Element = TmpCell->Element;
T->Right = Delete(T->Element, T->Right); /*right sub tree become it delete T*/
}
else                            /*have one or zero child*/
{
TmpCell = T;
if (NULL == T->Left)
T = T->Right;
else if (NULL == T->Right)
T = T->Left;
free(TmpCell);
}

return T;
}

int Height(SearchTree T)
{
int lDeep, rDeep;

if (NULL == T)
return -1;

lDeep = Height(T->Left);
rDeep = Height(T->Right);
return 1 + (lDeep > rDeep ? lDeep : rDeep);
}

/*
* main.cpp
*
*  Created on: Jan 16, 2016
*      Author: youngwan
*/
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "SearchTree.h"

using namespace std;

static int power(int m, int n)
{
int result = 1;

while((n--) > 0)
{
result *= m;
}
return result;
}

void Print(Tree root)
{
vector<Tree> vecTree[2];
int current = 0;
int next    = 1;
int height, preSpace, mulSpace, i;

if (root == NULL)
{
fprintf(stderr, "root is null\n");
return ;
}

height = Height(root);
vecTree[current].push_back(root);
while (height >= 0)
{
preSpace = power(2, height) - 1;
mulSpace = power(2, height + 1) - 1;
for(i = 0; i < preSpace; i++)
printf("  ");
for(vector<Tree>::iterator iter = vecTree[current].begin(); iter < vecTree[current].end(); iter++)
{
if (NULL == (*iter))
{
printf("  ");
vecTree[next].push_back(NULL);
vecTree[next].push_back(NULL);
}
else
{
printf("%-2d", (*iter)->Element);
vecTree[next].push_back((*iter)->Left);
vecTree[next].push_back((*iter)->Right);
}

for(i = 0; i < mulSpace; i++)
printf("  ");
}
printf("\n");

vecTree[current].clear();
current = 1 - current;
next    = 1 - next;
height--;
}
}

void Show(Tree root)
{
if (NULL == root)
{
fprintf(stderr, "root is empty!\n");
}
else
{
Position pMax, pMin;
int height;
pMax = FindMax(root);
pMin = FindMin(root);
height = Height(root);
printf("Max  : %d\n", pMax->Element);
printf("Min  : %d\n", pMin->Element);
printf("High : %d\n", height + 1);
}
}

void FindElement(Tree root)
{
char buffer[1024] = {0};
int ret = 0;
char *p = NULL;

printf("Please input Digit you want find, split by ','!\n");
ret = scanf("%s", buffer);
if (ret <= 0)
{
printf("Error, ret:%d\n", ret);
return ;
}

p = strtok(buffer, ",");
while(p)
{
if((*p) > '0' && (*p) <= '9')
{
ret = atoi(p);
if (NULL == Find(ret, root))
printf("%d is not found\n", ret);
else
printf("%d is found\n", ret);
}
p = strtok(NULL, ",");
}
}

Tree OperatorInsert(Tree root)
{
char buffer[1024] = {0};
int ret = 0;
char *p = NULL;

printf("Please Input Digit you want insert, split by ','!\n");
ret = scanf("%s", buffer);

if (ret <= 0)
{
printf("Error, ret:%d\n", ret);
return root;
}

p = strtok(buffer, ",");
while(p)
{
if((*p) > '0' && (*p) <= '9')
{
ret = atoi(p);
root = Insert(ret, root);
}
p = strtok(NULL, ",");
}
return root;
}

Tree OperatorDelete(Tree root)
{
char buffer[1024] = {0};
int ret = 0;
char *p = NULL;

printf("Please Delete Digit you want insert, split by ','!\n");
ret = scanf("%s", buffer);
if (ret <= 0)
{
printf("Error, ret:%d\n", ret);
return root;
}

p = strtok(buffer, ",");
while(p)
{
if((*p) > '0' && (*p) <= '9')
{
ret = atoi(p);
root = Delete(ret, root);
}
p = strtok(NULL, ",");
}
return root;
}

int main(void)
{
Tree root = NULL;
char input[1024];

printf("Usage: insert only support digit(>0)\n");

while(1)
{
printf("(I:insert; D:delete; C:clear; P:print; S:Show; F:Find)\n");
printf("Please Input operator.\n");
scanf("%s", input);
switch(input[0])
{
case 'I':
case 'i':
root = OperatorInsert(root);
break;
case 'D':
case 'd':
root = OperatorDelete(root);
break;
case 'C':
case 'c':
root = MakeEmpty(root);
break;
case 'P':
case 'p':
Print(root);
break;
case 'S':
case 's':
Show(root);
break;
case 'F':
case 'f':
FindElement(root);
break;
default:break;
}
}

return 1;
}