9_排序二叉树删除-1

出处:http://blog.csdn.net/feixiaoxing/article/details/6867460   

相比较节点的添加，平衡二叉树的删除要复杂一些。因为在删除的过程中，你要考虑到不同的情况，针对每一种不同的情况，你要有针对性的反应和调整。所以在代码编写的过程中，我们可以一边写代码，一边写测试用例。编写测试用例不光可以验证我们编写的代码是否正确，还能不断提高我们开发代码的自信心。这样，即使我们在开发过程对代码进行修改或者优化也不会担心害怕。然而看起来编写测试用例是一个繁杂的过程，但是从长期的收益来看，编写测试用例的成本是非常低廉的。

    在排序二叉树的删除过程当中，我们应该怎么做呢？大家不用担心，只要按照我们下面的介绍一步一步往下做就可以了，大体上分为下面三个步骤：

    1）判断参数的合法性，判断参数是否在当前的二叉树当中

    2）删除的节点是根节点，此时应该怎么调整

    3）删除的节点是普通节点，此时又应该怎么调整

    闲话不多说，下面看看我们的代码是怎么设计的？

   1、判断参数的合法性，同时判断当前的二叉树是否含有相关数据

    1.1 判断输入参数是否合法

[cpp] view plaincopy

1. STATUS delete_node_from_tree(TREE_NODE** ppTreeNode, int data)  
2. {  
3.     if(NULL == ppTreeNode || NULL == *ppTreeNode)  
4.         return FALSE;  
5.     return TRUE；  
6. }  

    那么此时测试用例怎么写呢？

[cpp] view plaincopy

1. static void test1()  
2. {  
3.     TREE_NODE* pTreeNode = NULL;  
4.     assert(FALSE == delete_node_from_tree(NULL, 10));  
5.     assert(FALSE == delete_node_from_tree(&pTreeNode, 10));  
6. }  

    注： 上面的测试用例说明当指针为空或者指针的指针为空，函数返回FALSE。

    1.2 判断输入数据是否存在

[cpp] view plaincopy

1. STATUS delete_node_from_tree(TREE_NODE** ppTreeNode, int data)  
2. {  
3.     TREE_NODE* pTreeNode;  
4.       
5.     if(NULL == ppTreeNode || NULL == *ppTreeNode)  
6.         return FALSE;  
7.   
8.     pTreeNode = find_data_in_tree_node(*ppTreeNode, data);  
9.     if(NULL == pTreeNode)  
10.         return FALSE;  
11.       
12.     return TRUE;  
13. }  

    此时，我们设计一种当前指针合法，但是删除数据不存在的测试用例。

[cpp] view plaincopy

1. static void test2()  
2. {  
3.     TREE_NODE* pTreeNode = NULL;  
4.     pTreeNode = create_tree_node(10);  
5.     assert(FALSE == delete_node_from_tree(&pTreeNode, 11));  
6.     free(pTreeNode);  
7. }  

    注： 上面的测试用例根节点为10，但是删除的数据为11，单步跟踪，验证我们编写的代码是否正确。

    2、删除的数据是根节点数据

    2.1 删除根数据时，根节点没有左子树，没有右子树情形

[cpp] view plaincopy

1. /* 
2. *                
3. *         10          ======>    NULL 
4. *        /  \ 
5. *      NULL  NULL 
6. */  

    那么此时代码应该怎么写呢？我们可以试一试。

[cpp] view plaincopy

1. STATUS delete_node_from_tree(TREE_NODE** ppTreeNode, int data)  
2. {  
3.     TREE_NODE* pTreeNode;  
4.       
5.     if(NULL == ppTreeNode || NULL == *ppTreeNode)  
6.         return FALSE;  
7.   
8.     pTreeNode = find_data_in_tree_node(*ppTreeNode, data);  
9.     if(NULL == pTreeNode)  
10.         return FALSE;  
11.       
12.     if(*ppTreeNode == pTreeNode){         
13.         if(NULL == pTreeNode->left_child && NULL == pTreeNode->right_child){  
14.             *ppTreeNode = NULL;  
15.         }  
16.           
17.         free(pTreeNode);  
18.         return TRUE;  
19.     }  
20.   
21.     return TRUE;  
22. }  

    我们的代码明显越来越长，我们要保持耐心。此时，该是我们添加新测试用例的时候了。

[cpp] view plaincopy

1. static void test3()  
2. {  
3.     TREE_NODE* pTreeNode = NULL;  
4.     pTreeNode = create_tree_node(10);  
5.     assert(TRUE == delete_node_from_tree(&pTreeNode, 10));  
6.     assert(NULL == pTreeNode);  
7. }  

    2.2 删除根数据时，只有左子树节点，没有右子树节点

