Some_DataStructure__in__C/a6f5.c at main · Small-hawk/Some_DataStructure__in__C · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/*             ASKISI 6
*             FYLLADIO 5
*    STYLIANOS KARAKOSTAS it12146
*/


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

typedef int BinTreeElementType;

typedef struct BinTreeNode *BinTreePointer;

struct BinTreeNode {
    BinTreeElementType Data;
    BinTreePointer LChild, RChild;
};

typedef enum {
    FALSE, TRUE
} boolean;

void CreateBST(BinTreePointer *Root);
boolean EmptyBST(BinTreePointer Root);
void BSTInsert(BinTreePointer *Root, BinTreeElementType Item);
int BSTDepth(BinTreePointer *root);

int main()
{
    BinTreePointer root;
    BinTreeElementType depth;


    CreateBST(&root);
    BSTInsert(&root,'P');
    BSTInsert(&root,'R');
    BSTInsert(&root,'O');
    BSTInsert(&root,'C');
    BSTInsert(&root,'E');
    BSTInsert(&root,'D');
    BSTInsert(&root,'U');
    BSTInsert(&root,'R');
    BSTInsert(&root,'E');

    depth = BSTDepth(&root);
    printf("Depth:%d \n", depth);


system("Pause");
return 0;

}

void CreateBST(BinTreePointer *Root)
{
    *Root = NULL;
}

boolean EmptyBST(BinTreePointer Root)
{
    return (Root==NULL);
}

void BSTInsert(BinTreePointer *Root, BinTreeElementType Item)
{
    BinTreePointer LocPtr, Parent;
    boolean Found;

    LocPtr = *Root;
    Parent = NULL;
    Found = FALSE;
    while (!Found && LocPtr != NULL) {
        Parent = LocPtr;
        if (Item < LocPtr->Data)
            LocPtr = LocPtr ->LChild;
        else if (Item > LocPtr ->Data)
            LocPtr = LocPtr ->RChild;
        else
            Found = TRUE;
    }
    if (Found)
        printf("The %c exists in DDA\n", Item);
    else {
        LocPtr = (BinTreePointer)malloc(sizeof (struct BinTreeNode));
        LocPtr ->Data = Item;
        LocPtr ->LChild = NULL;
        LocPtr ->RChild = NULL;
        if (Parent == NULL)
            *Root = LocPtr;
        else if (Item < Parent ->Data)
            Parent ->LChild = LocPtr;
        else
            Parent ->RChild = LocPtr;
    }
}

 int BSTDepth(BinTreePointer *Root)
 {
     int LDepth, RDepth;


     if(*Root==NULL)
     {
         return 0;
     }
     else
     {
         LDepth = BSTDepth(&(*Root)->LChild);
         RDepth = BSTDepth(&((*Root)->RChild));

         if(LDepth > RDepth)
          return LDepth + 1;
         else
          return RDepth + 1;
     }


 }