【数据结构】树与二叉树(廿六):树删除指定结点及其子树(算法DS)

文章目录

  • 5.3.1 树的存储结构
    • 5. 左儿子右兄弟链接结构
  • 5.3.2 获取结点的算法
    • 1. 获取大儿子、大兄弟结点
    • 2. 搜索指定数据域的结点
    • 3. 搜索给定结点的父亲
    • 4. 删除结点及其左右子树
      • a. 逻辑删除与物理删除
      • b. 算法DST
      • c. 算法解析
      • d. 代码实现
        • 递归释放树
        • 算法DS
      • e. 算法测试
    • 5. 代码整合

5.3.1 树的存储结构

5. 左儿子右兄弟链接结构

【数据结构】树与二叉树(十九):树的存储结构——左儿子右兄弟链接结构(树、森林与二叉树的转化)
  左儿子右兄弟链接结构通过使用每个节点的三个域(FirstChild、Data、NextBrother)来构建一棵树,同时使得树具有二叉树的性质。具体来说,每个节点包含以下信息:

  1. FirstChild: 存放指向该节点的大儿子(最左边的子节点)的指针。这个指针使得我们可以迅速找到一个节点的第一个子节点。
  2. Data: 存放节点的数据。
  3. NextBrother: 存放指向该节点的大兄弟(同一层中右边的兄弟节点)的指针。这个指针使得我们可以在同一层中迅速找到节点的下一个兄弟节点。

  通过这样的结构,整棵树可以用左儿子右兄弟链接结构表示成一棵二叉树。这种表示方式有时候被用于一些特殊的树结构,例如二叉树、二叉树的森林等。这种结构的优点之一是它更紧凑地表示树,而不需要额外的指针来表示兄弟关系。
在这里插入图片描述

   A
  /|\
 B C D
  / \
 E   F
A
|
B -- C -- D
     |
     E -- F

即:

      A
     / 
    B   
    \
	  C
  	 / \ 
  	E   D
  	 \
  	  F

在这里插入图片描述

5.3.2 获取结点的算法

1. 获取大儿子、大兄弟结点

【数据结构】树与二叉树(二十):树获取大儿子、大兄弟结点的算法(GFC、GNB)

2. 搜索指定数据域的结点

【数据结构】树与二叉树(廿四):树搜索指定数据域的结点(算法FindTarget)

3. 搜索给定结点的父亲

【数据结构】树与二叉树(廿五):树搜索给定结点的父亲(算法FindFather)

4. 删除结点及其左右子树

a. 逻辑删除与物理删除

  • 逻辑删除(Logical Deletion)
    • 逻辑删除通常是指在数据结构中标记某个节点为被删除的状态,而不是真正地从内存中删除它。
  • 物理删除(Physical Deletion)
    • 物理删除是指真正地从内存中释放某个节点及其子树的内存。

b. 算法DST

在这里插入图片描述

c. 算法解析

  1. 检查输入参数t和p是否为空,如果其中任一参数为空,则返回。

  2. 调用FindFather(t, p.result)函数,找到以t为根的树中根为p的子树的父节点

  3. 如果找不到父节点(即result为空),则表示根为p的子树不存在,直接删除节点p并返回。

  4. 如果找到了父节点,算法继续执行,检查父节点的第一个子节点是否为p

    • 如果第一个子节点是p,则将父节点的第一个子节点设置为p的下一个兄弟节点(即FirstChild(result)←NextBrother( p)),然后删除节点p并返回。
    • 如果第一个子节点不是p,则算法使用一个循环找到p的下一个兄弟节点q,将q的下一个兄弟节点设置为p的下一个兄弟节点(即NextBrother(q)←NextBrother( p))。最后,删除节点p并返回。

d. 代码实现

递归释放树
void freeTree(TreeNode* root) {
    if (root != NULL) {
        freeTree(root->firstChild);
        freeTree(root->nextBrother);
        free(root);
    }
}
算法DS
void DelSubtree(TreeNode* t, TreeNode* p) {
    if (t == NULL || p == NULL) {
        return;
    }

    TreeNode* result = NULL;
    FindFather(t, p, &result);

    if (result == NULL) {
        return; // 未找到父亲节点
    }

    if (result->firstChild == p) {
        result->firstChild = p->nextBrother;
        freeTree(p);
        return;
    }

    TreeNode* q = result->firstChild;

    while (q != NULL && q->nextBrother != p) {
        q = q->nextBrother;
    }

    if (q != NULL) {
        q->nextBrother = p->nextBrother;
        freeTree(p);
    }
}

e. 算法测试

int main() {
    // 构建左儿子右兄弟链接结构的树
    TreeNode* A = createNode('A');
    TreeNode* B = createNode('B');
    TreeNode* C = createNode('C');
    TreeNode* D = createNode('D');
    TreeNode* E = createNode('E');
    TreeNode* F = createNode('F');

    A->firstChild = B;
    B->nextBrother = C;
    C->nextBrother = D;
    C->firstChild = E;
    E->nextBrother = F;

    // 要删除的子树的根节点
    TreeNode* subtreeRoot = F;

    // 使用算法 DelSubtree 删除子树
    DelSubtree(A, subtreeRoot);

    // 输出删除子树后的树结构
    printf("Tree after deleting subtree rooted at %c:\n", subtreeRoot->data);

    // 层次遍历算法
    printf("Level Order: \n");
    LevelOrder(A);
    printf("\n");

    // 释放树节点
    freeTree(A);

    return 0;
}



  • 继续采用先前系列文章的树结构
  • 删除指定结点subtreeRoot
  • 层次遍历删除subtreeRoot结点及其子树后的树
  • 释放整棵树
    在这里插入图片描述

