C Language

Step by step

My diary

...

Search
breakinformation. Powered by Blogger.

2019년 1월 17일 목요일

array heap

  1월 17, 2019    

"arrayheap.h"
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
#ifndef _ARRAY_HEAP_
#define _ARRAY_HEAP_
 
struct Heap_Element_Type {
 
    int key;
    //char data;
};
 
struct Array_Heap_Type {
 
    int Maximum_Element_Count;
    int Current_Element_Count;
    struct Heap_Element_Type* Pointer_Element;
};
 
typedef struct Heap_Element_Type    Heap_Node;
typedef struct Array_Heap_Type        Array_Maximum_Heap, Array_Minimum_Heap;
 
Array_Maximum_Heap* Create_Array_Maximum_Heap(int Maximum_Element_Count);
void Delete_Array_Maximum_Heap(Array_Maximum_Heap* Pointer_Array_Heap);
void Insert_Maximum_Heap_Array_Heap(Array_Maximum_Heap* Pointer_Array_Heap, Heap_Node element);
Heap_Node* Delete_Maximum_Heap_Array_Heap(Array_Maximum_Heap* Pointer_Array_Heap);
 
#endif // !_ARRAY_HEAP_
 
#ifndef _COMMON_TREE_DEFAULT_
#define _COMMON_TREE_DEFAULT_
 
#define TRUE    1
#define FALSE    0
 
#endif // !_COMMON_TREE_DEFAULT_
 
cs
"arrayheap.c"
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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "arrayheap.h"
 
Array_Maximum_Heap* Create_Array_Maximum_Heap(int Maximum_Element_Count) {
 
    if (Maximum_Element_Count <= 0) {
 
        printf("Error! The count must be greater then zero. Create_Array_Maximum_Heap()\n");
        return NULL;
    }
 
    Array_Maximum_Heap* Pointer_Return = (Array_Maximum_Heap*)malloc(1 * sizeof(Array_Maximum_Heap));
    if ((Array_Maximum_Heap*)Pointer_Return == NULL) {
 
        printf("Error! Dynamic memory allocation(1). Create_Array_Maximum_Heap()\n");
        return NULL;
    }
 
    Pointer_Return->Maximum_Element_Count = Maximum_Element_Count;
    Pointer_Return->Current_Element_Count = 0;
    (struct Heap_Element_Type*)Pointer_Return->Pointer_Element = (struct Heap_Element_Type*)malloc((Maximum_Element_Count + 1) * sizeof(struct Heap_Element_Type));
    if ((struct Heap_Element_Type*)Pointer_Return->Pointer_Element == NULL) {
 
        printf("Error! Dynamic memory allocation(2). Create_Array_Maximum_Heap()\n");
        free((Array_Maximum_Heap*)Pointer_Return);
        return NULL;
    }
    (void*)memset((struct Heap_Element_Type*)Pointer_Return->Pointer_Element, 0, (Maximum_Element_Count + 1) * sizeof(struct Heap_Element_Type));
 
    return (Array_Maximum_Heap*)Pointer_Return;
}
 
void Insert_Maximum_Heap_Array_Heap(Array_Maximum_Heap* Pointer_Heap, Heap_Node element) {
 
    if ((Array_Maximum_Heap*)Pointer_Heap == NULL) {
 
        printf("Error! The heap is null. Insert_Maximum_Heap_Array_Heap()\n");
        return;
    }
    else if (Pointer_Heap->Maximum_Element_Count == Pointer_Heap->Current_Element_Count) {
 
        printf("Error! The heap is full. [%d], Insert_Maximum_Heap_Array_Heap()\n", Pointer_Heap->Maximum_Element_Count);
        return;
    }
 
    Pointer_Heap->Current_Element_Count++;
    int index = 0;
    for (index = Pointer_Heap->Current_Element_Count; index != 1 && element.key > (*(Pointer_Heap->Pointer_Element + (index / 2))).key; index /= 2) {
 
        (*(Pointer_Heap->Pointer_Element + index)) = (*(Pointer_Heap->Pointer_Element + (index / 2)));
    }
    (*(Pointer_Heap->Pointer_Element + index)) = element;
 
    return;
}
 
