2. 程式人生 > >數據結構——樹

數據結構——樹

阿新 • • 發佈：2017-12-08
最大 可以轉化 應用 csdn 根節點 std sig 祖先 pop

1、樹的相關定義

（1）樹：包含n（n>0）個節點的有窮集合，其中每個元素稱為節點（node）；有一個特定的節點被稱為根節點或樹根（root）；除根節點之外的其余數據元素被分為m（m≥0）個互不相交的結合T1，T2，……Tm-1，而其中每一個集合Ti（1<=i<=m）本身也是一棵樹，被稱作原樹的子樹（subtree）。

（2）節點的度：一個節點含有的子樹的個數稱為該節點的度；

（3）樹的度：一棵樹中，最大的節點的度稱為樹的度；

（4）葉節點或終端節點：度為零的節點稱為葉節點；

（5）分支節點或非終端節點：度不為零的節點；

（6）父節點或雙親節點：若一個結點含有子節點，則這個節點稱為其子節點的父節點；

（7）子節點或孩子節點：一個節點含有的子樹的根節點稱為該節點的子節點；

（8）兄弟節點：具有相同父節點的節點互稱為兄弟節點；

（9）節點的祖先：從根到該節點所經分支上的所有節點；

（10）子孫：以某節點為根的子樹中任一節點都稱為該節點的子孫。

（11）節點的層次：從根開始定義起，根為第1層，根的子結點為第2層，以此類推；

（12）樹的深度或高度：定義一棵樹的根結點層次為1，其他節點的層次是其父結點層次加1。一棵樹中所有結點的層次的最大值稱為這棵樹的深度。

（13）森林：由m（m>=0）棵互不相交的樹的集合稱為森林；

2、樹的特點

（1）每個節點有零個或多個子節點。

（2）每個子節點只有一個父節點。

（3）沒有父節點的節點稱為根節點。

3、樹的分類

根據形態可以分為以下兩種：

（1）二叉樹

  • 滿二叉樹
  • 完全二叉樹
  • 斜樹

（2）多叉樹

還有其他根據應用特性而命名的樹，比如線索二叉樹、平衡二叉樹、二叉排序樹、多路查找樹（2-3樹、2-3-4樹、B樹、B+樹等）、最小生成樹等，本質是上述兩種類型。

4、樹的特點和性質

由於實際中二叉樹用得最多，而且多叉樹可以轉化成二叉樹，因此主要講二叉樹的性質。

性質1：在二叉樹的第i層上，至多有2^（i-1）個節點。

性質2：深度為k的二叉樹，至多有2^k-1個節點。

性質3：對任何的一顆二叉樹，如果其終端節點（葉子節點）數為n0，度為2的節點數為n2，則有n0=n2+1。

性質4：具有n個節點的完全二叉樹的深度為 [ log2(n) ]+1（[ x ]表示不大於x的最大整數）。

性質5：有n個節點的完全二叉樹，從第一層到[ log2(n) ]+1層，每層從左到右編號，對任一節點i，如果i=1，則是二叉樹的根；如果i>1，則 [ i / 2 ]是其父節點；如果2i>n，則i無左孩子，否則其左孩子是2i；如果2i+1>n，則節點無右孩子，否則右孩子是2i+1。

5、樹的表示（存儲結構）

由於實際中二叉樹用得最多，而且多叉樹可以轉化成二叉樹，因此主要講二叉樹的存儲結構，即如何表示二叉樹結構，和創建實際的二叉樹。這裏有幾種表示方法：

（1）孩子兄弟表示法：每個節點設置兩個指針，分別指向該節點的第一個孩子和此節點的兄弟。

[cpp] view plain copy
  1. typedef struct TreeNode
  2. {
  3. int data;
  4. //other data information
  5. struct TreeNode *fisrtchild;
  6. struct TreeNode *BrotherNode;
  7. }node;


（2）子節點表示法；

（3）父節點表示法；

6、樹的操作與用途

（1）遍歷二叉樹，如前序、後序、中序遍歷（並推導遍歷結果）；

（2）對樹進行節點的刪減和添加；

（3）運用於查找（平衡二叉樹、多路查找樹），排序（（堆）排序等）等；

二叉樹順序結構實現

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存儲空間初始分配量 */
#define MAX_TREE_SIZE 100 /* 二叉樹的最大結點數 */

