資料結構之樹的一些基本操作

阿新 • • 發佈：2018-12-25

樹是由根結點和若干顆子樹構成的。樹是由一個集合以及在該集合上定義的一種關係構成的。集合中的元素稱為樹的結點，所定義的關係稱為父子關係。父子關係在樹的結點之間建立了一個層次結構。在這種層次結構中有一個結點具有特殊的地位，這個結點稱為該樹的根結點，或稱為樹根。
標頭檔案 tree.h

#ifndef __TREE_H__
#define __TREE_H__

#include "error.h"

struct _treeNode;                   // 結構體宣告

// 孩子結點連結串列的型別
typedef struct _childNode
{
    struct _treeNode * childNode;
    struct 
 _childNode* next;        // 指向孩子結點連結串列下一個元素
}ChildNode;

// 樹節點型別
typedef char TreeData;
typedef struct _treeNode
{
    TreeData data;
    struct _treeNode * parent;      // 指向父節點的指標
    struct _treeNode * next;        // 指向連結串列的下一個結點
    struct _childNode* childList;   // 孩子連結串列的頭節點
    int degree;                     // 結點的度 

}TreeNode;

typedef struct _tree
{
    struct _treeNode* head;         // 樹連結串列的頭節點
    int len;                        // 樹結點個數
}Tree;

// 定義一個函式指標型別
typedef void(*TreePrint)(TreeNode *node);

Tree* Create_Tree();

// pos 代表要插入結點父親結點的位置
// 約定：
// 1 新插入的結點插入在當前父親結點所有孩子的右邊
// 2 根節點的位置是 0
int Insert_Tree (Tree* tree, TreeData data, int 
 pos);

// 列印樹
void Display (Tree* tree, TreePrint pFunc);

// 刪除結點
int Delete (Tree* tree, int pos, TreeData *x);

// 求指定位置樹結點的值
int Tree_Get (Tree* tree, int pos, TreeData *x);

// 清空樹中所有的節點
int Tree_Clear (Tree* tree);

// 樹的銷燬 
void Tree_Destroy   (Tree* tree);

// 獲取根節點的地址
TreeNode* Tree_Root (Tree* tree);

// 求樹的結點個數
int Tree_Count  (Tree* tree);

// 求樹的高度
int Tree_Height (Tree* tree);

// 求樹的度
int Tree_Degree (Tree* tree);

// 列印
void printA (TreeNode* node);

#endif  // __TREE_H__

原始檔 tree.c

#include "tree.h"
#include <stdlib.h>

Tree *Create_Tree()
{
    // 建立樹節點
    Tree* tree = (Tree*) malloc(sizeof(Tree)/sizeof(char));
    if (NULL == tree)
    {
        errno = MALLOC_ERROR;
        return NULL;
    }

    // 給樹結點連結串列建立頭節點
    tree->head = (TreeNode*) malloc(sizeof(TreeNode)/sizeof(char));
    if (NULL == tree->head)
    {
        errno = MALLOC_ERROR;
        free (tree);
        return NULL;
    }

    tree->head->parent    = NULL;
    tree->head->childList = NULL;
    tree->head->next      = NULL;   // 代表樹中沒有結點

    // 空樹結點為0
    tree->len = 0;

    return tree;
}

int Insert_Tree (Tree* tree, TreeData data, int pos)
{
    if (NULL == tree || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (pos != 0 && tree->len == pos)
    {
        errno = ERROR;
        return FALSE;
    }

    // 新建結點
    TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode)/sizeof(char));
    if (NULL == node)
    {   
        errno = MALLOC_ERROR;
        return FALSE;
    }

    node->data = data;
    node->next = NULL;

    // 建立該新節點的孩子結點連結串列的頭節點
    node->childList = (ChildNode*) malloc(sizeof(ChildNode)/sizeof(char));
    if (NULL == node->childList)
    {   
        errno = MALLOC_ERROR;
        free (node);
        return FALSE;
    }   
    node->childList->next      = NULL;
    node->childList->childNode = NULL;

    node->degree = 0;

    int i;
    // 找父節點
    TreeNode* parent = tree->head->next;     // 當前樹節點的第一個結點
    for (i = 0; i < pos; i++)
    {
        parent = parent->next;
    }
    node->parent = parent; 

    // 在父親結點的子結點連結串列中加入一個結點
    if (parent != NULL)
    {
        // 建立一個孩子結點
        ChildNode* childnode = (ChildNode*) malloc(sizeof(ChildNode)/sizeof(char));
        if (NULL == childnode)
        {
            errno = MALLOC_ERROR;
            free (node->childList);
            free (node);
            return FALSE;
        }
        childnode->childNode = node;
        childnode->next      = NULL;

        // 加入到父親結點子結點連結串列當中
        ChildNode* tmp = parent->childList;   // 子結點連結串列的頭節點
        while (tmp->next)
        {   
            tmp = tmp->next;
        }
        tmp->next = childnode;
        parent->degree += 1;
    }

    TreeNode* tmp = tree->head;              // 樹節點連結串列的頭節點
    while (tmp->next)
    {
        tmp = tmp->next;
    }
    tmp->next = node;
    tree->len += 1;

    return TRUE;
}