Heap_Node* Delete_Maximum_Heap_Array_Heap(Array_Maximum_Heap* Pointer_Heap) {
 
    if ((Array_Maximum_Heap*)Pointer_Heap == NULL && Pointer_Heap->Current_Element_Count <= 0) return NULL;
 
    Heap_Node* Pointer_Return = (Heap_Node*)malloc(1 * sizeof(Heap_Node));
    if ((Heap_Node*)Pointer_Return == NULL) {
 
        printf("Error! Dynamic memory allocation. Delete_Maximum_Heap_Array_Heap()\n");
        return NULL;
    }
 
    *(Pointer_Return + 0) = *(Pointer_Heap->Pointer_Element + 1);
 
    int index = Pointer_Heap->Current_Element_Count;
    Heap_Node* Pointer_Temporary = Pointer_Heap->Pointer_Element + index;
    Pointer_Heap->Current_Element_Count--;
 
    int parent = 1, child = 2;
    for (index; child <= Pointer_Heap->Current_Element_Count; child *= 2) {
 
        if (child <= Pointer_Heap->Current_Element_Count && (*(Pointer_Heap->Pointer_Element + child)).key < (*(Pointer_Heap->Pointer_Element + child + 1)).key) {
 
            child++;
        }
        if (Pointer_Temporary->key >= (*(Pointer_Heap->Pointer_Element + child)).key) break;
 
        *(Pointer_Heap->Pointer_Element + parent) = *(Pointer_Heap->Pointer_Element + child);
        parent = child;
    } // end-of-for
 
    *(Pointer_Heap->Pointer_Element + parent) = *Pointer_Temporary;
    return (Heap_Node*)Pointer_Return;
}
 
void Delete_Array_Maximum_Heap(Array_Maximum_Heap* Pointer_Heap) {
 
    if ((struct Heap_Element_Type*)Pointer_Heap->Pointer_Element != NULL) {
 
        free((struct Heap_Element_Type*)Pointer_Heap->Pointer_Element);
    }
    if ((Array_Maximum_Heap*)Pointer_Heap != NULL) {
 
        free((Array_Maximum_Heap*)Pointer_Heap);
    }
    return;
}
cs
"main.c"
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
#include <stdio.h>
#include <stdlib.h>
#include "arrayheap.h"
 
void Display_Array_Heap(Array_Maximum_Heap* Pointer_Heap);
 
int main(int argc, char** argv) {
 
    int Maximum_Heap_Size = 20;
    Array_Maximum_Heap* Pointer_Heap = (Array_Maximum_Heap*)Create_Array_Maximum_Heap(Maximum_Heap_Size);
    if ((Array_Maximum_Heap*)Pointer_Heap == NULL) return -1;
 
    Heap_Node element[5] = { 0, };
    element[0].key = 10;
    element[1].key = 40;
    element[2].key = 30;
    element[3].key = 20;
    element[4].key = 50;
 
    Insert_Maximum_Heap_Array_Heap((Array_Maximum_Heap*)Pointer_Heap, element[0]);
    Insert_Maximum_Heap_Array_Heap((Array_Maximum_Heap*)Pointer_Heap, element[1]);
    Insert_Maximum_Heap_Array_Heap((Array_Maximum_Heap*)Pointer_Heap, element[2]);
    Insert_Maximum_Heap_Array_Heap((Array_Maximum_Heap*)Pointer_Heap, element[3]);
    Insert_Maximum_Heap_Array_Heap((Array_Maximum_Heap*)Pointer_Heap, element[4]);
 
    Display_Array_Heap((Array_Maximum_Heap*)Pointer_Heap);
 
    Heap_Node* Pointer_Node = Delete_Maximum_Heap_Array_Heap((Array_Maximum_Heap*)Pointer_Heap);
    if ((Heap_Node*)Pointer_Node != NULL) {
 
        printf("Delete_Maximum_Heap_Array_Heap()-[%d]\n", Pointer_Node->key);
        free((Heap_Node*)Pointer_Node);
    }
 
    Display_Array_Heap((Array_Maximum_Heap*)Pointer_Heap);
 
    Delete_Array_Maximum_Heap((Array_Maximum_Heap*)Pointer_Heap);
 
    return 0;
}
 
