c语言实现二叉树的插入、查找、删除、打印树

目录：

---

二叉树的关键概念：

• 每个节点是一个自引用结构体，形式如下：

struct TreeNode {    struct TreeNode *leftPtr;  /* pointer to left subtree */    int data;                  /* node data */    struct TreeNode *rightPtr; /* pointer to right subtree */};

• 从根部节点开始，每个节点拥有两个子节点（NULL或者一个节点），称为左节点与右节点，每个节点的左部分与右部分又分别称为该节点的左子树与右子树。
• 每个节点的键值大于左节点，小于右节点；每个节点的键值大于左子树所有节点的键值，小于右子树所有节点的键值。所以二叉树是按节点键值排序的数据结构。
• 二叉树的某个节点，如果不是叶节点，则有左子树或右子树，是一个更小的树，因此可以递归地处理关于树的一些问题。

---

二叉树的插入

• 思路：将要插入节点的键值与根节点键值比较，如果小于根节点键值，则插入根节点的左子树，如果大于根节点的键值，则插入根节点的右子树，插入子树相当于插入一个更小的树，因此可以用递归方法实现，直到找到没有子树的节点，将新节点插到其下面。注意，新节点插入后，最终只会成为叶节点。

函数代码如下（测试插入、删除、打印功能的源码在最后面，此处只给出插入函数代码）：

void insertNode(TreeNodePtr *treePtr, int value){    /* if treePtr is NULL */    if (*treePtr == NULL) {        *treePtr = malloc(sizeof(TreeNode));        if (*treePtr != NULL) {            (*treePtr)->data = value;            (*treePtr)->leftPtr = NULL;            (*treePtr)->rightPtr = NULL;        }        else {            printf("%d not inserted. No memory available.\n", value);        }     }     else {            /* insert node in left subtree */        if (value < (*treePtr)->data) {            insertNode(&((*treePtr)->leftPtr), value);        }         else {            /* insert node in right subtree */            if (value >(*treePtr)->data) {                insertNode(&((*treePtr)->rightPtr), value);            }             else {                 printf("dup");            }        }     } } 

二叉树的查找

• 思路：与插入类似，从根节点开始，将查找的键值与根节点键值比较，若相等，则返回指向该节点的指针，若查找的键值比它大，则从根节点的右子树开始查找，若查找的键值比它小，则从根节点的左子树开始查找。可以用递归方法实现，类似于插入。这里我用迭代实现，能用迭代还是用迭代，因为递归开销比较大。

函数代码如下：

TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value){    TreeNode *tempPtr = treePtr;    while (tempPtr != NULL && tempPtr->data != value)    {        if (value > tempPtr->data)            tempPtr = tempPtr->rightPtr;        else            tempPtr = tempPtr->leftPtr;    }    return tempPtr;}

二叉树的删除

• 相比于二叉树的插入和查找，删除一个节点要复杂一些，原因是要保证二叉树的排序性质。二叉树删除有如下三种情况：

  1. 删除节点是叶节点，即没有子节点，或者说左右子节点都是NULL。这种情况下，只需要把删除节点的父节点中对应的指针指向NULL即可。然后释放掉删除节点的空间。

  2. 删除节点有一个子节点（左子节点或右子节点），这种情况下，把删除节点的父节点中对应的指针指向删除节点的子节点即可。然后释放掉删除节点的空间

  3. 删除节点有两个子节点，这种情况下，必须要找到一个替代删除节点的替代节点，并且保证二叉树的排序性。根据二叉树的排序性，可知替代节点的键值必须最接近删除节点键值。比删除节点键值小的所有键值中最大那个，或者是比删除节点键值大的所有键值中最小的那个，是符合要求的。这两个键值所在的节点分别在删除节点的左子树中最右边的节点，删除节点右子树中最左边的节点。以从左子树中找最大键值节点为例，算法如下：

  1. 找到删除节点以及它的父节点
  2. 在删除节点的左子树中，向下向右遍历，找到替代节点以及它的父节点
  3. 删除节点的父节点中对应的指针指向替代节点
  4. 替代节点中的右子节点指针指向删除节点的右子树
  5. 如果替代节点的父节点不是删除节点，则将替代节点的左子节点指针指向删除节点的左子树，并且替代节点的父节点中对应的指针指向替代节点的左子节点
  6. 释放删除节点的空间
     注意：第二步中找到的替代节点，可能会有左子树，但一定没有右子树。第五步要判断替代节点的父节点不是删除节点后，才将替代节点的左子节点指针指向删除节点的左子树，否则会出现替代节点左子节点指针指向自己的情况，从而丢失替代节点的左子树。

另外，还有一种实现相同效果的的方法，即将替代节点中的数据赋给删除节点，然后释放替代节点的空间。这种方法其实是删除了替代节点，并没有真正删除想要删除的节点。而且如果节点包括一个键值和很多其他的数据，则赋值语句会很多。在最后面的测试过程中，我也给出了这个函数的实现，void deleteNode2(TreeNode **treePtrP, int value)

