c語言實現二叉樹的插入、查詢、刪除、列印樹

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

目錄：

二叉樹的關鍵概念：

每個節點是一個自引用結構體，形式如下：

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);
}

c語言實現二叉樹的插入、查詢、刪除、列印樹

目錄：二叉樹的關鍵概念：每個節點是一個自引用結構體，形式如下： struct TreeNode { struct TreeNode *leftPtr; /* pointer to left subtree */

C語言實現二叉樹的插入和刪除

二叉樹的插入刪除：//首先介紹二叉樹的插入： //首先需要明白插入的規則：每個建好的結點p都需要從跟結點開始與根結點相比較資料域，如果根結點的資料域小於結點p，則接著將結點p與根結點的右子樹相比較，否則p將與根結點的左子樹相比較； //繼續往下類推，一直到最後

C語言實現二叉樹的基本操作---建立、遍歷、求深度、求葉子結點

#include <stdio.h> #include <stdlib.h> #include <malloc.h> typedefint ElemType;//資料型別 //定義二叉樹結構，與單鏈表相似，多了一個右孩子結點 typed

C語言實現二叉樹各種基本運算的演算法

包含如下函式： CreateBTree( BTNode * &b, char * str ) ：由括號表示串 str 創建二叉鏈b ； FindNode( BTNode * &b, ElemType x ) ：返回data域為 x的節

C語言實現二叉樹中統計葉子結點的個數&度為1&度為2的結點個數

演算法思想統計二叉樹中葉子結點的個數和度為1、度為2的結點個數，因此可以參照二叉樹三種遍歷演算法（先序、中序、後序）中的任何一種去完成，只需將訪問操作具體變為判斷是否為葉子結點和度為1、度為2的結點及統計操作即可。 #include <stdio.h> #include &

C語言實現二叉樹的建立&遍歷

演算法思想（重點是遞迴的使用）利用擴充套件先序遍歷序列建立二叉連結串列採用類似先序遍歷的遞迴演算法，首先讀入當前根結點的資料，如果是'.'則將當前樹根置為空，否則申請一個新結點，存入當前根結點的資料，分別用當前根結點的左子域和右子域進行遞迴呼叫，建立左、右子樹.

C語言實現二叉樹的基本操作

我在前面的部落格中講解了連結串列、棧和佇列，這些資料結構其實都是線性表，並且給出了詳細的實現。從今天開始，我們將要來學習樹，樹作為一種資料結構我們經常會用到，作為起步和基礎，我們先來實現二叉樹，也就是每個節點有不超過2個子節點的樹。對於樹的操作，最基本的建立、遍

C語言實現二叉樹的各種遍歷及求解深度

#include<stdio.h> #include<malloc.h> #define MAXSIZE 100 typedef char dataType; //二叉樹結構 typedef struct bnode{ dataType data; struct bnode *lC

資料結構之---C語言實現二叉排序樹（BinarySortTree）

wechat:812716131 ------------------------------------------------------ 技術交流群請聯絡上面wechat ----------------------------------------------

C語言實現二叉排序樹

二叉排序樹的插入規則：在二叉排序樹中插入新結點，要保證插入後的二叉樹仍符合二叉排序樹的定義。插入過程：若二叉排序樹為空，則待插入結點*S作為根結點插入到空樹中；當非空時，將待插結點關鍵字S->key和樹根關鍵字t->key進行

C語言實現二叉排序樹的基本運算演算法

二叉排序樹的建立、查詢和刪除過程及其演算法設計。（1）由關鍵字序列（4,9,0,1,8,6,3,5,2,7）建立一棵二叉排序樹bt並以括號表示法輸出；（2）判斷bt是否為一棵二叉排序樹；（3）採用遞迴和非遞迴兩種方法查詢關鍵字6的節點，並輸出其查詢路徑；（4）分別刪

c語言實現二叉樹的遍歷和建立程式（附帶註釋）

/******************************************************************/ //樹的遞迴思想，把每個節點當作是一棵樹，以後序遍歷為例 //步驟1：訪問左子樹.2訪問右子樹3.列印當前節點的值 //在節點遍歷時如果

c語言實現二叉樹（二叉連結串列）非遞迴後序遍歷

演算法思想因為後序遍歷是先訪問左子樹，再訪問右子樹，最後訪問根節點。當用棧實現遍歷時，必須分清返回根節點時，是從左子樹返回的還是從右子樹返回的。所以使用輔助指標r指向最近已訪問的結點。當然也可以在節點中增加一個標誌域，記錄是否已被訪問。 #include<iost

c語言實現二叉樹的基本操作--二叉連結串列儲存

利用二叉連結串列儲存，並且利用遞迴的方法實現二叉樹的遍歷（前序遍歷、中序遍歷和後續遍歷）操作。 c語言具體實現程式碼如下： #include<stdio.h> #include<stdlib.h> #include<malloc.h>

c語言實現二叉樹常用演算法

構造二叉樹結點結構 typedef struct BT { char data; struct BT *l_chrild; struct BT *r_chrild; }BT; 建立二叉樹 BT* Create_tree()//

c語言實現二叉樹的先序遍歷，中序遍歷，後序遍歷

// new.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <MEMORY.H> #include <STRING.H&

C語言實現二叉查詢樹（BST）的基本操作

我們在上一篇部落格中講解了二叉樹，這一次我們來實現二叉樹的進階——二叉查詢樹（Binary Search Tree），又稱二插排序樹(Binary Sort Tree)。所以簡稱為BST。二插查詢樹的定義如下：1.若左子樹不為空，則左子樹上所有節點的值均小於它的根節

資料結構之---C語言實現二叉樹的順序儲存

//二叉樹的順序儲存 //這裡利用迴圈佇列儲存資料 //楊鑫 #include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> #defi

用C語言實現二叉樹的結構和常用操作

#include<stdio.h> #include <stdlib.h> typedef float ElemType; typedef struct S_BiTNode//定義結點型別結構體 { ElemType data;//資料域 str

C語言實現二叉查詢樹的輸出

二叉樹是資料結構和演算法中的重要部分。本文將簡單介紹其中的一類——二叉查詢樹：二叉排序樹（BinarySortTree），又稱二叉查詢樹、二叉搜尋樹。它或者是一棵空樹；或者是具有下列

c語言實現二叉樹的插入、查詢、刪除、列印樹

二叉樹的關鍵概念：

二叉樹的插入

二叉樹的查詢

二叉樹的刪除

二叉樹的列印

測試結果截圖

測試插入、刪除、列印樹原始碼

相關推薦