// 遞迴列印結點
void r_display (TreeNode* node, int gap, TreePrint pFunc)
{
    if (NULL == node)
    {
        return;
    }

    // 列印距離前一個結點的距離
    int i;
    for (i = 0; i < gap; i++)
    {
        printf ("%c", '-');
    }

    // 列印結點自己
    // printf ("%c\n", node->data);
    pFunc (node);

    ChildNode* child = node->childList->next; // 該結點的第一個孩子
    // 列印該結點的孩子
    while (child)
    {
        r_display (child->childNode, gap+4, pFunc);
        child = child->next;  // 下一個孩子
    }
}

void Display (Tree *tree, TreePrint pFunc)
{
    if (NULL == tree)
    {
        return;
    }

    r_display (tree->head->next, 0, pFunc);
}

void r_delete (Tree *tree, TreeNode *node)
{
    if (NULL == tree || NULL == node)
        return;

    // 從樹連結串列中移除這個結點,找node的前一個結點
    TreeNode* tmp = tree->head;  // 連結串列的頭節點
    while (tmp->next)
    {
        if (tmp->next == node)
        {
            tmp->next = node->next;
            tree->len--;
            break;
        }
        tmp = tmp->next;
    }

    // 將父親結點中子結點連結串列中指向node的結點刪除
    TreeNode* parent = node->parent;
    if (NULL != parent)
    {
        ChildNode* tmp = parent->childList;  // 子結點連結串列的頭節點
        while (tmp->next)
        {
            if (tmp->next->childNode == node)
            {
                ChildNode* p = tmp->next;
                tmp->next    = p->next;
                free (p);
                parent->degree--;
                break;
            }
            tmp = tmp->next;
        }
    }

    // 將該結點的孩子結點刪掉
    ChildNode* child = node->childList->next; 
    // 子結點連結串列中的第一個結點
    while (child)
    {
        ChildNode* pchild = child->next;
        r_delete (tree, child->childNode);
        child  = pchild;
    }

    free (node->childList);
    free (node);
}

int Delete (Tree *tree, int pos, TreeData *x)
{
    if (NULL == tree || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (0 != pos && tree->len == pos)
    {
        errno = ERROR;
        return FALSE;
    }

    int i;
    // 找結點
    TreeNode* current = tree->head->next;  
    for (i = 0; i < pos; i++)
    {
        current = current->next;
    }

    *x = current->data;

    r_delete (tree, current);

    return TRUE;

}

int Tree_Get (Tree* tree, int pos, TreeData *x)
{
    if (NULL == tree || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (0 != pos && tree->len == pos)
    {
        errno = ERROR;
        return FALSE;
    }

    int i;
    // 找結點
    TreeNode* current = tree->head->next;  
    for (i = 0; i < pos; i++)
    {
        current = current->next;
    }

    *x = current->data;

    return TRUE;
}

int Tree_Clear (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    TreeData x;
    return Delete (tree, 0, &x);
}

void Tree_Destroy (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return;
    }

    Tree_Clear (tree);

    free (tree->head);
    free (tree);
}

TreeNode* Tree_Root (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return NULL;
    }

    return tree->head->next;
}

int Tree_Count (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    return tree->len;
}