void Display_Array_Heap(Array_Maximum_Heap* Pointer_Heap) {
 
    if ((Array_Maximum_Heap*)Pointer_Heap == NULL) return;
    int index = 0;
    for (index = 1; index <= Pointer_Heap->Current_Element_Count; index++) {
 
        printf("[%d], %d\n", index, (*(Pointer_Heap->Pointer_Element + index)).key);
    }
    return;
}
cs

  No Comments

2019년 1월 11일 금요일

binary tree operation

  1월 11, 2019    

"binarytree.h"
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
#ifndef _BINARY_TREE_
#define _BINARY_TREE_
 
struct Binary_Tree_Node_Type {
 
    char data;
 
    struct Binary_Tree_Node_Type* Pointer_Left_Child;
    struct Binary_Tree_Node_Type* Pointer_Right_Child;
};
 
struct Binary_Tree_Type {
 
    struct Binary_Tree_Node_Type* Pointer_Root_Node;
};
 
typedef struct Binary_Tree_Node_Type    Binary_Tree_Node;
typedef struct Binary_Tree_Type            Binary_Tree;
 
Binary_Tree* Make_Binary_Tree(Binary_Tree_Node Root_Node);
Binary_Tree_Node* Get_Root_Node_Binary_Tree(Binary_Tree* Pointer_Binary_Tree);
Binary_Tree_Node* Insert_Left_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Parent_Node, Binary_Tree_Node element);
Binary_Tree_Node* Insert_Right_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Parent_Node, Binary_Tree_Node element);
Binary_Tree_Node* Get_Left_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Node);
Binary_Tree_Node* Get_Right_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Node);
void Delete_Binary_Tree(Binary_Tree* Pointer_Binary_Tree);
void Delete_Binary_Tree_Node(Binary_Tree_Node* Pointer_Node);
 
#endif // !_BINARY_TREE_
 
#ifndef _COMMON_TREE_DEFAULT_
#define _COMMON_TREE_DEFAULT_
 
#define TRUE    1
#define FALSE    0
 
#endif // !_COMMON_TREE_DEFAULT_
 
 
cs
"binarytreeoperation.h"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef _BINARY_TREE_OPERATION_
#define _BINARY_TREE_OPERATION_
 
#include "binarytree.h"
 
Binary_Tree* Copy_Binary_Tree(Binary_Tree* Pointer_Source);
Binary_Tree_Node* Copy_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source_Node);
int Equal_Binary_Tree(Binary_Tree* Pointer_First, Binary_Tree* Pointer_Second);
int Equal_Binary_Tree_Node(Binary_Tree_Node* Pointer_First, Binary_Tree_Node* Pointer_Second);
int Get_Node_Count_Binary_Tree(Binary_Tree* Pointer_Source);
int Get_Node_Count_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source);
int Get_Leaf_Node_Count_Binary_Tree(Binary_Tree* Pointer_Source);
int Get_Leaf_Node_Count_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source);
int Get_Height_Binary_Tree(Binary_Tree* Pointer_Source);
int Get_Height_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source);
void Display_Binary_Tree(Binary_Tree* Pointer_Tree);
void Display_Binary_Tree_Node(Binary_Tree_Node* Pointer_Node, int level, char type);
 
#endif // !_BINARY_TREE_OPERATION_
 
cs
"binarytree.c"
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
#include <stdio.h>
#include <stdlib.h>
#include "binarytree.h"
 
