apaki/unicstl
1
0
Fork 0
mirror of https://gitee.com/apaki/unicstl.git synced 2025-05-18 03:51:35 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

删除旧版rbtree代码，已经现有代码中不必要的代码。

Browse Source
This commit is contained in:
建峰 2024-07-02 15:52:20 +08:00
parent 73fd6176ae
commit 91d6976009
8 changed files with 8 additions and 1531 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@ -16,6 +16,7 @@
"config.h": "c",
"limits": "c",
"*.tcc": "c",
"cstdlib": "c"
"cstdlib": "c",
"string.h": "c"
}
}

19
include/common.h
View File

@ -9,21 +9,4 @@
#include <string.h>
#include <assert.h>
#if RBTREE == 1
#include "rbtree.h"
typedef prbtree_node_t stack_data_t;
typedef prbtree_node_t queue_data_t;
typedef int list_data_t;
#elif AVLTREE == 1
#include "tree.h"
typedef ptree_node_t stack_data_t;
typedef ptree_node_t queue_data_t;
#else
typedef int stack_data_t;
typedef int queue_data_t;
typedef int list_data_t;
#endif
#endif // _DEMO_H_
#endif // _COMMON_H_

49
include/rbtree.h
View File

@ -1,49 +0,0 @@
#ifndef _RBTREE_H_
#define _RBTREE_H_
#include "common.h"
#if RBTREE == 1
typedef int rbtree_data_t;
typedef struct _rbtree_node_t
{
rbtree_data_t data;
struct _rbtree_node_t * left;
struct _rbtree_node_t * right;
struct _rbtree_node_t * parent;
uint32_t color;
}rbtree_node_t, *prbtree_node_t;
typedef struct _rbtree_t
{
struct _rbtree_node_t * tree;
uint32_t size;
}rbtree_t, *prbtree_t;
typedef void (*tree_data_disp_t)(rbtree_data_t data);
bool rbtree_init(prbtree_t *head);
void rbtree_destroy(prbtree_t * head);
bool rbtree_empty(prbtree_t head);
void rbtree_clear(prbtree_t head);
uint32_t rbtree_get_size(prbtree_t head);
bool rbtree_insert(prbtree_t head, rbtree_data_t data);
bool rbtree_delete(prbtree_t head, rbtree_data_t data);
bool rbtree_get_min(prbtree_t head, rbtree_data_t *data);
bool rbtree_get_max(prbtree_t head, rbtree_data_t *data);
void rbtree_traversal_depth_preorder(prbtree_t head, tree_data_disp_t tree_data_disp);
void rbtree_traversal_depth_inorder(prbtree_t head, tree_data_disp_t tree_data_disp);
void rbtree_traversal_depth_postorder(prbtree_t head, tree_data_disp_t tree_data_disp);
void rbtree_traversal_breadth(prbtree_t head, tree_data_disp_t tree_data_disp);
// check
bool rbtree_check(prbtree_t head);
#endif
#endif // _RBTREE_H_

23
include/unicstl.h
View File

@ -8,8 +8,8 @@
* @copyright Copyright (c) 2024
*
*/
#ifndef _DEMO_H_
#define _DEMO_H_
#ifndef _UNICSTL_H_
#define _UNICSTL_H_
#include "list.h"
#include "stack.h"
@ -17,21 +17,4 @@
#include "deque.h"
#include "tree.h"
#if RBTREE == 1
#include "rbtree.h"
typedef prbtree_node_t stack_data_t;
typedef prbtree_node_t queue_data_t;
typedef int list_data_t;
#elif AVLTREE == 1
#include "tree.h"
typedef ptree_node_t stack_data_t;
typedef ptree_node_t queue_data_t;
#else
typedef int stack_data_t;
typedef int queue_data_t;
typedef int list_data_t;
#endif
#endif // _DEMO_H_
#endif // _UNICSTL_H_

4
src/list.c
View File