typedef int Status;        /* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */
typedef int TElemType;  /* 樹結點的數據類型，目前暫定為整型 */
typedef TElemType SqBiTree[MAX_TREE_SIZE]; /* 0號單元存儲根結點  */

typedef struct
{
    int level,order; /* 結點的層,本層序號(按滿二叉樹計算) */
}Position;

TElemType Nil=0; /*  設整型以0為空 */

Status visit(TElemType c)
{
    printf("%d ",c);
    return OK;
}

/* 構造空二叉樹T。因為T是固定數組，不會改變，故不需要& */
Status InitBiTree(SqBiTree T)
{
    int i;
    for(i=0;i<MAX_TREE_SIZE;i++)
        T[i]=Nil; /* 初值為空 */
    return OK;
}

/* 按層序次序輸入二叉樹中結點的值(字符型或整型), 構造順序存儲的二叉樹T */
Status CreateBiTree(SqBiTree T)
{ 
    int i=0;
     printf("請按層序輸入結點的值(整型)，0表示空結點，輸999結束。結點數≤%d:\n",MAX_TREE_SIZE);
    while(i<10)
    {
        T[i]=i+1;
        
        if(i!=0&&T[(i+1)/2-1]==Nil&&T[i]!=Nil) /* 此結點(不空)無雙親且不是根 */
        {
            printf("出現無雙親的非根結點%d\n",T[i]);
            exit(ERROR);
        }
        i++;
    }
    while(i<MAX_TREE_SIZE)
    {
        T[i]=Nil; /* 將空賦值給T的後面的結點 */
        i++;
    }

    return OK;
}

#define ClearBiTree InitBiTree /* 在順序存儲結構中，兩函數完全一樣 */

/* 初始條件: 二叉樹T存在 */
/* 操作結果: 若T為空二叉樹,則返回TRUE,否則FALSE */
Status BiTreeEmpty(SqBiTree T)
{ 
    if(T[0]==Nil) /* 根結點為空,則樹空 */
        return TRUE;
    else
        return FALSE;
}

/* 初始條件: 二叉樹T存在。操作結果: 返回T的深度 */
int BiTreeDepth(SqBiTree T)
{ 
   int i,j=-1;
   for(i=MAX_TREE_SIZE-1;i>=0;i--) /* 找到最後一個結點 */
     if(T[i]!=Nil)
       break;
   i++; 
   do
     j++;
   while(i>=powl(2,j));/* 計算2的j次冪。 */
   return j;
}

/* 初始條件: 二叉樹T存在 */
/* 操作結果:  當T不空,用e返回T的根,返回OK;否則返回ERROR,e無定義 */
Status Root(SqBiTree T,TElemType *e)
{ 
    if(BiTreeEmpty(T)) /* T空 */
        return ERROR;
    else
    {    
        *e=T[0];
        return OK;
    }
}

/* 初始條件: 二叉樹T存在,e是T中某個結點(的位置) */
/* 操作結果: 返回處於位置e(層,本層序號)的結點的值 */
TElemType Value(SqBiTree T,Position e)
{ 
     return T[(int)powl(2,e.level-1)+e.order-2];
}

/* 初始條件: 二叉樹T存在,e是T中某個結點(的位置) */
/* 操作結果: 給處於位置e(層,本層序號)的結點賦新值value */
Status Assign(SqBiTree T,Position e,TElemType value)
{ 
    int i=(int)powl(2,e.level-1)+e.order-2; /* 將層、本層序號轉為矩陣的序號 */
    if(value!=Nil&&T[(i+1)/2-1]==Nil) /* 給葉子賦非空值但雙親為空 */
        return ERROR;
    else if(value==Nil&&(T[i*2+1]!=Nil||T[i*2+2]!=Nil)) /*  給雙親賦空值但有葉子（不空） */
        return ERROR;
    T[i]=value;
    return OK;
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操作結果: 若e是T的非根結點,則返回它的雙親,否則返回＂空＂ */
TElemType Parent(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=1;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e) /* 找到e */
            return T[(i+1)/2-1];
    return Nil; /* 沒找到e */
}