[cpp] view plaincopy

1. /* 
2. *                
3. *         10          ======>    5 
4. *        /  \                  /  \ 
5. *      5  NULL                3    NULL 
6. *     /                       
7. *    3 
8. */  

    很明显，我们只需要把用左子树节点代替原来的根节点即可。

[cpp] view plaincopy

1. STATUS delete_node_from_tree(TREE_NODE** ppTreeNode, int data)  
2. {  
3.     TREE_NODE* pTreeNode;  
4.       
5.     if(NULL == ppTreeNode || NULL == *ppTreeNode)  
6.         return FALSE;  
7.   
8.     pTreeNode = find_data_in_tree_node(*ppTreeNode, data);  
9.     if(NULL == pTreeNode)  
10.         return FALSE;  
11.       
12.     if(*ppTreeNode == pTreeNode){         
13.         if(NULL == pTreeNode->left_child && NULL == pTreeNode->right_child){  
14.             *ppTreeNode = NULL;  
15.         }else if(NULL != pTreeNode->left_child && NULL == pTreeNode->right_child){  
16.             *ppTreeNode = pTreeNode->left_child;  
17.             pTreeNode->left_child->parent = NULL;  
18.         }  
19.           
20.         free(pTreeNode);  
21.         return TRUE;  
22.     }  
23.   
24.     return TRUE;  
25. }  

    这个时候，我们可以添加新的测试用例，分别添加10、5、3，然后删除10。

[cpp] view plaincopy

1. static void test4()  
2. {  
3.     TREE_NODE* pTreeNode = NULL;  
4.     assert(TRUE == insert_node_into_tree(&pTreeNode, 10));  
5.     assert(TRUE == insert_node_into_tree(&pTreeNode, 5));  
6.     assert(TRUE == insert_node_into_tree(&pTreeNode, 3));  
7.     assert(TRUE == delete_node_from_tree(&pTreeNode, 10));  
8.     assert(5 == pTreeNode->data);  
9.     assert(NULL == pTreeNode->parent);  
10.     free(pTreeNode->left_child);  
11.     free(pTreeNode);  
12. }  

    2.3 删除根数据时，没有左子树节点，只有右子树节点

[cpp] view plaincopy

1. /* 
2. *                
3. *         10          ======>    15 
4. *        /  \                   /   \ 
5. *     NULL  15               NULL    20 
6. *             \ 
7. *             20 
8. */  

    上面的代码表示了节点的删除过程。我们可以按照这个流程编写代码。

[cpp] view plaincopy

1. STATUS delete_node_from_tree(TREE_NODE** ppTreeNode, int data)  
2. {  
3.     TREE_NODE* pTreeNode;  
4.       
5.     if(NULL == ppTreeNode || NULL == *ppTreeNode)  
6.         return FALSE;  
7.   
8.     pTreeNode = find_data_in_tree_node(*ppTreeNode, data);  
9.     if(NULL == pTreeNode)  
10.         return FALSE;  
11.       
12.     if(*ppTreeNode == pTreeNode){         
13.         if(NULL == pTreeNode->left_child && NULL == pTreeNode->right_child){  
14.             *ppTreeNode = NULL;  
15.         }else if(NULL != pTreeNode->left_child && NULL == pTreeNode->right_child){  
16.             *ppTreeNode = pTreeNode->left_child;  
17.             pTreeNode->left_child->parent = NULL;  
18.         }else if(NULL == pTreeNode->left_child && NULL != pTreeNode->right_child){  
19.             *ppTreeNode = pTreeNode->right_child;  
20.             pTreeNode->right_child->parent = NULL;  
21.         }  
22.           
23.         free(pTreeNode);  
24.         return TRUE;  
25.     }  
26.   
27.     return TRUE;  
28. }  

    添加测试用例，依次添加10、15、20，然后删除数据10。

[cpp] view plaincopy

1. static void test5()  
2. {  
3.     TREE_NODE* pTreeNode = NULL;  
4.     assert(TRUE == insert_node_into_tree(&pTreeNode, 10));  
5.     assert(TRUE == insert_node_into_tree(&pTreeNode, 15));  
6.     assert(TRUE == insert_node_into_tree(&pTreeNode, 20));  
7.     assert(TRUE == delete_node_from_tree(&pTreeNode, 10));  
8.     assert(15 == pTreeNode->data);  
9.     assert(NULL == pTreeNode->parent);  
10.     free(pTreeNode->right_child);  
11.     free(pTreeNode);  
12. }