#include "dkc2Tree.h"#include "dkcStdio.h"#include "dkcStack.h"#include "dkcMemoryStream.h"dkc2Tree.cのインクルード依存関係図

マクロ定義 | |
| #define | DKUTIL_C_2TREE_C |
関数 | |
| DKC_INLINE void * | alloc_2tree_node (DKC_2TREE_ROOT *root, size_t data_size) |
| DKC_INLINE void | free_2tree_node (DKC_2TREE_ROOT *root, DKC_2TREE_NODE **node) |
| DKC_INLINE DKC_2TREE_NODE * | alloc_set (DKC_2TREE_ROOT *ptr, const void *Key, const void *data, size_t data_size) |
| DKC_INLINE void | erase_tree_with_node (DKC_2TREE_ROOT *ptr, DKC_2TREE_NODE **leaf_node) |
| DKC_2TREE_ROOT *WINAPI | dkcAlloc2TreeRoot (size_t key_size, size_t pool_max, DKC_COMPARE_TYPE compare, size_t max_num) |
| 2分木領域を得る。 | |
| DKC_INLINE void | free_2tree_root (DKC_2TREE_ROOT *root) |
| DKC_INLINE int | dkcFree2TreeWithVector (DKC_2TREE_ROOT *ptr) |
| void | dkcFree2TreeReflexive (DKC_2TREE_ROOT *ptr, DKC_2TREE_NODE **pp) |
| ppから左、右についた葉を削除 | |
| int | dkcFree2TreeReflexiveBegin (DKC_2TREE_ROOT *ptr) |
| int WINAPI | dkcFree2TreeRoot (DKC_2TREE_ROOT **ptr) |
| dkcAllocNew2Tree()で確保したリスト領域と内部バッファを削除。dkcAllocNew2Treeと対。 | |
| DKC_2TREE_NODE * | dkcAlloc2TreeInsertPoint (DKC_2TREE_NODE *ptr, int Key) |
| int WINAPI | dkc2TreeInsert (DKC_2TREE_ROOT *ptr, const void *Key, const void *data, size_t data_size) |
| 新しいデータを挿入する。 | |
| int WINAPI | dkc2TreeErase (DKC_2TREE_ROOT *ptr, DKC_2TREE_NODE *node) |
| int WINAPI | dkc2TreeEraseFromKey (DKC_2TREE_ROOT *ptr, const void *Key) |
| int WINAPI | tree_exist_reflexive (DKC_2TREE_ROOT *ptr, DKC_2TREE_NODE *node, DKC_2TREE_NODE **leaf_ptr, const DKC_2TREE_NODE *target, DKC_2TREE_NODE *parent, DKC_2TREE_EXIST *re) |
| 0見つからない 1見つかった | |
| DKC_2TREE_EXIST WINAPI | dkc2TreeExist (DKC_2TREE_ROOT *ptr, const DKC_2TREE_NODE *node) |
| nodeに入れたポインタがptr内に存在するかどうか調べる存在したら結果値を返す。 | |
| DKC_2TREE_NODE *WINAPI | dkc2TreeFindEqual (DKC_2TREE_ROOT *ptr, const void *Key) |
| DKC_2TREE_NODE * | find_lg_base (DKC_2TREE_ROOT *ptr, const void *Key, BOOL isGreater) |
| DKC_2TREE_NODE *WINAPI | dkc2TreeFindMaximumLess (DKC_2TREE_ROOT *ptr, const void *Key) |
| DKC_2TREE_NODE *WINAPI | dkc2TreeFindMinimalGreater (DKC_2TREE_ROOT *ptr, const void *Key) |
| int WINAPI | dkc2TreeGetBuffer (DKC_2TREE_NODE *ptr, void *data, size_t size) |
| 2分木構造体内に保存しているデータをもらう | |
| int WINAPI | dkc2TreeSetBuffer (DKC_2TREE_NODE *ptr, const void *data, size_t size) |
| 2分木構造体に保存しているデータ領域にデータを入れる。 2分木構造体内のバッファが足りない場合はこの関数の内部で拡張してくれる。 | |
dkc2Tree.c で定義されています。
|
|
dkc2Tree.c の 10 行で定義されています。 |
|
||||||||||||
|
dkc2Tree.c の 18 行で定義されています。 参照先 dkc_2TreeNode::data, dkc_2TreeNode::data_size, DKC_2TREE_NODE, DKC_2TREE_ROOT, dkcAllocateFast(), dkcSameObjectPoolAlloc(), dkcSameObjectPoolRecycle(), dkc_2TreeNode::key, dkc_2TreeRoot::key_ac, dkc_2TreeNode::left, NULL, dkc_2TreeRoot::obj_ac, dkc_2TreeNode::right, と dkc_2TreeRoot::sentinel. 参照元 alloc_set(), と dkcAlloc2TreeRoot().
00019 {
00020
00021 DKC_2TREE_NODE *np = NULL;
00022 void *data = NULL;
00023 void *key = NULL;
00024 np = (DKC_2TREE_NODE *)dkcSameObjectPoolAlloc(root->obj_ac);
00025 //np = (DKC_2TREE_NODE *)dkcAllocate(sizeof(DKC_2TREE_NODE));
00026
00027 if(NULL==np){
00028 return NULL;
00029 }
00030 key = dkcSameObjectPoolAlloc(root->key_ac);
00031 if(NULL==key){
00032 goto Error;
00033 }
00034 if(0 != data_size){
00035
00036 data = dkcAllocateFast(data_size);
00037 if(NULL==data){
00038 goto Error;
00039 }
00040 }
00041
00042 np->data = data;
00043 np->key = key;
00044 np->data_size = data_size;
00045 np->right = np->left = root->sentinel;
00046
00047
00048 return np;
00049 Error:
00050 dkcSameObjectPoolRecycle(root->key_ac,key);
00051 dkcSameObjectPoolRecycle(root->obj_ac,np);
00052 return NULL;
00053 }
|
|
||||||||||||||||||||
|
dkc2Tree.c の 67 行で定義されています。 参照先 alloc_2tree_node(), dkc2TreeSetBuffer(), DKC_2TREE_NODE, DKC_2TREE_ROOT, dkcm2TREE_SET_BUFFER_ERROR, free_2tree_node(), dkc_2TreeNode::key, dkc_2TreeRoot::key_size, と NULL. 参照元 dkc2TreeInsert().
00069 {
00070 DKC_2TREE_NODE *np;
00071 int tr;
00072
00073 np = alloc_2tree_node(ptr,data_size);
00074 if(NULL==np){
00075 return NULL;
00076 }
00077 tr = dkc2TreeSetBuffer(np,data,data_size);
00078 //if(tr != edk_NoValueToProcess && DKUTIL_FAILED(tr)){
00079 if(dkcm2TREE_SET_BUFFER_ERROR(tr)){
00080 goto Error;
00081 }
00082
00083 memcpy(np->key,Key,ptr->key_size);
00084 return np;
00085 Error:
00086 free_2tree_node(ptr,&np);
00087 return NULL;
00088 }
|
|
||||||||||||
|
dkc2Tree.c の 338 行で定義されています。 参照先 dkc2TreeExist(), DKC_2TREE_EXIST, DKC_2TREE_NODE, DKC_2TREE_ROOT, erase_tree_with_node(), FALSE, dkc_2TreeExist::isExist, dkc_2TreeExist::leaf_ptr, NULL, と dkc_2TreeRoot::sentinel.
00339 {
00340
00341 DKC_2TREE_EXIST ex;
00342 if(NULL==node || node == ptr->sentinel){
00343 return edk_FAILED;
00344 }
00345 ex = dkc2TreeExist(ptr,node);
00346 if(FALSE==ex.isExist){
00347 return edk_FAILED;
00348 }
00349 erase_tree_with_node(ptr,ex.leaf_ptr);
00350
00351 return edk_SUCCEEDED;
00352 }
|
|
||||||||||||
|
dkc2Tree.c の 386 行で定義されています。 参照先 dkc_2TreeRoot::compare, DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_COMPARE_TYPE, erase_tree_with_node(), dkc_2TreeNode::key, dkc_2TreeRoot::key_size, NULL, dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel.
00387 {
00388 DKC_2TREE_NODE **p = &(ptr->root);
00389 int tr;
00390 DKC_COMPARE_TYPE compare = ptr->compare;
00391
00392 if(NULL==(*p)){
00393 return edk_FAILED;
00394 }
00395
00396 //番兵
00397 memcpy(ptr->sentinel->key,Key,ptr->key_size);
00398
00399 for(;;){
00400 tr = compare(Key,(*p)->key);
00401 if(0==tr){//同じキーがある
00402 break;
00403 }
00404 if(tr < 0){
00405 p = &((*p)->left);
00406 }else{
00407 p = &((*p)->right);
00408 }
00409 }
00410 if(*p == ptr->sentinel)
00411 {//見つからず
00412 return edk_FAILED;
00413 }
00414
00415 erase_tree_with_node(ptr,p);
00416 //return dkc2TreeErase(ptr,p);
00417 //return dkc2TreeErase(ptr,p,(*p));
00418 return edk_SUCCEEDED;
00419
00420 }
|
|
||||||||||||
|
nodeに入れたポインタがptr内に存在するかどうか調べる存在したら結果値を返す。
dkc2Tree.c の 471 行で定義されています。 参照先 DKC_2TREE_EXIST, DKC_2TREE_NODE, DKC_2TREE_ROOT, FALSE, dkc_2TreeExist::isExist, dkc_2TreeExist::leaf_ptr, dkc_2TreeNode::left, dkc_2TreeExist::node, NULL, dkc_2TreeExist::parent, dkc_2TreeNode::right, dkc_2TreeRoot::root, dkc_2TreeRoot::sentinel, tree_exist_reflexive(), と TRUE. 参照元 dkc2TreeErase().
00472 {
00473 DKC_2TREE_NODE *root = ptr->root;
00474 DKC_2TREE_EXIST re;
00475 int t;
00476
00477 re.isExist = FALSE;
00478 re.leaf_ptr = NULL;
00479 re.node = ptr->sentinel;
00480 re.parent = re.node;
00481
00482 if(ptr->root == ptr->sentinel){//中には何も無し・・・
00483 goto End;
00484 }
00485 if(ptr->root == node){
00486 re.isExist = TRUE;
00487 //re.leaf_ptr = NULL;
00488 re.node = ptr->root;
00489 re.parent = NULL;
00490 goto End;
00491 }
00492
00493 //左
00494 t = tree_exist_reflexive(ptr,root->left,&(root->left),node,
00495 NULL,&re);
00496 if(t != 0){
00497 goto End;
00498 }
00499
00500 //右
00501 tree_exist_reflexive(ptr,root->right,&(root->right),node,
00502 NULL,&re);
00503
00504
00505 End:
00506 return re;
00507 }
|
|
||||||||||||
|
dkc2Tree.c の 637 行で定義されています。 参照先 dkc_2TreeRoot::compare, DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_COMPARE_TYPE, dkcmASSERT, dkc_2TreeNode::key, dkc_2TreeRoot::key_size, dkc_2TreeNode::left, NULL, dkc_2TreeNode::right, dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel.
00638 {
00639 DKC_2TREE_NODE *it = ptr->root;
00640 DKC_COMPARE_TYPE compare = ptr->compare;
00641 int tr;
00642
00643 dkcmASSERT(compare);
00644
00645 //番兵
00646 memcpy(ptr->sentinel->key,Key,ptr->key_size);
00647 for(;;){
00648
00649 tr = compare(Key,it->key);
00650 if(0==tr){
00651 break;
00652 }
00653 if(tr < 0){
00654 it = it->left;
00655 }else{
00656 it = it->right;
00657 }
00658
00659 }
00660 if(it == ptr->sentinel){//見つからん
00661 return NULL;
00662 }
00663 return it;
00664 }
|
|
||||||||||||
|
0 初期 前が大きいキー 1 dkc2Tree.c の 742 行で定義されています。 参照先 dkc_2TreeRoot::compare, DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_COMPARE_TYPE, dkcmASSERT, dkcmNOT_ASSERT, dkc_2TreeNode::key, dkc_2TreeNode::left, NULL, dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel.
00743 {
00744
00745 DKC_2TREE_NODE *it = ptr->root,*st = ptr->sentinel;
00746 DKC_2TREE_NODE *save = st;
00747 //*save;
00748 DKC_COMPARE_TYPE compare = ptr->compare;
00749 int tr;
00751 int state = 0;
00752
00753 dkcmASSERT(compare);
00754
00755 for(;;){
00756
00757 if(it == st){
00758 dkcmNOT_ASSERT(NULL==it);
00759 if(NULL==it){//と、いうかありえない・・・
00760 break;
00761 }
00762 switch(state){
00763 case 1:
00764 return save;
00765 case 2:
00766 return it;
00767 }
00768 it = NULL;
00769 break;
00770 }
00771
00772 tr = compare(Key,it->key);
00773
00774 if(tr==0){//同じの見つかったら次に左
00775 if(it->left == st){//つーか、終わりでしたから・・・
00776 return NULL;
00777 }
00778 return it->left;
00779 }
00780
00781 if(tr > 0){//Keyの方が大きい
00782 switch(state){
00783 case 0:
00784 state = 1;
00785 break;
00786 case 1:
00787 return save;
00788 case 2:
00789 return it;
00790 break;
00791 default:
00792 state = 0;
00793 }
00794 save = it;
00795 //
00796 it = it->left;
00797
00798
00799 }else{//Keyの方がちっこい
00800 switch(state){
00801 case 0:
00802 state = 2;
00803 break;
00804 }
00805 save = it;
00806
00807 it = it->left;
00808
00809 }
00810
00811
00812 }
00813
00814 return it;
00815
00816
00817 }
|
|
||||||||||||
|
dkc2Tree.c の 825 行で定義されています。 参照先 dkc_2TreeRoot::compare, DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_COMPARE_TYPE, dkcmASSERT, dkcmNOT_ASSERT, dkc_2TreeNode::key, NULL, dkc_2TreeNode::right, dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel.
00826 {
00827
00828 DKC_2TREE_NODE *it = ptr->root,*st = ptr->sentinel;
00829 DKC_2TREE_NODE *save = st;
00830 //*save;
00831 DKC_COMPARE_TYPE compare = ptr->compare;
00832 int tr;
00833 //0 初期 / 1 前がKeyの方が小さいキー / 2 前がKeyの方が大きいキー
00834 //
00835 int state = 0;
00836
00837 dkcmASSERT(compare);
00838
00839 for(;;){
00840 if(it == st){
00841 dkcmNOT_ASSERT(NULL==it);
00842 if(NULL==it){//と、いうかありえない・・・
00843 break;
00844 }
00845 switch(state){
00846 case 1:
00847 return save;
00848 case 2:
00849 return it;
00850 }
00851 it = NULL;
00852 break;
00853 }
00854 tr = compare(Key,it->key);
00855
00856
00857 if(tr==0){//同じの見つかったら次にデカイのは右
00858 if(it->right == st){//つーか、終わりでしたから・・・
00859 return NULL;
00860 }
00861 return it->right;
00862 }
00863
00864
00865 if(tr > 0){//Keyの方が大きい
00866
00867 switch(state){
00868 case 0:
00869 state = 2;
00870 break;
00871 }
00872 save = it;
00873 //Keyの方が大きいからitはより大きいのを調べる
00874 it = it->right;
00875
00876 }else{//Keyの方がちっこい
00877 switch(state){
00878 case 0:
00879 state = 1;
00880 break;
00881 case 1:
00882 return save;
00883 case 2:
00884 return it;
00885 break;
00886 default:
00887 state = 0;
00888 }
00889 save = it;
00890 //ちっこいからでかいのに移る
00891 it = it->right;
00892
00893 }
00894
00895 }
00896
00897
00898 return it;
00899
00900 }
|
|
||||||||||||||||
|
2分木構造体内に保存しているデータをもらう
dkc2Tree.c の 903 行で定義されています。 参照先 dkc_2TreeNode::data, dkc_2TreeNode::data_size, DKC_2TREE_NODE, と dkc_memcpy_zc().
00903 {
00904 return dkc_memcpy_zc(data,size,ptr->data,ptr->data_size);
00905 }
|
|
||||||||||||||||||||
|
新しいデータを挿入する。
dkc2Tree.c の 292 行で定義されています。 参照先 alloc_set(), dkc_2TreeRoot::compare, DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_COMPARE_TYPE, dkc_2TreeNode::key, dkc_2TreeRoot::key_size, NULL, dkc_2TreeNode::right, dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel.
00294 {
00295 typedef DKC_2TREE_NODE *DKC_2TREE_NODE_PTR;
00296 int cmp;
00297 DKC_2TREE_NODE_PTR *p, q;
00298 DKC_COMPARE_TYPE compare = ptr->compare;
00299
00300 p = &(ptr->root);
00301
00302 //番兵
00303 memcpy(ptr->sentinel->key,Key,ptr->key_size);
00304
00305 for(;;){
00306 cmp = compare(Key, (*p)->key);
00307 if(0==cmp){
00308 break;
00309 }
00310 if (cmp < 0){
00311 p = &((*p)->left );
00312 }else{
00313 p = &((*p)->right);
00314 }
00315 }
00316
00317 if (*p != ptr->sentinel)
00318 {//登録済み
00319 return edk_FAILED;
00320 }
00321
00322 q = alloc_set(ptr,Key,data,data_size);
00323 if(NULL==q){
00324 return edk_OutOfMemory;
00325 }
00326
00327 q->left = ptr->sentinel;
00328 q->right = *p;
00329 *p = q;
00330 #ifdef DEBUG
00331 //printf("key = %d\n",*(int *)(q->key));
00332 #endif
00333 return edk_SUCCEEDED;
00334 }
|
|
||||||||||||||||
|
2分木構造体に保存しているデータ領域にデータを入れる。 2分木構造体内のバッファが足りない場合はこの関数の内部で拡張してくれる。
dkc2Tree.c の 907 行で定義されています。 参照先 dkc_2TreeNode::data, dkc_2TreeNode::data_size, DKC_2TREE_NODE, dkc_memcpy_zc(), dkcReallocate(), と NULL. 参照元 alloc_set().
00907 {
00908 int t;
00909 void *np = NULL;
00910 if(size == 0){
00911 return edk_NoValueToProcess;
00912 }
00913 t = dkc_memcpy_zc(ptr->data,ptr->data_size,data,size);
00914
00915 if(DKUTIL_FAILED(t))
00916 {
00917 t = dkcReallocate(&np,size,&(ptr->data));
00918 if(DKUTIL_FAILED(t)){
00919 return t;
00920 }
00921 ptr->data = np;
00922 ptr->data_size = size;
00923 return dkc2TreeSetBuffer(ptr,data,size);
00924 }
00925 return t;
00926 }
|
|
||||||||||||
|
dkc2Tree.c の 285 行で定義されています。 参照先 DKC_2TREE_NODE.
00285 {
00286
00287
00288 }
|
|
||||||||||||||||||||
|
2分木領域を得る。
dkc2Tree.c の 115 行で定義されています。 参照先 alloc_2tree_node(), dkc_2TreeRoot::compare, DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_COMPARE_TYPE, dkcAllocate(), dkcAllocSameObjectPool(), dkcFree(), dkcFreeSameObjectPool(), dkc_2TreeRoot::key_ac, dkc_2TreeRoot::key_size, dkc_2TreeNode::left, dkc_2TreeRoot::max_num, dkc_2TreeRoot::now_num, NULL, dkc_2TreeRoot::obj_ac, dkc_2TreeRoot::pool_max, dkc_2TreeNode::right, dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel.
00116 {
00117 DKC_2TREE_ROOT *root = dkcAllocate(sizeof(DKC_2TREE_ROOT));
00118 if(NULL==root){
00119 return NULL;
00120 }
00121 root->key_ac = dkcAllocSameObjectPool(key_size,pool_max,NULL,NULL);
00122 if(NULL==root->key_ac){
00123 goto Error;
00124 }
00125
00126 root->obj_ac = dkcAllocSameObjectPool(sizeof(DKC_2TREE_NODE),pool_max,NULL,NULL);
00127 if(NULL==root->obj_ac){
00128 goto Error;
00129 }
00130 root->max_num = max_num;
00131 root->key_size = key_size;
00132 root->pool_max = pool_max;
00133 root->compare = compare;
00134 root->now_num = 0;
00135 root->sentinel = alloc_2tree_node(root,0);
00136
00137 if(NULL==root->sentinel){
00138 goto Error;
00139 }
00140 //番兵を入れておく
00141 root->root = root->sentinel;
00142 //無限ループにならないようにコーディングしなくては・・・
00143 root->sentinel->left = root->sentinel->right = root->sentinel;
00144 return root;
00145 Error:
00146 dkcFreeSameObjectPool(&(root->key_ac));
00147 dkcFree(&root);
00148 return NULL;
00149 }
|
|
||||||||||||
|
ppから左、右についた葉を削除
dkc2Tree.c の 208 行で定義されています。 参照先 DKC_2TREE_NODE, DKC_2TREE_ROOT, erase_tree_with_node(), dkc_2TreeNode::left, dkc_2TreeNode::right, と dkc_2TreeRoot::sentinel. 参照元 dkcFree2TreeReflexiveBegin().
00209 {
00210
00211 //DKC_2TREE_NODE *root = ptr->root;
00212 DKC_2TREE_NODE *l,*r;
00213 DKC_2TREE_NODE *node = *pp;
00214
00215 if(node==ptr->sentinel)
00216 {
00217 return;
00218 }
00219
00220 l = node->left;
00221 r = node->right;
00222
00223
00224
00225 dkcFree2TreeReflexive(ptr,&l);
00226 dkcFree2TreeReflexive(ptr,&r);
00227
00228 if(node->left != ptr->sentinel)
00229 erase_tree_with_node(ptr,&(node->left));
00230 if(node->right != ptr->sentinel)
00231 erase_tree_with_node(ptr,&(node->right));
00232 return;
00233
00234 }
|
|
|
dkc2Tree.c の 239 行で定義されています。 参照先 DKC_2TREE_ROOT, dkcFree2TreeReflexive(), erase_tree_with_node(), dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel. 参照元 dkcFree2TreeRoot().
00239 {
00240 if(ptr->sentinel==ptr->root){
00241 goto End;
00242 }
00243 //rootから左、右についた葉を削除
00244 dkcFree2TreeReflexive(ptr,&(ptr->root));
00245 erase_tree_with_node(ptr,&(ptr->root));
00246 End:
00247 return edk_SUCCEEDED;
00248 }
|
|
|
dkcAllocNew2Tree()で確保したリスト領域と内部バッファを削除。dkcAllocNew2Treeと対。 DKC_2TREEをデリート (リンクしてあるリストも削除します。 一つだけの要素を削除したい場合はdkcErase2Treeを使ってください。)
dkc2Tree.c の 250 行で定義されています。 参照先 DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_STACK, dkcAllocStack(), dkcFree2TreeReflexiveBegin(), dkcFree2TreeWithVector(), dkcFreeStack(), free_2tree_root(), と NULL.
00250 {
00251
00252 int result;
00253
00254 if(NULL==ptr || NULL==*ptr){
00255 return edk_ArgumentException;
00256 }
00257
00258 #if 0
00259 {
00260
00261 DKC_STACK *stack;
00262 stack = dkcAllocStack(100,sizeof(DKC_2TREE_NODE *));
00263 if(NULL==stack) return edk_FAILED;
00264
00265
00266 result = dkcFree2TreeWithStack((*ptr),stack);
00267
00268 dkcFreeStack(&stack);
00269 }
00270 #elif 0
00271 result = dkcFree2TreeWithVector((*ptr));
00272 #else
00273 //dkcFree2TreeReflexive((*ptr),(*ptr)->root);
00274 //result = edk_SUCCEEDED;
00275 result = dkcFree2TreeReflexiveBegin((*ptr));
00276
00277 #endif
00278 free_2tree_root((*ptr));
00279
00280 (*ptr) = NULL;
00281 return result;
00282
00283 }
|
|
|
dkc2Tree.c の 161 行で定義されています。 参照先 DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_MEMORYSTREAM, dkcAllocMemoryStream(), dkcMemoryStreamNowOffset(), dkcMemoryStreamPointer(), dkcMemoryStreamWrite(), free_2tree_node(), dkc_2TreeNode::left, dkc_2TreeRoot::now_num, NULL, dkc_2TreeNode::right, と dkc_2TreeRoot::root. 参照元 dkcFree2TreeRoot().
00161 {
00162 DKC_2TREE_NODE *it;
00163 size_t se,i;
00164 DKC_MEMORYSTREAM *ms;
00165 it = ptr->root;
00166
00167 ms = dkcAllocMemoryStream(sizeof(DKC_2TREE_NODE *) * ptr->now_num);
00168 if(NULL==ms){
00169 return edk_FAILED;
00170 }
00171
00172 for(;;){
00173
00174 if(NULL != it){
00175 if(it->left){
00176 dkcMemoryStreamWrite(ms,it->left,sizeof(DKC_2TREE_NODE *));
00177 it = it->left;
00178 continue;
00179 }
00180 if(it->right){
00181 dkcMemoryStreamWrite(ms,it->right,sizeof(DKC_2TREE_NODE *));
00182 it = it->right;
00183 continue;
00184 }
00185 }else{
00186 dkcMemoryStreamWrite(ms,it,sizeof(DKC_2TREE_NODE *));
00187 break;
00188 }
00189
00190 }
00191 it = (DKC_2TREE_NODE *)dkcMemoryStreamPointer(ms);
00192 se = dkcMemoryStreamNowOffset(ms);
00193 for(i = 0;i<se;i++,it++){
00194 free_2tree_node(ptr,&it);
00195 }
00196
00197 return edk_SUCCEEDED;
00198
00199
00200 }
|
|
||||||||||||
|
dkc2Tree.c の 90 行で定義されています。 参照先 DKC_2TREE_NODE, DKC_2TREE_ROOT, free_2tree_node(), dkc_2TreeNode::left, dkc_2TreeNode::right, と dkc_2TreeRoot::sentinel. 参照元 dkc2TreeErase(), dkc2TreeEraseFromKey(), dkcFree2TreeReflexive(), と dkcFree2TreeReflexiveBegin().
00091 {
00092 DKC_2TREE_NODE *target = (*leaf_node);
00093 DKC_2TREE_NODE **p = leaf_node, **q, *s;
00094
00095 if(target == ptr->sentinel){
00096 return;
00097 }
00098 if (target->right == ptr->sentinel) *p = target->left;
00099 else if (target->left == ptr->sentinel) *p = target->right;
00100 else {
00101 q = &(target->left);
00102 while ((*q)->right != ptr->sentinel){
00103 q = &((*q)->right);
00104 }
00105 s = *q; *q = s->left;
00106 s->left = target->left;
00107 s->right = target->right;
00108 *p = s;
00109 }
00110 free_2tree_node(ptr,&target);
00111
00112 }
|
|
||||||||||||||||
|
dkc2Tree.c の 667 行で定義されています。 参照先 BOOL, dkc_2TreeRoot::compare, DKC_2TREE_NODE, DKC_2TREE_ROOT, DKC_COMPARE_TYPE, dkcmASSERT, dkc_2TreeNode::key, NULL, dkc_2TreeNode::right, dkc_2TreeRoot::root, と dkc_2TreeRoot::sentinel.
00668 {
00669 DKC_2TREE_NODE *it = ptr->root,*st = ptr->sentinel;
00670 DKC_2TREE_NODE *save = st;
00671 //*save;
00672 DKC_COMPARE_TYPE compare = ptr->compare;
00673 int tr;
00674 //0 初期 / 1 前がKeyの方が小さいキー / 2 前がKeyの方が大きいキー
00675 //
00676 int state = 0;
00677
00678 dkcmASSERT(compare);
00679
00680 for(;;){
00681 if(it == st || NULL==it){
00682 it = NULL;
00683 break;
00684 }
00685 if(isGreater){
00686 tr = compare(Key,it->key);
00687 }else{
00688 tr = compare(it->key,Key);
00689 }
00690
00691 if(tr==0){//同じの見つかったら次にデカイのは右
00692 return it->right;
00693 }
00694
00695 if(tr > 0){//Keyの方が大きい
00696 /*if(1==state){
00697 return it;
00698 }else{
00699 state = 0;
00700 }*/
00701 switch(state){
00702 case 0:
00703 state = 2;
00704 break;
00705 }
00706 save = it;
00707 //Keyの方が大きいからitはより大きいのを調べる
00708 it = it->right;
00709
00710 }else{//Keyの方がちっこい
00711 switch(state){
00712 case 0:
00713 state = 1;
00714 break;
00715 case 1:
00716 return save;
00717 case 2:
00718 return it;
00719 break;
00720 default:
00721 state = 0;
00722 }
00723 save = it;
00724 //ちっこいからでかいのに移る
00725 it = it->right;
00726
00727 }
00728
00729 }
00730
00731 return it;
00732
00733 }
|
|
||||||||||||
|
dkc2Tree.c の 55 行で定義されています。 参照先 DKC_2TREE_NODE, DKC_2TREE_ROOT, dkcFree(), dkcmNOT_ASSERT, dkcSameObjectPoolRecycle(), dkc_2TreeRoot::key_ac, NULL, と dkc_2TreeRoot::obj_ac. 参照元 alloc_set(), dkcFree2TreeWithVector(), erase_tree_with_node(), と free_2tree_root().
00056 {
00057 DKC_2TREE_NODE *n = (*node);
00058 dkcmNOT_ASSERT(NULL==n);
00059 dkcFree(&(n->data));
00060
00061 dkcSameObjectPoolRecycle(root->key_ac,n->key);
00062
00063 dkcSameObjectPoolRecycle(root->obj_ac,n);
00064 //dkcFree(node);
00065
00066 }
|
|
|
dkc2Tree.c の 151 行で定義されています。 参照先 DKC_2TREE_ROOT, dkcFree(), dkcFreeSameObjectPool(), free_2tree_node(), dkc_2TreeRoot::key_ac, dkc_2TreeRoot::obj_ac, と dkc_2TreeRoot::sentinel. 参照元 dkcFree2TreeRoot().
00151 {
00152 free_2tree_node(root,&(root->sentinel));
00153 dkcFreeSameObjectPool(&(root->key_ac));
00154 dkcFreeSameObjectPool(&(root->obj_ac));
00155 dkcFree(&root);
00156
00157 }
|
|
||||||||||||||||||||||||||||
|
0見つからない 1見つかった
dkc2Tree.c の 436 行で定義されています。 参照先 DKC_2TREE_EXIST, DKC_2TREE_NODE, DKC_2TREE_ROOT, dkc_2TreeExist::isExist, dkc_2TreeExist::leaf_ptr, dkc_2TreeNode::left, dkc_2TreeExist::node, NULL, dkc_2TreeExist::parent, dkc_2TreeNode::right, dkc_2TreeRoot::sentinel, と TRUE. 参照元 dkc2TreeExist().
00440 {
00441 int t;
00442 if(ptr->sentinel == node){
00443 return 0;
00444 }
00445 if(node == target){
00446 re->isExist = TRUE;
00447 re->leaf_ptr = leaf_ptr;
00448 re->node = node;
00449 re->parent = parent;
00450 return 1;
00451 }
00452 if(parent == NULL){
00453 parent = node;
00454 }
00455 //左
00456 t = tree_exist_reflexive(ptr,node->left,&(node->left),target,node,re);
00457 if(t != 0){
00458 return t;
00459 }
00460
00461 //右
00462 t = tree_exist_reflexive(ptr,node->right,&(node->right),target,node,re);
00463 if(t != 0){
00464 return t;
00465 }
00466
00467 //見つからない・・・。
00468 return 0;
00469 }
|
1.3.6