/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操作結果: 返回e的左孩子。若e無左孩子,則返回＂空＂ */
TElemType LeftChild(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=0;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e) /* 找到e */
            return T[i*2+1];
    return Nil; /* 沒找到e */
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操作結果: 返回e的右孩子。若e無右孩子,則返回＂空＂ */
TElemType RightChild(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=0;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e) /* 找到e */
            return T[i*2+2];
    return Nil; /* 沒找到e */
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操作結果: 返回e的左兄弟。若e是T的左孩子或無左兄弟,則返回＂空＂ */
TElemType LeftSibling(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=1;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e&&i%2==0) /* 找到e且其序號為偶數(是右孩子) */
            return T[i-1];
    return Nil; /* 沒找到e */
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操作結果: 返回e的右兄弟。若e是T的右孩子或無右兄弟,則返回＂空＂ */
TElemType RightSibling(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=1;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e&&i%2) /* 找到e且其序號為奇數(是左孩子) */
            return T[i+1];
    return Nil; /* 沒找到e */
}

/* PreOrderTraverse()調用 */
void PreTraverse(SqBiTree T,int e)
{ 
    visit(T[e]);
    if(T[2*e+1]!=Nil) /* 左子樹不空 */
        PreTraverse(T,2*e+1);
    if(T[2*e+2]!=Nil) /* 右子樹不空 */
        PreTraverse(T,2*e+2);
}

/* 初始條件: 二叉樹存在 */
/* 操作結果: 先序遍歷T。 */
Status PreOrderTraverse(SqBiTree T)
{ 
    if(!BiTreeEmpty(T)) /* 樹不空 */
     PreTraverse(T,0);
    printf("\n");
    return OK;
}

/* InOrderTraverse()調用 */
void InTraverse(SqBiTree T,int e)
{ 
    if(T[2*e+1]!=Nil) /* 左子樹不空 */
        InTraverse(T,2*e+1);
    visit(T[e]);
    if(T[2*e+2]!=Nil) /* 右子樹不空 */
        InTraverse(T,2*e+2);
}

/* 初始條件: 二叉樹存在 */
/* 操作結果: 中序遍歷T。 */
Status InOrderTraverse(SqBiTree T)
{ 
    if(!BiTreeEmpty(T)) /* 樹不空 */
        InTraverse(T,0);
    printf("\n");
    return OK;
}

/* PostOrderTraverse()調用 */
void PostTraverse(SqBiTree T,int e)
{ 
    if(T[2*e+1]!=Nil) /* 左子樹不空 */
        PostTraverse(T,2*e+1);
    if(T[2*e+2]!=Nil) /* 右子樹不空 */
        PostTraverse(T,2*e+2);
    visit(T[e]);
}

/* 初始條件: 二叉樹T存在 */
/* 操作結果: 後序遍歷T。 */
Status PostOrderTraverse(SqBiTree T)
{ 
    if(!BiTreeEmpty(T)) /* 樹不空 */
        PostTraverse(T,0);
    printf("\n");
    return OK;
}

/* 層序遍歷二叉樹 */
void LevelOrderTraverse(SqBiTree T)
{ 
    int i=MAX_TREE_SIZE-1,j;
    while(T[i]==Nil)
        i--; /* 找到最後一個非空結點的序號 */
    for(j=0;j<=i;j++)  /* 從根結點起,按層序遍歷二叉樹 */
        if(T[j]!=Nil)
            visit(T[j]); /* 只遍歷非空的結點 */
    printf("\n");
}

/* 逐層、按本層序號輸出二叉樹 */
void Print(SqBiTree T)
{ 
    int j,k;
    Position p;
    TElemType e;
    for(j=1;j<=BiTreeDepth(T);j++)
    {
        printf("第%d層: ",j);
        for(k=1;k<=powl(2,j-1);k++)
        {
            p.level=j;
            p.order=k;
            e=Value(T,p);
            if(e!=Nil)
                printf("%d:%d ",k,e);
        }
        printf("\n");
    }
}