Binary_Tree* Make_Binary_Tree(Binary_Tree_Node Root_Node) {
 
    Binary_Tree* Pointer_Return = NULL;
    (Binary_Tree*)Pointer_Return = (Binary_Tree*)malloc(1 * sizeof(Binary_Tree));
    if ((Binary_Tree*)Pointer_Return == NULL) {
 
        printf("Error! Dynamic memory allocation(1). Make_Binary_Tree()\n");
        return NULL;
    }
 
    (struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Root_Node = (struct Binary_Tree_Node_Type*)malloc(1 * sizeof(struct Binary_Tree_Node_Type));
    if ((struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Root_Node == NULL) {
 
        printf("Error! Dynamic memory allocation(2). Make_Binary_Tree()\n");
        free((Binary_Tree*)Pointer_Return);
        return NULL;
    }
 
    *(struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Root_Node = *(struct Binary_Tree_Node_Type*)&Root_Node;
    (struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Root_Node->Pointer_Left_Child = NULL;
    (struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Root_Node->Pointer_Right_Child = NULL;
 
    return (Binary_Tree*)Pointer_Return;
}
 
Binary_Tree_Node* Insert_Left_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Parent_Node, Binary_Tree_Node element) {
 
    if ((Binary_Tree_Node*)Pointer_Parent_Node == NULL) {
 
        printf("Error! Binary tree node is null. Insert_Left_Child_Node_Binary_Tree()\n");
        return NULL;
    }
    else if ((struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Left_Child != NULL) {
 
        printf("Error! The node already exists. Insert_Left_Child_Node_Binary_Tree()\n");
        return NULL;
    }
 
    (struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Left_Child = (struct Binary_Tree_Node_Type*)malloc(1 * sizeof(struct Binary_Tree_Node_Type));
    if ((struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Left_Child == NULL) {
 
        printf("Error! Dynamic memory allocation. Insert_Left_Child_Node_Binary_Tree()\n");
        return NULL;
    }
 
    *(struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Left_Child = *(struct Binary_Tree_Node_Type*)&element;
    (struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Left_Child->Pointer_Left_Child = NULL;
    (struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Left_Child->Pointer_Right_Child = NULL;
    return (Binary_Tree_Node*)Pointer_Parent_Node->Pointer_Left_Child;
}
 
Binary_Tree_Node* Insert_Right_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Parent_Node, Binary_Tree_Node element) {
 
    if ((Binary_Tree_Node*)Pointer_Parent_Node == NULL) {
 
        printf("Error! Binary tree node is null. Insert_Right_Child_Node_Binary_Tree()\n");
        return NULL;
    }
    else if ((struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Right_Child != NULL) {
 
        printf("Error! The node already exists. Insert_Right_Child_Node_Binary_Tree()\n");
        return NULL;
    }
 
    (struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Right_Child = (struct Binary_Tree_Node_Type*)malloc(1 * sizeof(struct Binary_Tree_Node_Type));
    if ((struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Right_Child == NULL) {
 
        printf("Error! Dynamic memory allocation. Insert_Right_Child_Node_Binary_Tree()\n");
        return NULL;
    }
 
    *(struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Right_Child = *(struct Binary_Tree_Node_Type*)&element;
    (struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Right_Child->Pointer_Left_Child = NULL;
    (struct Binary_Tree_Node_Type*)Pointer_Parent_Node->Pointer_Right_Child->Pointer_Right_Child = NULL;
    return (Binary_Tree_Node*)Pointer_Parent_Node->Pointer_Right_Child;
}
 
Binary_Tree_Node* Get_Root_Node_Binary_Tree(Binary_Tree* Pointer_Binary_Tree) {
 
    if ((Binary_Tree*)Pointer_Binary_Tree == NULL) return NULL;
    return (Binary_Tree_Node*)Pointer_Binary_Tree->Pointer_Root_Node;
}
 
Binary_Tree_Node* Get_Left_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Node) {
 
    if ((Binary_Tree_Node*)Pointer_Node == NULL) return NULL;
    return (Binary_Tree_Node*)Pointer_Node->Pointer_Left_Child;
}
 
Binary_Tree_Node* Get_Right_Child_Node_Binary_Tree(Binary_Tree_Node* Pointer_Node) {
 
    if ((Binary_Tree_Node*)Pointer_Node == NULL) return NULL;
    return (Binary_Tree_Node*)Pointer_Node->Pointer_Right_Child;
}
 
void Delete_Binary_Tree(Binary_Tree* Pointer_Binary_Tree) {
 
    if ((Binary_Tree*)Pointer_Binary_Tree == NULL) return;
    Delete_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Binary_Tree->Pointer_Root_Node);
    free((Binary_Tree*)Pointer_Binary_Tree);
    return;
}
 
void Delete_Binary_Tree_Node(Binary_Tree_Node* Pointer_Node) {
 
    if ((Binary_Tree_Node*)Pointer_Node == NULL) return;
    Delete_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Node->Pointer_Left_Child);
    Delete_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Node->Pointer_Right_Child);
    free((Binary_Tree_Node*)Pointer_Node);
    return;
}
cs
"binarytreeoperation.c"
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
121
122
123
124
125
126
127
128
129
130
#include <stdio.h>
#include <stdlib.h>
#include "binarytree.h"
#include "binarytreeoperation.h"
 
Binary_Tree* Copy_Binary_Tree(Binary_Tree* Pointer_Source) {
 
    if ((Binary_Tree*)Pointer_Source == NULL) {
 
        printf("Error! The binary tree is null. Copy_Binary_Tree()\n");
        return NULL;
    }
    Binary_Tree* Pointer_Return = (Binary_Tree*)malloc(1 * sizeof(Binary_Tree));
    if ((Binary_Tree*)Pointer_Return == NULL) {
 
        printf("Error! Dynamic memory allocation. Copy_Binary_Tree()\n");
        return NULL;
    }
    (struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Root_Node = (struct Binary_Tree_Node_Type*)Copy_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Root_Node);
    return (Binary_Tree*)Pointer_Return;
}
 
Binary_Tree_Node* Copy_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source_Node) {
 
    if ((Binary_Tree_Node*)Pointer_Source_Node == NULL) return NULL;
 
    Binary_Tree_Node* Pointer_Return = (Binary_Tree_Node*)malloc(1 * sizeof(Binary_Tree_Node));
    if ((Binary_Tree_Node*)Pointer_Return == NULL) {
 
        printf("Error! Dynamic memory allocation. Copy_Binary_Tree_Node()\n");
        return NULL;
    }
 
    *(Binary_Tree_Node*)Pointer_Return = *(Binary_Tree_Node*)Pointer_Source_Node;
    (struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Left_Child = (struct Binary_Tree_Node_Type*)Copy_Binary_Tree_Node((Binary_Tree_Node*)Get_Left_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Source_Node));
    (struct Binary_Tree_Node_Type*)Pointer_Return->Pointer_Right_Child = (struct Binary_Tree_Node_Type*)Copy_Binary_Tree_Node((Binary_Tree_Node*)Get_Right_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Source_Node));
    return (Binary_Tree_Node*)Pointer_Return;
}
 
int Equal_Binary_Tree(Binary_Tree* Pointer_First, Binary_Tree* Pointer_Second) {
 
    int Root_Node_result = (int)Equal_Binary_Tree_Node((Binary_Tree_Node*)Pointer_First->Pointer_Root_Node, (Binary_Tree_Node*)Pointer_Second->Pointer_Root_Node);
    if ((Binary_Tree*)Pointer_First == NULL && (Binary_Tree*)Pointer_Second == NULL
     || (Binary_Tree*)Pointer_First != NULL && (Binary_Tree*)Pointer_Second != NULL && Root_Node_result == TRUE) return TRUE;
    return FALSE;
}
 
int Equal_Binary_Tree_Node(Binary_Tree_Node* Pointer_First, Binary_Tree_Node* Pointer_Second) {
 
    if ((Binary_Tree*)Pointer_First == NULL && (Binary_Tree*)Pointer_Second == NULL) return TRUE;
    int Left_Node_Result = (int)Equal_Binary_Tree_Node((Binary_Tree_Node*)Pointer_First->Pointer_Left_Child, (Binary_Tree_Node*)Pointer_Second->Pointer_Left_Child);
    int Right_Node_Result = (int)Equal_Binary_Tree_Node((Binary_Tree_Node*)Pointer_First->Pointer_Right_Child, (Binary_Tree_Node*)Pointer_Second->Pointer_Right_Child);
    if ((Binary_Tree*)Pointer_First != NULL && (Binary_Tree*)Pointer_Second != NULL && Pointer_First->data == Pointer_Second->data
        && Left_Node_Result == TRUE && Right_Node_Result == TRUE) return TRUE;
    return FALSE;
}
 
int Get_Node_Count_Binary_Tree(Binary_Tree* Pointer_Source) {
 
    if ((Binary_Tree*)Pointer_Source == NULL) return FALSE;
    return (int)Get_Node_Count_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Root_Node);
}
 
int Get_Node_Count_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source) {
 
    if ((Binary_Tree_Node*)Pointer_Source == NULL) return FALSE;
    return (int)Get_Node_Count_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Left_Child)
        + ((int)Get_Node_Count_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Right_Child) + 1);
}
 
int Get_Leaf_Node_Count_Binary_Tree(Binary_Tree* Pointer_Source) {
 
    if ((Binary_Tree*)Pointer_Source == NULL) return FALSE;
    return (int)Get_Leaf_Node_Count_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Root_Node);
}
 
int Get_Leaf_Node_Count_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source) {
 
    if ((Binary_Tree_Node*)Pointer_Source == NULL) return FALSE;
    else if ((struct Binary_Tree_Node_Type*)Pointer_Source->Pointer_Left_Child == NULL && (struct Binary_Tree_Node_Type*)Pointer_Source->Pointer_Right_Child == NULL) return 1;
    return (int)(Get_Leaf_Node_Count_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Left_Child) + Get_Leaf_Node_Count_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Right_Child));
}
 