// 遞迴求高度
int r_height (TreeNode* node)
{
    if (NULL == node)
    {
        return 0;
    }

    int subHeight = 0;
    int max       = 0;
    ChildNode* child = node->childList->next;
    while (child)
    {
        subHeight = r_height (child->childNode);
        if (subHeight > max)
        {
            max = subHeight;
        }
        child = child->next;
    }

    return max + 1;
}

int Tree_Height (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    int height = r_height (tree->head->next);

    return height;
}

// 遞迴求度
int r_degree (TreeNode* node)
{
    if (NULL == node)
    {
        return 0;
    }

    int max       = node->degree;
    int subDegree = 0;
    ChildNode* child = node->childList->next;
    while (child)
    {
        subDegree = r_degree (child->childNode);
        if (subDegree > max)
        {
            max = subDegree;
        }
        child = child->next;
    }

    return max;
}

int Tree_Degree (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    int degree = r_degree (tree->head->next);

    return degree;
}

void printA (TreeNode* node)
{
    printf ("%c\n", node->data);
}

主函式 main.c

#include <stdio.h>
#include "tree.h"



int main()
{
    Tree* tree = Create_Tree();
    if (NULL == tree)
    {
        myError ("Create_Tree");
        return -1;
    }

    Insert_Tree (tree, 'A', 0);
    Insert_Tree (tree, 'B', 0);
    Insert_Tree (tree, 'C', 0);
    Insert_Tree (tree, 'D', 0);
    Insert_Tree (tree, 'E', 1);
    Insert_Tree (tree, 'F', 1);
    Insert_Tree (tree, 'H', 3);
    Insert_Tree (tree, 'I', 3);
    Insert_Tree (tree, 'J', 3);
    Insert_Tree (tree, 'X', 3);
    Insert_Tree (tree, 'Z', 8);

    Display (tree, printA);

    //printf ("刪除B ：\n");
    TreeData x;
    //Delete(tree, 1, &x);
    //Display(tree, printA);

    printf ("height = %d\n", Tree_Height(tree));
    printf ("degree = %d\n", Tree_Degree(tree));
    return 0;
}

error.h是我自己寫的一個包含常見錯誤的標頭檔案，這裡我就不發了。

資料結構之樹的基本操作（java版本）

本部落格來自慕課網《資料結構探險之樹篇》，慕課網主講老師使用C++實現的，這裡我將其改為java實現，以下是對程式碼的幾點說明：二叉樹：所有節點的度都小於等於2二叉樹的遍歷：根據訪問根的順序：前序、中序、後序。二叉樹陣列實現：左孩子下標 = 父節點下標2 + 1;右孩子下標

資料結構之連結串列基本操作

涉及到單鏈表的基本操作有如下： int initList(linkList *);　　//初始化一個單鏈表，具有頭指標，頭結點，頭結點->next=NULL; int createListHead(linkList *, int n);　　//頭插法建立一個連

資料結構之棧的基本操作