int main()
{
    Status i;
    Position p;
    TElemType e;
    SqBiTree T;
    InitBiTree(T);
    CreateBiTree(T);
    printf("建立二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    i=Root(T,&e);
    if(i)
        printf("二叉樹的根為：%d\n",e);
    else
        printf("樹空，無根\n");
    printf("層序遍歷二叉樹:\n");
    LevelOrderTraverse(T);
    printf("前序遍歷二叉樹:\n");
    PreOrderTraverse(T);
    printf("中序遍歷二叉樹:\n");
    InOrderTraverse(T);
    printf("後序遍歷二叉樹:\n");
    PostOrderTraverse(T);
    printf("修改結點的層號3本層序號2。");
    p.level=3;
    p.order=2;
    e=Value(T,p);
    printf("待修改結點的原值為%d請輸入新值:50 ",e);
    e=50;
    Assign(T,p,e);
    printf("前序遍歷二叉樹:\n");
    PreOrderTraverse(T);
    printf("結點%d的雙親為%d,左右孩子分別為",e,Parent(T,e));
    printf("%d,%d,左右兄弟分別為",LeftChild(T,e),RightChild(T,e));
    printf("%d,%d\n",LeftSibling(T,e),RightSibling(T,e));
    ClearBiTree(T);
    printf("清除二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    i=Root(T,&e);
    if(i)
        printf("二叉樹的根為：%d\n",e);
    else
        printf("樹空，無根\n");
    
    return 0;
}

鏈式結構實現

#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存儲空間初始分配量 */

typedef int Status;        /* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */

/* 用於構造二叉樹********************************** */
int index=1;
typedef char String[24]; /*  0號單元存放串的長度 */
String str;

Status StrAssign(String T,char *chars)
{ 
    int i;
    if(strlen(chars)>MAXSIZE)
        return ERROR;
    else
    {
        T[0]=strlen(chars);
        for(i=1;i<=T[0];i++)
            T[i]=*(chars+i-1);
        return OK;
    }
}
/* ************************************************ */

typedef char TElemType;
TElemType Nil=‘ ‘; /* 字符型以空格符為空 */

Status visit(TElemType e)
{
    printf("%c ",e);
    return OK;
}

typedef struct BiTNode  /* 結點結構 */
{
   TElemType data;        /* 結點數據 */
   struct BiTNode *lchild,*rchild; /* 左右孩子指針 */
}BiTNode,*BiTree;


/* 構造空二叉樹T */
Status InitBiTree(BiTree *T)
{ 
    *T=NULL;
    return OK;
}

/* 初始條件: 二叉樹T存在。操作結果: 銷毀二叉樹T */
void DestroyBiTree(BiTree *T)
{ 
    if(*T) 
    {
        if((*T)->lchild) /* 有左孩子 */
            DestroyBiTree(&(*T)->lchild); /* 銷毀左孩子子樹 */
        if((*T)->rchild) /* 有右孩子 */
            DestroyBiTree(&(*T)->rchild); /* 銷毀右孩子子樹 */
        free(*T); /* 釋放根結點 */
        *T=NULL; /* 空指針賦0 */
    }
}

/* 按前序輸入二叉樹中結點的值（一個字符） */
/* #表示空樹，構造二叉鏈表表示二叉樹T。 */
void CreateBiTree(BiTree *T)
{ 
    TElemType ch;
    
    /* scanf("%c",&ch); */
    ch=str[index++];

    if(ch==‘#‘) 
        *T=NULL;
    else
    {
        *T=(BiTree)malloc(sizeof(BiTNode));
        if(!*T)
            exit(OVERFLOW);
        (*T)->data=ch; /* 生成根結點 */
        CreateBiTree(&(*T)->lchild); /* 構造左子樹 */
        CreateBiTree(&(*T)->rchild); /* 構造右子樹 */
    }
 }

/* 初始條件: 二叉樹T存在 */
/* 操作結果: 若T為空二叉樹,則返回TRUE,否則FALSE */
Status BiTreeEmpty(BiTree T)
{ 
    if(T)
        return FALSE;
    else
        return TRUE;
}

#define ClearBiTree DestroyBiTree

/* 初始條件: 二叉樹T存在。操作結果: 返回T的深度 */
int BiTreeDepth(BiTree T)
{
    int i,j;
    if(!T)
        return 0;
    if(T->lchild)
        i=BiTreeDepth(T->lchild);
    else
        i=0;
    if(T->rchild)
        j=BiTreeDepth(T->rchild);
    else
        j=0;
    return i>j?i+1:j+1;
}

/* 初始條件: 二叉樹T存在。操作結果: 返回T的根 */
TElemType Root(BiTree T)
{ 
    if(BiTreeEmpty(T))
        return Nil;
    else
        return T->data;
}

/* 初始條件: 二叉樹T存在，p指向T中某個結點 */
/* 操作結果: 返回p所指結點的值 */
TElemType Value(BiTree p)
{
    return p->data;
}

/* 給p所指結點賦值為value */
void Assign(BiTree p,TElemType value)
{
    p->data=value;
}

/* 初始條件: 二叉樹T存在 */
/* 操作結果: 前序遞歸遍歷T */
void PreOrderTraverse(BiTree T)
{ 
    if(T==NULL)
        return;
    printf("%c",T->data);/* 顯示結點數據，可以更改為其它對結點操作 */
    PreOrderTraverse(T->lchild); /* 再先序遍歷左子樹 */
    PreOrderTraverse(T->rchild); /* 最後先序遍歷右子樹 */
}

/* 初始條件: 二叉樹T存在 */
/* 操作結果: 中序遞歸遍歷T */
void InOrderTraverse(BiTree T)
{ 
    if(T==NULL)
        return;
    InOrderTraverse(T->lchild); /* 中序遍歷左子樹 */
    printf("%c",T->data);/* 顯示結點數據，可以更改為其它對結點操作 */
    InOrderTraverse(T->rchild); /* 最後中序遍歷右子樹 */
}

/* 初始條件: 二叉樹T存在 */
/* 操作結果: 後序遞歸遍歷T */
void PostOrderTraverse(BiTree T)
{
    if(T==NULL)
        return;
    PostOrderTraverse(T->lchild); /* 先後序遍歷左子樹  */
    PostOrderTraverse(T->rchild); /* 再後序遍歷右子樹  */
    printf("%c",T->data);/* 顯示結點數據，可以更改為其它對結點操作 */
}


int main()
{
    int i;
    BiTree T;
    TElemType e1;
    InitBiTree(&T);

    
    StrAssign(str,"ABDH#K###E##CFI###G#J##");

    CreateBiTree(&T);

    printf("構造空二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    e1=Root(T);
    printf("二叉樹的根為: %c\n",e1);

    printf("\n前序遍歷二叉樹:");
    PreOrderTraverse(T);
    printf("\n中序遍歷二叉樹:");
    InOrderTraverse(T);
    printf("\n後序遍歷二叉樹:");
    PostOrderTraverse(T);
    ClearBiTree(&T);
    printf("\n清除二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    i=Root(T);
    if(!i)
        printf("樹空，無根\n");
    
    return 0;
}

數據結構——樹

相關推薦

數據結構——樹筆記1

其余 劃分 right class log 並且 否則 -1 尋找 樹屬於非線性數據結構，它是一種層次結構：如果存在前驅節點，則是唯一的，如果存在後繼節點，則可以是多個。即樹的元素之間是一對多的關系。樹是由n個節點構成的有限集合T，如果n = 0，則是空樹，如果n不等於0，

數據結構--樹

鏈式 底層 nbsp src one pan 方法 分享 完全二叉樹 1、樹的一些定義 　　1.1 樹 　　　　有且只有一個稱為根的節點； 　　　　有若幹個互不相交的子樹，這些子樹本身也是一棵樹。 　　　　 　　1.2 深度 從根節點到最底層節點的層數成為深度，根節

數據結構——樹

最大 可以轉化 應用 csdn 根節點 std sig 祖先 pop 1、樹的相關定義 （1）樹：包含n（n>0）個節點的有窮集合，其中每個元素稱為節點（node）；有一個特定的節點被稱為根節點或樹根（root）；除根節點之外的其余數據元素被分為m（m≥

ACM數據結構-樹狀數組

分享圖片 clu ace eof nan -a main printf quicksort 模板： int n; int tree[LEN]; int lowbit(int x){ return x&-x; } void update(int i,in

數據結構-樹

bubuko info img 完全 gpo 總數 節點 png 完全二叉樹 樹: 樹的一種鏈式存儲方法: 每個節點都有兩個指針, 一個指向下一層第一個結點, 一個指向右側兄弟結點; 二叉樹: 二叉樹是每個節點最多有兩個子樹的樹結構 概念: 度(結點的度):結

數據結構——樹的相關算法實現

std div 運行 data 左右子樹 blog etc 結構 post 二叉樹的基本算法 包括二叉樹的遍歷（先、中、後），二叉樹的層次，二叉樹的深度，二叉樹的葉子節點數計算。相關算法思想可以看書，這裏只是給出相關算法實現。 代碼實現 #include <stdio

[數據結構] 樹狀數組 的C程序實現

有用 binary 二分 樹狀 IT 數據結構 實現 特殊 turn int tree[100001];//樹狀數組,用於取區間[x,y]的數據的和 /* & 特殊運算，t&(-t)的值（十進制），就是t在2進制下，從右往左數第一個1出現的位置。 結

數據結構-樹狀數組（一）

stream owb 數組長度 using lan alt 存儲 單點 info 復習筆記：樹狀數組（一） 基本原理 樹狀數組，顧名思義，是一個存儲方式像樹一樣的數組。它只需要開和原數組一樣大小的內存，但是每個數的位置存的並不是每個數的原始值，而是像這樣： （引用自度

《數據結構 - 樹》概念

nbsp height utf-8 gre ont eight mage 最大 enc 一：樹 結構概念？ 　　- 樹(Tree) 是 n(n >= 0 ) 個結點的有限集合。 　　- n = 0 時，為空樹。 　　- 在任意一棵非空樹中 　　　　- 有且只有

第五章數據結構--樹--學習小結

後序 個性 -- 無法 高度 方法 一個 oid tro 這兩周我們主要學到了有關樹和二叉樹的用法，掌握了二叉樹的遍歷的基本操作，但是對一些具體題目來說，還是覺得有點難以上手。 樹的介紹 1. 樹的定義 樹是一種數據結構，它是由n（n>=1）個有限節點組成一個具

數據結構--Avl樹的創建，插入的遞歸版本和非遞歸版本，刪除等操作

pop end eem static cout 遞歸 sta div else AVL樹本質上還是一棵二叉搜索樹，它的特點是： 1.本身首先是一棵二叉搜索樹。 2.帶有平衡條件：每個結點的左右子樹的高度之差的絕對值最多為1（空樹的高度為-1）。 也就是說，AV

數據結構與算法第10周作業——二叉樹的創建和遍歷算法

技術分享 truct order traverse eof 結構 後序遍歷 lib void 一、二叉樹的創建算法（遞歸方式） 二、二叉樹的先序、中序和後序遍歷算法 #include<stdio.h>#include<stdlib.h>typedef

數據結構-第10周作業（二叉樹的創建和遍歷算法）

樹的創建 創建 -1 數據結構 二叉 分享 com jpg 遍歷算法 數據結構-第10周作業（二叉樹的創建和遍歷算法）

數據結構～Sqlserver索引使用的B樹

vsa pvs lol kff avs elk bin nmf eth1 B樹相關概念 在B-樹中查找給定關鍵字的方法是，首先把根結點取來，在根結點所包含的關鍵字K1,…,Kn查找給定的關鍵字（可用順序查找或二分查找法），若找到等於給定值的關鍵字，則查找成功；否則，一定可以

Chapter 3. 數據結構 線段樹

int 區間修改 lld ref else 如果 ios 正在 step Chapter 3. 數據結構 線段樹 Sylvia‘s I.單點修改，區間查詢. 模板： //單點修改 區間求和 //1操作 單點修改//2操作 區間求和 #include<c

【數據結構】二叉樹(c++)

public ear ren fontsize tree fault left reorder 個數 頭文件： #include <iostream> using namespace std; template<class Type> cl

3、非線性結構--樹與二叉樹——數據結構【基礎篇】

位置 enter 深度 基礎 表達式 左右 -a 基礎篇 先序遍歷 非線性結構--樹與二叉樹 二叉樹的基礎知識： 　　　　　　　　二叉樹的特點： 　　　　　　　　　　　　1、每個結點的度<=2 　　　　　　　　　　　　2、二叉樹是有序樹 　　　　　　　　二叉樹的五種不

數據結構學習筆記-排序/隊/棧/鏈/堆/查找樹/紅黑樹

算法 數據結構排序：插入排序：每次從剩余數據中選取一個最小的，插入已經排序完成的序列中合並排序：將數據分成左右兩組分別排序，然後合並，對每組數據的排序遞歸處理。冒泡排序：重復交換兩個相鄰元素，從a[1]開始向a[0]方向冒泡，然後a[2]...當a[i]無法繼續往前擠的時候說明前面的更小了，而且越往前越小(擠

java數據結構之三叉鏈表示的二叉樹

按層遍歷 postorder while ldl 字符串 param pub link 根節點 三叉鏈表示的二叉樹定義所畏的三叉鏈表示是指二叉樹由指向左孩子結點、右孩子結點、父親結點【三叉】的引用（指針）數據和數據組成。 package datastructure.t

並查集樹數據結構hdu1325

ret 兩個 方式 構造 ring flag cst tree out 我的解法就是去構造了一棵樹 以數組的存儲方式 數組的值存放節點的根。 排除空樹 剩下的就是出現環和多根節點的情況 也就是排除森林和有一個節點多個入度的情況 排除森林就用到了並查集 也就是