代码如下：

void deleteNode(TreeNode **treePtrP, int value){    TreeNode *deleteNodePtr = *treePtrP;    TreeNode *parentNodeOfDeletePtr = NULL;    TreeNode *substituteNodePtr;    TreeNode *parentNodeOfSubstitutePtr;    //find deleNode and its parentNode    while (deleteNodePtr != NULL && value != deleteNodePtr->data)    {        parentNodeOfDeletePtr = deleteNodePtr;        if (deleteNodePtr->data > value)        {            deleteNodePtr = deleteNodePtr->leftPtr;        }        else        {            deleteNodePtr = deleteNodePtr->rightPtr;        }    }    //case that can't find such Node    if (deleteNodePtr == NULL)    {        printf("no such Node, delete fail\n\n");        return;    }    //delete a leafNode    if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = NULL;        }        else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)        {            parentNodeOfDeletePtr->leftPtr = NULL;        }        else        {            parentNodeOfDeletePtr->rightPtr = NULL;        }    }    //delete a Node which has a left child Node    else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = deleteNodePtr->leftPtr;        }        else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)            parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;        else            parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;    }    //delete a Node which has a right child Node    else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = deleteNodePtr->rightPtr;        }        else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)            parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;        else            parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;    }    //delete a Node which has a left and a right child Node    else    {        parentNodeOfSubstitutePtr = deleteNodePtr;        substituteNodePtr = deleteNodePtr->leftPtr;        //search down and right to find substituteNode and its parentNode        while (substituteNodePtr->rightPtr != NULL)        {            parentNodeOfSubstitutePtr = substituteNodePtr;            substituteNodePtr = substituteNodePtr->rightPtr;        }        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = substituteNodePtr;        }        else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)        {            parentNodeOfDeletePtr->leftPtr = substituteNodePtr;        }        else        {            parentNodeOfDeletePtr->rightPtr = substituteNodePtr;        }        substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;        if (parentNodeOfSubstitutePtr != deleteNodePtr)        {            substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;            if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)            {                parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;            }            else            {                parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;            }        }    }    free(deleteNodePtr);}

二叉树的打印

• 从根节点开始，先输出右子树，再输出节点键值，再输出左子树。采用递归法
  代码如下：

void outputTree(TreeNodePtr treePtr, int spaces){    int loop;    while (treePtr != NULL) {        outputTree(treePtr->rightPtr, spaces + 4);        for (loop = 1; loop <= spaces; loop++) {            printf(" ");        }         printf("%d\n", treePtr->data);        outputTree(treePtr->leftPtr, spaces + 4);        treePtr = NULL;    } } 

测试结果截图

测试插入、删除、打印树源码

#include <stdio.h>#include <stdlib.h>#include <time.h>struct TreeNode {    struct TreeNode *leftPtr;  /* pointer to left subtree */    int data;                  /* node data */    struct TreeNode *rightPtr; /* pointer to right subtree */};typedef struct TreeNode TreeNode;void insertNode(TreeNode **treePtr, int value);TreeNode * binaryTreeSereach(TreeNode * const treePtr, int value);void deleteNode(TreeNode **treePtrP, int value);void outputTree(TreeNode *treePtr, int spaces);void deleteNode2(TreeNode **treePtrP, int value);int main(void){    int arr[] = { 45, 83, 28, 97, 71, 40, 18, 77, 99, 92, 72, 69, 44, 32, 19, 11 };    int i;                      /* loop counter */    int item;                   /* value to deal with */    int totalSpaces = 0;        /* spaces preceding output */    TreeNode *rootPtr = NULL; /* points to the tree root */    srand(time(NULL)); /* randomize */    printf("The numbers being placed in the tree are:\n\n");    for (i = 0; i < sizeof(arr) / sizeof(int); i++) {        item = arr[i];        printf("%3d", item);        insertNode(&rootPtr, item);    }    printf("\n\n\nnow the tree is:\n\n");    if (rootPtr == NULL)        printf("empty tree\n");    else        outputTree(rootPtr, totalSpaces);    //random delete Nodes, then output the tree    while (rootPtr != NULL)    {        item = rand() % 16;        printf("\n\nafter delete %d:\n\n", arr[item]);        deleteNode2(&rootPtr, arr[item]);        if (rootPtr == NULL)            printf("empty tree\n");        else            outputTree(rootPtr, totalSpaces);    }    return 0; }void insertNode(TreeNode **treePtr, int value){    /* if treePtr is NULL */    if (*treePtr == NULL) {        *treePtr = malloc(sizeof(TreeNode));        if (*treePtr != NULL) {            (*treePtr)->data = value;            (*treePtr)->leftPtr = NULL;            (*treePtr)->rightPtr = NULL;        }        else {            printf("%d not inserted. No memory available.\n", value);        }    }    else {        /* insert node in left subtree */        if (value < (*treePtr)->data) {            insertNode(&((*treePtr)->leftPtr), value);        }        else {            /* insert node in right subtree */            if (value >(*treePtr)->data) {                insertNode(&((*treePtr)->rightPtr), value);            }            else {                printf("dup");            }        }    }}TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value){    TreeNode *tempPtr = treePtr;    while (tempPtr != NULL && tempPtr->data != value)    {        if (value > tempPtr->data)            tempPtr = tempPtr->rightPtr;        else            tempPtr = tempPtr->leftPtr;    }    return tempPtr;}void deleteNode(TreeNode **treePtrP, int value){    TreeNode *deleteNodePtr = *treePtrP;    TreeNode *parentNodeOfDeletePtr = NULL;    TreeNode *substituteNodePtr;    TreeNode *parentNodeOfSubstitutePtr;    //find deleNode and its parentNode    while (deleteNodePtr != NULL && value != deleteNodePtr->data)    {        parentNodeOfDeletePtr = deleteNodePtr;        if (deleteNodePtr->data > value)        {            deleteNodePtr = deleteNodePtr->leftPtr;        }        else        {            deleteNodePtr = deleteNodePtr->rightPtr;        }    }    //case that can't find such Node    if (deleteNodePtr == NULL)    {        printf("no such Node, delete fail\n\n");        return;    }    //delete a leafNode    if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = NULL;        }        else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)        {            parentNodeOfDeletePtr->leftPtr = NULL;        }        else        {            parentNodeOfDeletePtr->rightPtr = NULL;        }    }    //delete a Node which has a left child Node    else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = deleteNodePtr->leftPtr;        }        else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)            parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;        else            parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;    }    //delete a Node which has a right child Node    else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = deleteNodePtr->rightPtr;        }        else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)            parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;        else            parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;    }    //delete a Node which has a left and a right child Node    else    {        parentNodeOfSubstitutePtr = deleteNodePtr;        substituteNodePtr = deleteNodePtr->leftPtr;        //search down and right to find substituteNode and its parentNode        while (substituteNodePtr->rightPtr != NULL)        {            parentNodeOfSubstitutePtr = substituteNodePtr;            substituteNodePtr = substituteNodePtr->rightPtr;        }        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = substituteNodePtr;        }        else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)        {            parentNodeOfDeletePtr->leftPtr = substituteNodePtr;        }        else        {            parentNodeOfDeletePtr->rightPtr = substituteNodePtr;        }        substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;        if (parentNodeOfSubstitutePtr != deleteNodePtr)        {            substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;            if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)            {                parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;            }            else            {                parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;            }        }    }    free(deleteNodePtr);}void outputTree(TreeNode *treePtr, int spaces){    int loop;    while (treePtr != NULL) {        outputTree(treePtr->rightPtr, spaces + 4);        for (loop = 1; loop <= spaces; loop++) {            printf(" ");        }        printf("%d\n", treePtr->data);        outputTree(treePtr->leftPtr, spaces + 4);        treePtr = NULL;    }}void deleteNode2(TreeNode **treePtrP, int value){    TreeNode *deleteNodePtr = *treePtrP;    TreeNode *parentNodeOfDeletePtr = NULL;    TreeNode *substituteNodePtr;    TreeNode *parentNodeOfSubstitutePtr;    //find deleNode and its parentNode    while (deleteNodePtr != NULL && value != deleteNodePtr->data)    {        parentNodeOfDeletePtr = deleteNodePtr;        if (deleteNodePtr->data > value)        {            deleteNodePtr = deleteNodePtr->leftPtr;        }        else        {            deleteNodePtr = deleteNodePtr->rightPtr;        }    }    //case that can't find such Node    if (deleteNodePtr == NULL)    {        printf("no such Node, delete fail\n\n");        return;    }    // delete a leafNode    if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = NULL;        }        else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)        {            parentNodeOfDeletePtr->leftPtr = NULL;        }        else        {            parentNodeOfDeletePtr->rightPtr = NULL;        }    }    //delete a Node which has a left child Node    else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = deleteNodePtr->leftPtr;        }        else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)            parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;        else            parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;    }    //delete a Node which has a right child Node    else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)    {        //delete Node is root        if (parentNodeOfDeletePtr == NULL)        {            *treePtrP = deleteNodePtr->rightPtr;        }        else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)            parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;        else            parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;    }    //delete a Node which has a left and a right child Node    else    {        //find substituteNode and its parentNode        parentNodeOfSubstitutePtr = deleteNodePtr;        substituteNodePtr = deleteNodePtr->leftPtr;        //search down and right        while (substituteNodePtr->rightPtr != NULL)        {            parentNodeOfSubstitutePtr = substituteNodePtr;            substituteNodePtr = substituteNodePtr->rightPtr;        }        if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)        {            parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;        }        else        {            parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;        }        deleteNodePtr->data = substituteNodePtr->data;        deleteNodePtr = substituteNodePtr;    }    free(deleteNodePtr);}