int Get_Height_Binary_Tree(Binary_Tree* Pointer_Source) {
 
    if ((Binary_Tree*)Pointer_Source == NULL) return FALSE;
    return (int)Get_Height_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Root_Node);
}
 
int Get_Height_Binary_Tree_Node(Binary_Tree_Node* Pointer_Source) {
 
    if ((Binary_Tree_Node*)Pointer_Source == NULL) return FALSE;
    else if ((struct Binary_Tree_Node_Type*)Pointer_Source->Pointer_Left_Child == NULL && (struct Binary_Tree_Node_Type*)Pointer_Source->Pointer_Right_Child == NULL) return 1;
 
    int Left_Child_Height = (int)Get_Height_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Left_Child);
    int Right_Child_Height = (int)Get_Height_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Source->Pointer_Right_Child);
    if (Left_Child_Height >= Right_Child_Height) return ++Left_Child_Height;
    return ++Right_Child_Height;
}
 
void Display_Binary_Tree(Binary_Tree* Pointer_Tree) {
 
    if ((Binary_Tree*)Pointer_Tree == NULL) {
 
        printf("The Tree is null.\n");
        return;
    }
    Display_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Tree->Pointer_Root_Node, 0, 'O');
    return;
}
 
void Display_Binary_Tree_Node(Binary_Tree_Node* Pointer_Node, int level, char type) {
 
    int loop = 0;
    for (loop = 0; loop < level; loop++) {
 
        printf("    ");
    }
 
    if ((Binary_Tree_Node*)Pointer_Node == NULL) {
 
        printf("NULL\n");
        return;
    }
    printf("-[%i, %c]%c\n", level, type, Pointer_Node->data);
 
    Display_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Node->Pointer_Left_Child, level + 1, 'L');
    Display_Binary_Tree_Node((Binary_Tree_Node*)Pointer_Node->Pointer_Right_Child, level + 1, 'R');
    return;
}
cs
"main.c"
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
#include <stdio.h>
#include <stdlib.h>
#include "binarytree.h"
#include "binarytreeoperation.h"
 
