(树)-二叉树链表表示

1.二叉树新节点的插入:create(root,val) 

class node:
    def __init__(self):
        self.data = 0
        self.left = None
        self.right = None


def create(root, val):
    newnode = node()
    newnode.data = val
    newnode.left = None
    newnode.right = None
    if root == None:
        root = newnode
        return root

    current = root
    while current != None:
        parent = current
        if val < current.data:
            current = current.left
        else:
            current = current.right
    if parent.data > val:
        parent.left = newnode
    else:
        parent.right = newnode
    return root


data = [1, 7, 3, 4, 5, 2, 9, 11, 13, 15, 12]

root = None
for i in range(len(data)):
    root = create(root, data[i])

2.二叉树的删除

1)删除点为叶子节点,与之相连的父节点指向None

2)删除节点下只有1棵树:之间上提替换节点

3)有两棵树:1,中序遍历,左树最大者上提;2右树最小者上提。 

 

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用双亲-孩子链表表示法实现的各算法,和二叉树的转换算法的代码,包括主函数测试: ```c #include <stdio.h> #include <stdlib.h> #define MAX_TREE_SIZE 100 // 的最大结点数 #define MAX_QUEUE_SIZE 100 // 队列的最大容量 // 双亲-孩子链表结点结构体 typedef struct CTNode { int child; // 孩子结点的索引 struct CTNode *next; // 指向下一个孩子结点的指针 } CTNode, *ChildPtr; // 双亲-孩子链表头结点结构体 typedef struct { int data; // 结点数据 int parent; // 双亲结点的索引 ChildPtr firstChild; // 指向第一个孩子结点的指针 } CTBox; // 双亲-孩子链表结构体 typedef struct { CTBox nodes[MAX_TREE_SIZE]; // 结点数组 int r, n; // 根结点的索引和结点数 } CTree; // 初始化双亲-孩子链表 void InitTree(CTree *T) { int i; for (i = 0; i < MAX_TREE_SIZE; i++) { T->nodes[i].parent = -1; T->nodes[i].firstChild = NULL; } T->r = -1; T->n = 0; } // 向双亲-孩子链表中插入结点 void InsertNode(CTree *T, int i, int j) { ChildPtr p = (ChildPtr) malloc(sizeof(CTNode)); p->child = j; p->next = T->nodes[i].firstChild; T->nodes[i].firstChild = p; T->nodes[j].parent = i; T->n++; } // 遍历双亲-孩子链表 void TraverseTree(CTree *T) { int i, j; ChildPtr p; printf("Tree:\n"); for (i = 0; i < T->n; i++) { printf("%d: %d -> ", i, T->nodes[i].data); p = T->nodes[i].firstChild; while (p != NULL) { j = p->child; printf("%d -> ", T->nodes[j].data); p = p->next; } printf("NULL\n"); } } // 双亲-孩子链表转换为二叉树 void CTreeToBiTree(CTree *T, int i, int *j, BiTree *p) { ChildPtr q; int k; q = T->nodes[i].firstChild; if (q == NULL) { *p = NULL; } else { CTreeToBiTree(T, q->child, &k, p); *j = k; while (q->next != NULL) { q = q->next; CTreeToBiTree(T, q->child, &k, &((*p)->rchild)); (*p)->rchild = (k == -1) ? NULL : (BiTree) k; } } } // 二叉树转换为双亲-孩子链表 void BiTreeToCTree(BiTree T, int i, int *j, CTree *p) { if (T == NULL) { *j = -1; } else { p->nodes[i].data = T->data; p->nodes[i].parent = -1; (*j)++; BiTreeToCTree(T->lchild, *j, j, p); if (*j != -1) { InsertNode(p, i, *j); } BiTreeToCTree(T->rchild, *j, j, p); } } // 层序遍历二叉树 void LevelOrderTraverse(BiTree T) { BiTree Q[MAX_QUEUE_SIZE]; int front = 0, rear = 0; if (T != NULL) { Q[++rear] = T; } while (front != rear) { BiTree p = Q[++front]; printf("%d ", p->data); if (p->lchild != NULL) { Q[++rear] = p->lchild; } if (p->rchild != NULL) { Q[++rear] = p->rchild; } } printf("\n"); } int main() { CTree T; BiTree B; int j = -1; InitTree(&T); T.r = 0; T.n = 10; T.nodes[0].data = 0; T.nodes[1].data = 1; T.nodes[2].data = 2; T.nodes[3].data = 3; T.nodes[4].data = 4; T.nodes[5].data = 5; T.nodes[6].data = 6; T.nodes[7].data = 7; T.nodes[8].data = 8; T.nodes[9].data = 9; InsertNode(&T, 0, 1); InsertNode(&T, 0, 2); InsertNode(&T, 1, 3); InsertNode(&T, 1, 4); InsertNode(&T, 2, 5); InsertNode(&T, 3, 6); InsertNode(&T, 3, 7); InsertNode(&T, 5, 8); InsertNode(&T, 5, 9); TraverseTree(&T); CTreeToBiTree(&T, 0, &j, &B); printf("Binary Tree:\n"); LevelOrderTraverse(B); BiTreeToCTree(B, 0, &j, &T); TraverseTree(&T); return 0; } ``` 在该代码中,我们首先定义了双亲-孩子链表结点结构体 CTNode 和双亲-孩子链表头结点结构体 CTBox,然后定义了双亲-孩子链表结构体 CTree。在 InitTree 函数中,我们将中所有结点的双亲结点索引设置为 -1,孩子结点指针设置为 NULL,根结点的索引设置为 -1,结点数设置为 0。在 InsertNode 函数中,我们向中插入一个孩子结点,并建立孩子结点与双亲结点之间的关系。在 TraverseTree 函数中,我们遍历整个,输出每个结点的数据以及它的孩子结点。在 CTreeToBiTree 函数中,我们将双亲-孩子链表转换为二叉树,首先遍历的第一个孩子结点,得到它的索引 k,然后遍历它的兄弟结点,为每一个兄弟结点创建一个右孩子,并递归地将它的子转换为二叉树。在 BiTreeToCTree 函数中,我们将二叉树转换为双亲-孩子链表,首先为每个结点创建一个对应的双亲-孩子链表结点,并递归地将左子和右子插入到它们的双亲结点中。在 LevelOrderTraverse 函数中,我们使用队列实现层序遍历二叉树。最后,在主函数中,我们创建了一个双亲-孩子链表,并向其中插入一些结点,然后遍历该,将它转换为二叉树,输出二叉树,并将二叉树转换为双亲-孩子链表,输出双亲-孩子链表
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值