5. 代码整合

#include 
#include 

// 定义树节点
typedef struct TreeNode {
    char data;
    struct TreeNode* firstChild;
    struct TreeNode* nextBrother;
} TreeNode;

// 创建树节点
TreeNode* createNode(char data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    if (newNode != NULL) {
        newNode->data = data;
        newNode->firstChild = NULL;
        newNode->nextBrother = NULL;
    }
    return newNode;
}

// 释放树节点及其子树
void freeTree(TreeNode* root) {
    if (root != NULL) {
        freeTree(root->firstChild);
        freeTree(root->nextBrother);
        free(root);
    }
}

// 算法GFC:获取大儿子结点
TreeNode* getFirstChild(TreeNode* p) {
    if (p != NULL && p->firstChild != NULL) {
        return p->firstChild;
    }
    return NULL;
}

// 算法GNB:获取下一个兄弟结点
TreeNode* getNextBrother(TreeNode* p) {
    if (p != NULL && p->nextBrother != NULL) {
        return p->nextBrother;
    }
    return NULL;
}


// 队列结构
typedef struct QueueNode {
    TreeNode* treeNode;
    struct QueueNode* next;
} QueueNode;

typedef struct {
    QueueNode* front;
    QueueNode* rear;
} Queue;

// 初始化队列
void initQueue(Queue* q) {
    q->front = NULL;
    q->rear = NULL;
}

// 入队列
void enqueue(Queue* q, TreeNode* treeNode) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->treeNode = treeNode;
    newNode->next = NULL;

    if (q->rear == NULL) {
        q->front = newNode;
        q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

// 出队列
TreeNode* dequeue(Queue* q) {
    if (q->front == NULL) {
        return NULL; // 队列为空
    }

    TreeNode* treeNode = q->front->treeNode;
    QueueNode* temp = q->front;

    q->front = q->front->next;
    free(temp);

    if (q->front == NULL) {
        q->rear = NULL; // 队列为空
    }

    return treeNode;
}

// 层次遍历的算法
void LevelOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }

    Queue queue;
    initQueue(&queue);

    enqueue(&queue, root);

    while (queue.front != NULL) {
        TreeNode* p = dequeue(&queue);

        while (p != NULL) {
            // 访问当前结点
            printf("%c ", p->data);

            // 将大儿子结点入队列
            if (getFirstChild(p) != NULL) {
                enqueue(&queue, getFirstChild(p));
            }

            // 移动到下一个兄弟结点
            p = getNextBrother(p);
        }
    }
}

// 算法 FindFather
void FindFather(TreeNode* t, TreeNode* p, TreeNode** result) {
    *result = NULL;

    if (t == NULL || p == NULL || p == t) {
        return;
    }

    TreeNode* q = t->firstChild;

    while (q != NULL) {
        if (q == p) {
            *result = t;
            return;
        }

        FindFather(q, p, result);

        if (*result != NULL) {
            return;
        }

        q = q->nextBrother;
    }
}

// 算法 DelSubtree
void DelSubtree(TreeNode* t, TreeNode* p) {
    if (t == NULL || p == NULL) {
        return;
    }

    TreeNode* result = NULL;
    FindFather(t, p, &result);

    if (result == NULL) {
        return; // 未找到父亲节点
    }

    if (result->firstChild == p) {
        result->firstChild = p->nextBrother;
        freeTree(p);
        return;
    }

    TreeNode* q = result->firstChild;

    while (q != NULL && q->nextBrother != p) {
        q = q->nextBrother;
    }

    if (q != NULL) {
        q->nextBrother = p->nextBrother;
        freeTree(p);
    }
}


int main() {
    // 构建左儿子右兄弟链接结构的树
    TreeNode* A = createNode('A');
    TreeNode* B = createNode('B');
    TreeNode* C = createNode('C');
    TreeNode* D = createNode('D');
    TreeNode* E = createNode('E');
    TreeNode* F = createNode('F');

    A->firstChild = B;
    B->nextBrother = C;
    C->nextBrother = D;
    C->firstChild = E;
    E->nextBrother = F;

    // 要删除的子树的根节点
    TreeNode* subtreeRoot = F;

    // 使用算法 DelSubtree 删除子树
    DelSubtree(A, subtreeRoot);

    // 输出删除子树后的树结构
    printf("Tree after deleting subtree rooted at %c:\n", subtreeRoot->data);

    // 层次遍历算法
    printf("Level Order: \n");
    LevelOrder(A);
    printf("\n");

    // 释放树节点
    freeTree(A);

    return 0;
}

你可能感兴趣的:(数据结构,数据结构,算法,c语言,树,删除)