Binary_Tree* Create_Example_Binary_Tree(void);
 
int main(int argc, char** argv) {
 
    Binary_Tree* Pointer_Binary_Tree = (Binary_Tree*)Create_Example_Binary_Tree();
    printf("Original binary tree:\n");
    Display_Binary_Tree((Binary_Tree*)Pointer_Binary_Tree);
    
    Binary_Tree* Pointer_Copy_Binary_Tree = (Binary_Tree*)Copy_Binary_Tree((Binary_Tree*)Pointer_Binary_Tree);
    printf("Copy binary tree:\n");
    Display_Binary_Tree((Binary_Tree*)Pointer_Copy_Binary_Tree);
 
    int Compare_Result = (int)Equal_Binary_Tree((Binary_Tree*)Pointer_Binary_Tree, (Binary_Tree*)Pointer_Copy_Binary_Tree);
    printf("\nCompare result : (%d)\n", Compare_Result);
 
    int count = (int)Get_Node_Count_Binary_Tree((Binary_Tree*)Pointer_Binary_Tree);
    printf("\nNumber of node : %d\n", count);
 
    count = (int)Get_Leaf_Node_Count_Binary_Tree((Binary_Tree*)Pointer_Binary_Tree);
    printf("\nNumber of leaf node : %d\n", count);
 
    count = (int)Get_Height_Binary_Tree((Binary_Tree*)Pointer_Binary_Tree);
    printf("\nNumber of height : %d\n", count);
 
    Delete_Binary_Tree((Binary_Tree*)Pointer_Binary_Tree);
    (Binary_Tree*)Pointer_Binary_Tree = NULL;
    Delete_Binary_Tree((Binary_Tree*)Pointer_Copy_Binary_Tree);
    (Binary_Tree*)Pointer_Copy_Binary_Tree = NULL;
 
    return 0;
}
 