@ -19,7 +19,7 @@ bool list_append(struct _list* self, void* obj)
if (self->size(self) == self->_capacity)
{
int capacity = self->_capacity * self->_ratio;
void * obj_new = (list_data_t*)realloc(self->obj, capacity * self->_obj_size);
void * obj_new = (void *)realloc(self->obj, capacity * self->_obj_size);
if (obj_new == NULL)
{
return false;
@ -42,7 +42,7 @@ bool list_insert(struct _list* self, int index, void* obj)
if (self->size(self) == self->_capacity)
{
int capacity = self->_capacity * self->_ratio;
void* obj_new = (list_data_t*)realloc(self->obj, capacity * self->_obj_size);
void* obj_new = (void *)realloc(self->obj, capacity * self->_obj_size);
if (obj_new == NULL)
{
return false;

1186
src/rbtree.c
View File

File diff suppressed because it is too large Load Diff

1
test/test.c
View File

@ -55,7 +55,6 @@ int main()
// test_queue();
test_tree();
// rbtree_test();
}
return 0;
}

254
test/test_rbtree.c
View File

@ -1,254 +0,0 @@
#include "test.h"
#if RBTREE_TEST == 1
#define TREE_DISP_DEPTH_PRE(tree) {rbtree_traversal_depth_preorder(tree,tree_data_display);printf("\n");}
#define TREE_DISP_DEPTH_IN(tree) {rbtree_traversal_depth_inorder(tree,tree_data_display);printf("\n");}
#define TREE_DISP_DEPTH_POST(tree) {rbtree_traversal_depth_postorder(tree,tree_data_display);printf("\n");}
#define TREE_DISP_BREADTH(tree) {rbtree_traversal_breadth(tree,tree_data_display);printf("\n");}
// tree display
#define TREE_DISP(tree) TREE_DISP_DEPTH_IN(tree)
static void tree_data_display(rbtree_data_t data)
{
printf("%4d ", data);
}
void rbtree_base(void)
{
int32_t i = 0;
rbtree_data_t dat[10] = { 5,0,2,4,3,1,8,7,9,6 }; // debug data
rbtree_data_t tmp;
prbtree_t tree = NULL;
rbtree_init(&tree);
for (i = 0; i < 10; i++)
{
rbtree_insert(tree, dat[i]);
}
printf("tree : ");
TREE_DISP(tree);
rbtree_get_min(tree, &tmp);
if (tmp == 0)
{
printf("success -> tree_get_min is %d\n", tmp);
}
else
{
printf("failure -> tree_get_min is %d ?\n", tmp);
}
rbtree_get_max(tree, &tmp);
if (tmp == 9)
{
printf("success -> tree_get_max is %d\n", tmp);
}
else
{
printf("failure -> tree_get_max is %d ?\n", tmp);
}
// delete the leaf
rbtree_delete(tree, 6);
printf("del %d: ", 6);
TREE_DISP(tree);
// delete the node which one child
rbtree_delete(tree, 0);
printf("del %d: ", 0);
TREE_DISP(tree);
// delete the node which has two nodes
rbtree_delete(tree, 2);
printf("del %d: ", 2);
TREE_DISP(tree);
// delete the root
rbtree_delete(tree, 4);
printf("del %d: ", 4);
TREE_DISP(tree);
rbtree_clear(tree);
printf("success -> tree_clear success!\n");
if (rbtree_empty(tree))
{
printf("success -> the tree is empty\n");
}
else
{
printf("failure -> the tree is not empty\n");
}
if (!rbtree_delete(tree, 8))
{
printf("success -> tree is empty, so delete failureed!\n");
}
else
{
printf("failure -> tree is empty, but delete succeed!\n");
}
// ------------------------------------
// insert again
for (i = 0; i < 10; i++)
{
rbtree_insert(tree, dat[i]);
}
printf("tree : ");
TREE_DISP(tree);
for (i = 0; i < 10; i++)
{
if (rbtree_delete(tree, i))
{
printf("del %d: ", i);
TREE_DISP(tree);
}
}
if (rbtree_empty(tree))
{
printf("success -> the tree is empty\n");
}
else
{
printf("failure -> the tree is not empty\n");
}
rbtree_destroy(&tree);
if (!rbtree_insert(tree, dat[0]))
{
printf("success -> after tree destroyed, tree_insert failureed!\n");
}
if (!rbtree_get_min(tree, &tmp))
{
printf("success -> after tree destroyed, tree_get_min failured!\n");
}
if (!rbtree_get_max(tree, &tmp))
{
printf("success -> after tree destroyed, tree_get_max failured!\n");
}
printf("----------------------------------------\n");
}
void rbtree_random_insert_test(void)
{
#define INSERT_NUM_MAX 128
uint32_t i = 0;
const uint32_t len = INSERT_NUM_MAX;
rbtree_data_t dat[INSERT_NUM_MAX];
rbtree_data_t dd[] = { 5,0,2,4,3,1,8,7,9,6 };
prbtree_t tree = NULL;
rbtree_init(&tree);
printf("orig_data:\n");
srand((uint32_t)time(0));
for (i = 0; i < len; i++)
{
dat[i] = rand() % len;
// dat[i] = dd[i];
printf("%d,", dat[i]);
}
printf("\n----------------------------------------\n");
for (i = 0; i < len; i++)
{
// printf("insert %-04d\n", dat[i]);
rbtree_insert(tree, dat[i]);
// TREE_DISP(tree);
if (true != rbtree_check(tree))
{
printf("failure -> insert\n");
SYSTEM_PAUSE();
}
}
TREE_DISP_DEPTH_PRE(tree);
TREE_DISP_DEPTH_IN(tree);
TREE_DISP_DEPTH_POST(tree);
TREE_DISP_BREADTH(tree);
rbtree_destroy(&tree);
}
void rbtree_random_delete_test(void)
{
#define MAX_NUMBER 128
uint32_t i = 0;
const uint32_t len = MAX_NUMBER;
rbtree_data_t dat[MAX_NUMBER];
rbtree_data_t dd[] = { 22,12,5,2,0,21,5,22,30,11,6,18,22,5,7,17,13,13,24,13,14,1,20,12,22,24,19,14,17,13,24 };
prbtree_t tree = NULL;
rbtree_init(&tree);
static uint8_t srand_flag = 0;
if (srand_flag == 0)
{
srand((uint32_t)time(0));
srand_flag = 1;
}
printf("orig_data:\n");
for (i = 0; i < len; i++)
{
dat[i] = rand() % len;
// dat[i] = dd[i];
printf("%d,", dat[i]);
}
printf("\n----------------------------------------\n");
for (i = 0; i < len; i++)
{
rbtree_insert(tree, dat[i]);
if (true != rbtree_check(tree))
{
printf("failure -> insert\n");
SYSTEM_PAUSE();
}
}
// TREE_DISP(tree);
printf("----------------------------------------\n");
for (i = 0; i < len; i++)
{
// printf("delete %-04d\n", dat[i]);
rbtree_delete(tree, dat[i]);
// TREE_DISP(tree);
if (true != rbtree_check(tree))
{
printf("failure -> delete\n");
SYSTEM_PAUSE();
}
}
printf("----------------------------------------\n");
if (rbtree_empty(tree))
{
printf("success -> the tree is empty\n");
}
rbtree_destroy(&tree);
}
void rbtree_test(void)
{
// rbtree_base();
// rbtree_random_insert_test();
rbtree_random_delete_test();
}
#endif