本文章包括了棧的建立，初始化，入棧，出棧，清除，銷燬，大小等 +棧的應用（進位制轉換）棧的建立 typedef struct SqStack { ElemType *bottom;//棧底指標 ElemType *top;//棧頂指標 int stacksize;

資料結構之佇列的基本操作

本文章包括了佇列的初始化，插入元素，刪除元素等佇列結構體的建立 typedef struct { ElemType *base;//佇列儲存元素，也可用陣列代替 int front;//佇列頭部 int rear;//佇列尾部 }SqQueue; 佇列的初始化

資料結構之串的基本操作的實現（c語言）

我們先一起來看串的一些概念… 字串（簡稱串）,可以將其看作是種特殊的線性表，其特殊性在於線性表的資料元素的型別總是字元性，字串的資料物件約束為字符集。串是由０個或多個字元組成的有限序列。一般記作：s = “s1 s2 s3 …. sn”,，其中，s是串名

資料結構之串的基本操作

1.串的實現相比較而言簡單一些，但個人覺得有一些需要注意的地方，以下一一列舉：（1）串基本術語：空串：空串指長度為0的串，其不包含任何字元；空格串：不同於空串，它是由一個或多個空格構成的串。雖然是空格，但在計算長度時要把空格的個數算在內；串比較：串的大小比較時以字元的ASC

資料結構之堆的基本操作

在實現堆的操作之前，先來明白什麼是堆？堆中某個節點的值總是不大於或不小於其父節點的值堆總是一棵完全二叉樹。要說到完全二叉樹，直觀的判斷就是，層序遍歷一棵樹，如果樹的某個節點沒有右子樹或者是沒有子樹，那麼從這個節點後面的所有節點都不能夠有任何子樹。

資料結構之連結串列基本操作總結

題意：如何找到環的第一個節點？分析： 1）先判斷是否存在環使用兩個指標slow,fast。兩個指標都從表頭開始走，slow每次走一步，fast每次走兩步，如果fast遇到null，則說明沒有環，返回false；如果slow==fast，說明有環，並且此時fast超了s

資料結構之樹的一些基本操作

樹是由根結點和若干顆子樹構成的。樹是由一個集合以及在該集合上定義的一種關係構成的。集合中的元素稱為樹的結點，所定義的關係稱為父子關係。父子關係在樹的結點之間建立了一個層次結構。在這種層次結構中有一個結點具有特殊的地位，這個結點稱為該樹的根結點，或稱為樹根。標

資料結構之樹的操作

話不多少 q：690217293 歡迎交流 //_____________________________demo.cpp #include <cstdio> #include "Tree.h" #include <iostream> using

基本資料結構之樹、圖

一、二叉樹以下采用連結串列結構來實現上圖的二叉樹： #include <cstdlib> #include <iostream> using namespace std; struct mNode { int

數據結構之樹的基本概念、性質

sub 子集 blog 數據結構數據路徑層次葉子森林　　樹的定義：n個節點組成的有限集合。n=0，空樹；n>0,1個根節點，m個互不相交的有限集，每個子集為根的子樹。　　1、基本術語：　　節點的度：樹中某個節點的子樹的個數。　　樹的度：樹中各節點的度

C 資料結構中單鏈表基本操作

C中的typedef C中的typedef關鍵字作用是為一種資料型別定義一個新名字，這樣做的目的有兩個，一是給變數定義一個易記且意義明確的新名字，如： typedef unsigned char BYTE; 把unsigned char型別自命名為BYTE。另一個目的是

資料結構之樹（三十三）

我們在前面學習了排序相關的知識，從今天開始，我們來學習資料結構中樹的相關東西。那麼什麼是樹呢？樹是一種非線性的資料結構。 &

資料結構之樹結構

資料結構之樹結構樹結構：一種描述非線性層次關係的資料結構，其中重要的是樹的概念。樹：n個數據結點的集合，在該集合中包含一個根結點。根結點之下分佈著一些互不交叉的子集合，這些子集合也就是根結點的子樹。

資料結構之樹

樹相關的術語：節點：樹是由有限個元素組成的集合，每人元素都稱作一個節點，上圖A、B、 C、 D、 E、 F、G、H、I等都是樹的節點; 節點的度：一個節點含有的子樹的個數稱為該節點的度; 葉節點或終端節點：度為0的節點稱為葉節點，D,E,C,G都是葉節

資料結構：字串(堆)——基本操作

資料結構的重要行不言而喻，簡單介紹我在這部分遇到的一些問題，希望對大家有少許幫助。首先實現的多個操作：程式碼： #include<stdio.h> #include<stdlib.h> #include<string.h> #defi

資料結構-順序棧的基本操作的實現（含全部程式碼）

主要操作函式如下： InitStack(SqStack &s) 引數：順序棧s 功能：初始化時間複雜度O(1) Push(SqStack &s,SElemType e) 引數：順序棧s,元素e 功能：將e入棧時間複雜度:O(1)

資料結構-迴圈佇列的基本操作函式實現（含全部程式碼）

主要包含以下函式： InitQueue(SqQueue &Q) 引數：迴圈佇列Q 功能：初始化迴圈佇列Q 時間複雜度：O(1) QueueEmpty(SqQueue Q) 引數：迴圈佇列Q

資料結構-鏈隊的基本操作函式的實現（含全部程式碼）

主要包含以下函式： InitQueue(LinkQueue &Q) 引數：鏈隊Q 功能：初始化時間複雜度O(1) EnQueue(LinkQueue &Q,QElemType e) 引數：鏈隊Q,元素e 功能：將e入隊時間複雜度

資料結構之樹的一些基本操作

相關推薦