Binary_Tree* Create_Example_Binary_Tree(void) {
 
    Binary_Tree_Node node = { 0, };
    node.data = 'A';
 
    Binary_Tree* Pointer_Return = (Binary_Tree*)Make_Binary_Tree(node);
    if ((Binary_Tree*)Pointer_Return == NULL) return NULL;
 
    Binary_Tree_Node* Pointer_Node_A = (Binary_Tree_Node*)Get_Root_Node_Binary_Tree((Binary_Tree*)Pointer_Return);
 
    node.data = 'B';
    Binary_Tree_Node* Pointer_Node_B = (Binary_Tree_Node*)Insert_Left_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_A, node);
    if ((Binary_Tree_Node*)Pointer_Node_B == NULL) return NULL;
    node.data = 'C';
    Binary_Tree_Node* Pointer_Node_C = (Binary_Tree_Node*)Insert_Right_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_A, node);
    if ((Binary_Tree_Node*)Pointer_Node_C == NULL) return NULL;
 
    node.data = 'D';
    Binary_Tree_Node* Pointer_Node_D = (Binary_Tree_Node*)Insert_Left_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_B, node);
    if ((Binary_Tree_Node*)Pointer_Node_D == NULL) return NULL;
    node.data = 'E';
    Binary_Tree_Node* Pointer_Node_E = (Binary_Tree_Node*)Insert_Right_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_B, node);
    if ((Binary_Tree_Node*)Pointer_Node_E == NULL) return NULL;
 
    node.data = 'F';
    Binary_Tree_Node* Pointer_Node_F = (Binary_Tree_Node*)Insert_Left_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_C, node);
    if ((Binary_Tree_Node*)Pointer_Node_F == NULL) return NULL;
    node.data = 'G';
    Binary_Tree_Node* Pointer_Node_G = (Binary_Tree_Node*)Insert_Right_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_C, node);
    if ((Binary_Tree_Node*)Pointer_Node_G == NULL) return NULL;
 
    node.data = 'H';
    Binary_Tree_Node* Pointer_Node_H = (Binary_Tree_Node*)Insert_Left_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_D, node);
    if ((Binary_Tree_Node*)Pointer_Node_H == NULL) return NULL;
    node.data = 'I';
    Binary_Tree_Node* Pointer_Node_I = (Binary_Tree_Node*)Insert_Right_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_D, node);
    if ((Binary_Tree_Node*)Pointer_Node_I == NULL) return NULL;
 
    node.data = 'J';
    Binary_Tree_Node* Pointer_Node_J = (Binary_Tree_Node*)Insert_Left_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_E, node);
    if ((Binary_Tree_Node*)Pointer_Node_J == NULL) return NULL;
 
    node.data = 'K';
    Binary_Tree_Node* Pointer_Node_K = (Binary_Tree_Node*)Insert_Right_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_F, node);
    if ((Binary_Tree_Node*)Pointer_Node_K == NULL) return NULL;
 
    node.data = 'L';
    Binary_Tree_Node* Pointer_Node_L = (Binary_Tree_Node*)Insert_Left_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_G, node);
    if ((Binary_Tree_Node*)Pointer_Node_L == NULL) return NULL;
    node.data = 'M';
    Binary_Tree_Node* Pointer_Node_M = (Binary_Tree_Node*)Insert_Right_Child_Node_Binary_Tree((Binary_Tree_Node*)Pointer_Node_G, node);
    if ((Binary_Tree_Node*)Pointer_Node_M == NULL) return NULL;
 
    return (Binary_Tree*)Pointer_Return;
}
cs

  No Comments

피드 구독하기: 글 (Atom)