2. 程式人生 > >B樹的研究（查詢、插入、刪除）

B樹的研究（查詢、插入、刪除）

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

講到B樹那就不得不談一談查詢，查詢不是一種資料結構而是一種基於資料結構的對資料進行處理時經常使用的一種操作。平均查詢長度ASL=∑Pi×Ci (其中Pi為查詢第i個記錄的概率，Ci為查詢第i個記錄所用的比較次數)。 查詢方法有很多，分為兩大類：靜態查詢和動態查詢。

1、 靜態查詢：只能進行查詢操作，無法進行插入和刪除操作，表現為線性結構，有：順序儲存結構和鏈式儲存結構。主要有：順序查詢、二分查詢和索引查詢。
2、 動態查詢：既能插入和刪除，又能比較高效率的實現查詢操作，一般採用樹形連結串列等非線性結構，主要有：二叉排序樹、平衡二叉樹、紅黑樹、B樹、B+樹、tire樹。
（以下內容引用網路）


3、

紅黑樹：平衡二叉樹，通過對任何一條從根到葉子的簡單路徑上各個節點的顏色進行約束，確保沒有一條路徑會比其他路徑長2倍，因而是近似平衡的。所以相對於嚴格要求平衡的AVL樹來說，它的旋轉保持平衡次數較少。用於搜尋時，插入刪除次數多的情況下我們就用紅黑樹來取代AVL。
（現在部分場景使用跳錶來替換紅黑樹，可搜尋“為啥 redis 使用跳錶(skiplist)而不是使用 red-black？”）
4、 B樹，B+樹：它們特點是一樣的，是多路查詢樹，一般用於資料庫系統中，為什麼，因為它們分支多層數少，都知道磁碟IO是非常耗時的，而像大量資料儲存在磁碟中所以我們要有效的減少磁碟IO次數避免磁碟頻繁的查詢。B+樹是B樹的變種樹，有n棵子樹的節點中含有n個關鍵字，每個關鍵字不儲存資料，只用來索引，資料都儲存在葉子節點。是為檔案系統而生。
5、 Trie樹：又名單詞查詢樹，一種樹形結構，常用來操作字串。它是不同字串的相同字首只儲存一份。相對直接儲存字串肯定是節省空間的，但是它儲存大量字串時會很耗費記憶體（是記憶體）。類似的有字首樹(prefix
tree)，字尾樹(suffix tree)，radix tree(patricia tree, compact prefix
tree)，crit-bit tree（解決耗費記憶體問題），以及前面說的double array trie。

用階定義的B樹（國內代表：嚴蔚敏版）（m階B樹）：
1.樹中每個節點最多m個孩子，即m滿足[m/2]<=M<=m；
2．除根節點和葉子節點外，其他每個節點至少[m/2]個孩子；
3.除根節點外，（包括葉子節點）節點關鍵字數n需要滿足：[m/2]-1<=n<=m-1；

用度數定義的B樹（演算法導論版）（2T階B樹）：
1. B樹中每一節點包含關鍵字數有一上界和下界，此下界可用一稱作B樹的最小度數T表示；
2. 非根節點孩子數滿足：T到2T;
3. 非根節點關鍵字數滿足：T-1到2T-1;

樹高度：h<=logT*(n+1)/2, 時間複雜度為：O(logn).

B樹節點定義如下：

Typedef struct BTNode{
                Int n;          //關鍵字個數
                Bool isleaf;     //是否為葉子節點
                Int *keys;      //關鍵字陣列
                Struct BTNode **child;  //節點的孩子們
                Struct BTNode *p;}BTNode,*p_BTNode;  //節點的父節點

B樹查詢：
B樹查詢類似於二叉樹查詢但是B樹是進行N+1路分支的判斷，所以有所區別，具體程式碼如下：

BTNode*search(BTNode*curnode,int k,int &index)
{
        int i=0;
    While(i<=curnod->n&&k>curnode->keys[i])
    I++;
    If(i<curnode->n&&k==curnod->keys[i])
    {
        Index=i;
        Return curnod;}
    If (curnode->isleaf)

Return NULL;
Search(curnode->child[i],k,index)}

B樹插入（涉及分裂）
B樹插入操作是將關鍵字插入已存在的葉節點上，沿著根節點一直向下查詢，找到合適節點插入，若插入後節點已經滿了，即（2T階樹節點最多2T-1個關鍵字），故將n=2T-1分裂為兩個T-1個關鍵子的子節點，同時中間元素被提升至父節點，若父節點滿了，則進行迭代。
具體步驟：
1、 插入若樹空，則在葉子節點直接插入，否則非葉子節點，若該節點關鍵字數小於2T-1則插在該節點左邊或者右邊；
2、 若該節點關鍵字數為2T-1,則插入後分裂為2個T-1個關鍵字的子節點，且中間關鍵字上移至父節點（當然相應的指標也要發生改變）
3、 若2中使得父節點或根節點滿了，則根節點（父節點）也要分裂重複2使得各節點關鍵字滿足（T到2T-1）
(為了簡化演算法，採用從根節點往下查詢時，遇見關鍵字滿的節點，就進行分裂，這樣就保證了再次插入後，若節點分裂則父節點一定不為滿)

插入示例：
插入示例

B樹的刪除（涉及合併）（引用）

B樹的刪除操作比插入稍微複雜一些，因為關鍵詞 可以從任意節點中刪除
（包括內節點），刪除會導致節點含關鍵詞數目過少（小於t-1），所以可能需要進行合併。 B樹中從根節點至下刪除關鍵詞主要包括以下幾種情況（
最小度數為t ）。 1） 若關鍵詞k在節點x中且x為葉節點，則從x中刪除k； 2） 若關鍵詞k在節點x中且x為內節點，做以下操作：
a） 節點x中位於k之前或之後的子節點y至少有t個關鍵詞，則找出k在以y為根的子樹中的前驅或後繼k，遞迴刪除k並在x中用k`代替k；
b）
若節點x中位於k之前或之後的子節點y和z都只有t-1個關鍵詞，則將k和z中所有關鍵詞合併進y（使y有2t-1個關鍵詞），再刪除z節點，刪除k關鍵詞。
3） 若關鍵詞k不在內節點x中，並確定必包含k的子樹的根cx[i]，若cx[i]只有t-1個關鍵詞，則做以下操作： a）
若cx[i]的一個相鄰兄弟至少有t個關鍵詞，則將x中某關鍵詞降至cx[i]中，將cx[i]的相鄰兄弟節點的某關鍵詞提升至x，並修改指標；
b） 若cx[i]及其所有相鄰兄弟都只有t-1個關鍵詞，則將ci[x]與一個兄弟合併，即將x的一個關鍵詞移至新合併節點成為其中間關鍵詞。
一個包含以上情況的B樹刪除關鍵詞過程如下所示（最小度數t=2）：

刪除示例：
這裡寫圖片描述

使用說明

在本次實驗中，為了節省操作時間，偷了個懶，採用的是生成時間種子的方式，通過不斷的生成偽隨機數去構造一顆B樹，所以在實驗中，理論上不同的時間我們可以得到不同的B樹，同時，在刪除的過程中，只要相應的輸入需要刪除的關鍵字，就可以得到刪除後的新的B樹，有利於實驗過程的完整性。

執行示例：
這裡寫圖片描述
這裡寫圖片描述
這裡寫圖片描述

創新點：
為了能夠實現每次執行都能夠得到不同B樹，採用生成時間種子的辦法去生成偽隨機數來作為B樹的關鍵字來進行插入，同時，為了簡化在插入後遇到分裂操作需要反覆的調整父節點的關鍵字的個數，採用了一種簡化演算法，即從根節點往下查詢時，遇見關鍵字滿的節點，就先進行分裂，這樣就能夠保證再次插入關鍵字後，若遇見葉節點關鍵字滿而分裂時，父節點一定不為滿。

有待改進：
本次實驗的B樹查詢相對簡單，插入涉及到的分裂也還好，但是在刪除的過程中，因為涉及到的合併操作並不能夠完全符合要求，所以結論就是查詢和插入沒問題，刪除只適合低階B樹，鑑於精力有限，只能夠日後有時間再仔細的研究了。

（引用）實驗程式碼：（部分參考）

#include <stdio.h>
#include<time.h> 
#include<stdlib.h>
#include <iostream>    
#define  T 3 
using namespace std;  
typedef struct B_Tree_Node  //b樹節點定義 
{  
    int n;                         
    int *keys;                      
    bool isLeaf;                      
    struct B_Tree_Node **child ;      
    struct B_Tree_Node *p;           
}B_Tree_Node, *p_B_Tree_Node;  

B_Tree_Node *alloact_Node()       //b樹的初始化 
{  
    B_Tree_Node *newNode = new B_Tree_Node;  
    newNode->n = 0;  
    newNode->isLeaf = true;  
    newNode->keys = new int[2*T-1];  
    newNode->child = new p_B_Tree_Node[2*T];  
    newNode->p = NULL;  
    for(int i=0;i<2*T;i++)  
        newNode->child[i] = NULL;  
    return newNode;  
}  

B_Tree_Node * searchNode(B_Tree_Node *curNode, int k, int &index)  //關鍵字k的查詢,返回查詢資訊 
{  
    int i = 0;  
    while(i<=curNode->n && k >curNode->keys[i])   
        i++;  
    if(i<curNode->n && k == curNode->keys[i])  //找到了k  
    {  
        index = i;  
        return curNode;  
    }  
    if(curNode->isLeaf) //如果該結點是葉子結點，則k不存在  
        return NULL;  
    searchNode(curNode->child[i],k,index);  

}  

void BTree_Child_Split(B_Tree_Node *splitNode_p, int index_child)  //節點關鍵字滿了的情況，進行分裂 
{  
    B_Tree_Node *newChild = alloact_Node();  
    newChild->n = T-1;  
    for(int i = 0;i<T-1;i++)  
    {  
        newChild->keys[i] = splitNode_p->child[index_child]->keys[T+i];  
    }  
    splitNode_p->child[index_child]->n = T-1;  
    if(splitNode_p->child[index_child]->isLeaf!=true)  
    {  
        newChild->isLeaf = false;  
        for(int i=0;i<T-1;i++)  
            newChild->child[i] = splitNode_p->child[i+T];  
    }  
    for(int i = splitNode_p->n; i>=index_child;i--)  
    {  
        splitNode_p->child[i+1] = splitNode_p->child[i];  
    }  
    splitNode_p->n++;  
    splitNode_p->child[index_child+1] = newChild;  
    for(int i = splitNode_p->n-1; i>=index_child;i--)  
    {  
        splitNode_p->keys[i+1] = splitNode_p->keys[i];  
    }  
    splitNode_p->keys[index_child] = splitNode_p->child[index_child]->keys[T-1];  
}  

void BTree_Insert_NonFull(B_Tree_Node *nonfull, int k)  //插入節點關鍵字k 
{  
    int i = nonfull->n - 1;  
    if(nonfull->isLeaf)  
    {  
        while(i>=0&&k<nonfull->keys[i])  
        {  
            nonfull->keys[i+1] = nonfull->keys[i];  
            i--;  
        }  
        i = i+1;  
        (nonfull->n)++;  
        nonfull->keys[i] = k;  
    }  
    else  
    {  
        while(i>=0&&k<nonfull->keys[i])  
            i--;  
        i = i+1;  
        if(nonfull->child[i]->n == 2*T-1)  
        {  
            BTree_Child_Split(nonfull,i);  
            if(k>nonfull->keys[i])  
                i = i+1;  
        }  
        BTree_Insert_NonFull(nonfull->child[i],k);  
    }  
}  

void BTree_Insert_Node(p_B_Tree_Node *root,int k)  //若根節點滿了，呼叫分裂和插入函式 
{  
    B_Tree_Node *p = *root;  
    if(p->n == 2*T - 1)  
    {  
        B_Tree_Node *newRoot =alloact_Node();  
        newRoot->child[0] = (*root);  
        newRoot->isLeaf = false;  
        *root = newRoot;  

        BTree_Child_Split(newRoot,0);  
        BTree_Insert_NonFull(newRoot,k);  
    }  
    else   
        BTree_Insert_NonFull(*root,k);  
}  

void printBFS(B_Tree_Node *t)  //打印出該節點的關鍵字，且遞迴打出所有節點關鍵字 
{  
    if(NULL == t)  
        return;  
    cout << "\n【";  
    for(int i = 0;i < t->n;++i)  
    {  
        cout << t->keys[i];  
        if(t->n - 1 != i)  
            cout << " ";  
    }  
    cout << " 】" << endl;  
    for(int i = 0;i <= t->n;++i)  
        printBFS(t->child[i]);  

}  

void BTree_delete_key(B_Tree_Node *subNode, int k)  //刪除關鍵字k，涉及合併 
{  
    int index = 0;  
    B_Tree_Node *deleteNode = NULL;  
    if((deleteNode = searchNode(subNode,k,index)) == NULL)  
        return;  
    int keyIndex = -1;  
    for(int i=0;i<subNode->n;i++)  
    {  
        if(k == subNode->keys[i])  
        {  
            keyIndex = i;  
            break;  
        }  
    }  
    if(keyIndex != -1 && subNode->isLeaf)   //如果在當前結點，且當前結點為葉子結點，則直接刪除
    {  
        for(int i=keyIndex;i<subNode->n-1;i++)  
        {  
            subNode->keys[i] = subNode->keys[i+1];  
        }  
        (subNode->n)--;  
    }  

    else if(keyIndex != -1 && subNode->isLeaf!= true)   //如果在當前結點中，且當前結點不為葉子結點  
    {  
        B_Tree_Node *processorNode = subNode->child[keyIndex];  
        B_Tree_Node *succssorNode = subNode->child[keyIndex+1];  

        if(processorNode->n >= T)   //如果小於k的孩子結點關鍵字數大於T  
        {  
            int k1 = processorNode->keys[processorNode->n-1];  
            subNode->keys[keyIndex] = k1;  
            BTree_delete_key(processorNode,k1);  
        }  

        else if(succssorNode->n >=T)   //如果大於k的孩子結點關鍵字數大於T 
        {  
            int k1 = succssorNode->keys[0];  
            subNode->keys[keyIndex] = k1;  
            BTree_delete_key(succssorNode,k1);  
        }  

        else   //如果兩個孩子結點關鍵字數均不大於T,則將k與右孩子結點的關鍵字歸併到左孩子中  
        {  
            for(int j=0;j<T-1;j++)  
            {  
                processorNode->keys[processorNode->n] = k;  
                processorNode->keys[processorNode->n+1+j] = succssorNode->keys[j];  
            }  

            processorNode->n = 2*T -1 ;    
            if(!processorNode->isLeaf)  
            {  
                for(int j=0;j<T;j++)  
                {  
                    processorNode->child[T+j] = succssorNode->child[j];  
                }  
            }  

            for(int j = keyIndex;j<subNode->n-1;j++)   //修改subNode中的key值  
            {  
                subNode->keys[j] = subNode->keys[j+1];  
            }  
            subNode->n = subNode->n - 1;  
            delete succssorNode;  
            BTree_delete_key(processorNode,k);  


        }  

    }  
    else if(keyIndex == -1) //不在當前結點中  
    {  
        int childIndex = 0;  
        B_Tree_Node *deleteNode = NULL;  
        for(int j = 0;j<subNode->n;j++)     //尋找合適的子孩子，以該子孩子為根的樹包含k  
        {  
            if(k<subNode->keys[j])  
            {  
                childIndex = j;  
                deleteNode = subNode->child[j];  
                break;  
            }  
        }  
        if(deleteNode->n <= T-1)   //如果該子孩子的關鍵字數小於T,考慮那兩種情況  
        {  

            B_Tree_Node *LeftNode = subNode->child[childIndex-1];   //deleteNode的左兄弟結點  

            B_Tree_Node *RightNode = subNode->child[childIndex+1];   //deleteNode的右兄弟結點 

            if(childIndex>=1 && LeftNode->n >= T)   //如果左兄弟結點關鍵字數大於T,將父結點中的第childIndex-1個元素送給deleteNode,將Left中的最大元素送給父結點，  
            {  
                for(int i = deleteNode->n;i>0;i--)  
                {  
                    deleteNode->keys[i] = deleteNode->keys[i-1];  
                }  
                deleteNode->keys[0] = subNode->keys[childIndex];  
                subNode->keys[childIndex] = LeftNode->keys[LeftNode->n - 1];  
                (LeftNode->n)--;  
                (deleteNode->n)++;  
                BTree_delete_key(deleteNode,k);  
            }  
            else if(childIndex<subNode->n && RightNode->n >= T)              //如果右兄弟關鍵字大於T,將父結點中的第childIndex個元素送給deleteNode,將Right中的最小元素送給父結點，  
            {  
                deleteNode->keys[deleteNode->n] = subNode->keys[childIndex];  
                subNode->keys[childIndex] = RightNode->keys[0];  
                for(int i=0;i<RightNode->n-1;i++)  
                    RightNode[i] = RightNode[i+1];  
                (RightNode->n)--;  
                (deleteNode->n)++;  
                BTree_delete_key(deleteNode,k);  
            }  
            //如果左兄弟和右兄弟的關鍵字數均不在於T,則將左兄弟或右兄弟與其合併  
            else   
            {  
                if(childIndex>=1)//左兄弟存在，合併  
                {  
                    //將keys合併  
                    for(int i=0;i<deleteNode->n;i++)  
                    {  
                        LeftNode->keys[LeftNode->n+i] = deleteNode->keys[i];  
                    }  
                    //如果非葉子結點，則將葉子也合併  
                    if(!deleteNode->isLeaf)  
                    {  
                        for(int i=0;i<deleteNode->n+1;i++)  
                        {  
                            LeftNode->child[LeftNode->n+1+i] = deleteNode->child[i];  
                        }  

                    }  
                    LeftNode->n = LeftNode->n + deleteNode->n;  

                    //調整subNode的子節點  
                    for(int i = childIndex;i<subNode->n;i++)  
                    {  
                        subNode->child[i] = subNode->child[i+1];  
                    }  
                    BTree_delete_key(LeftNode,k);  
                }  
                else //合併它和右兄弟  
                {  
                    //將keys合併  
                    for(int i=0;i<RightNode->n;i++)  
                    {  
                        deleteNode->keys[i+deleteNode->n] = RightNode->keys[i];  
                    }  
                    //如果非葉子結點，則將葉子合併  
                    if(!deleteNode->isLeaf)  
                    {  
                        for(int i = 0;i<RightNode->n+1;i++)  
                        {  
                            deleteNode->child[deleteNode->n + 1 + i] = RightNode->child[i];  
                        }  
                    }  
                    deleteNode->n = deleteNode->n + RightNode->n;  

                    //調整subNode的子節點  
                    for(int i = childIndex+1;i<subNode->n;i++)  
                    {  
                        subNode->child[i] = subNode->child[i+1];  
                    }  
                    BTree_delete_key(deleteNode,k);  
                }  
            }  

        }  
        BTree_delete_key(deleteNode,k);  
    }  
}  

void createBTree(p_B_Tree_Node *root)  
{  
    int number;
    srand((unsigned)(time(NULL)));
    number=rand()%11;
    int a[number]; 
    for(int i = 0;i<number;i++)  
    {  a[i]=rand()%200;
        BTree_Insert_Node(root,a[i]);  
        printBFS(*root);  
    }  
}  


int main()  
{  
    int a;
    B_Tree_Node *root = alloact_Node();  
    createBTree(&root);  
  printf("你想刪除：");scanf("%d",&a);
    BTree_delete_key(root,a);  
    printBFS(root);  
    printf("你還想刪除：");scanf("%d",&a);
    BTree_delete_key(root,a);  
    printBFS(root);  
    printf("還想刪除：");scanf("%d",&a);
    BTree_delete_key(root,a);  
    printBFS(root);  
    printf("最後一個刪除：");scanf("%d",&a);
    BTree_delete_key(root,a);  
    printBFS(root);  

    return 0;  
}

相關推薦

單鏈表的基礎操作（頭插法、尾插法、插入和刪除）

一、連結串列的建立（頭插法和尾插法） 1、頭插法：把後建立的結點插在頭部。用這種方法建立起來的連結串列的實際順序與輸入順序剛好向反，輸出時為倒序！ 下面附上程式碼： struct node *headcreat() { struct node *p,*q,*head;

B樹的研究（查詢、插入、刪除）

講到B樹那就不得不談一談查詢，查詢不是一種資料結構而是一種基於資料結構的對資料進行處理時經常使用的一種操作。平均查詢長度ASL=∑Pi×Ci (其中Pi為查詢第i個記錄的概率，Ci為查詢第i個記錄所用的比較次數)。 查詢方法有很多，分為兩大類：靜態查詢和動態查詢

樹形索引（B-樹查詢、插入、刪除）

一、B-樹定義B-樹上每個節點包含多個關鍵碼從小到大排序，是一種平衡的多路查詢樹。最底層節點稱為外節點或葉結點，一般可省略。除了外結點，B-樹上的節點還有終端結點（葉結點的上一層）和非終端結點（終端結點

B樹的查詢、插入、刪除（附原始碼）

B-Tree Index B-Tree搜尋 B-Tree插入 分裂節點 插入節點 B-Tree刪除 合併節點 刪除節點 Basic B-Tree有兩個比較重要的性質： 所有的leaf均在同一個level上 除了root之外，其它所有node中所儲存的資料至少為Minimum

演算法導論 第十二章：二叉查詢樹 筆記（二叉查詢樹、查詢二叉查詢樹、插入和刪除、隨機構造的二叉查詢樹）

二叉查詢樹是一種樹資料結構，它與普通的二叉樹最大的不同就是二叉查詢樹滿足一個性質：對於樹中的任意一個節點，均有其左子樹中的所有節點的關鍵字值都不大於該節點的關鍵字值，其右子樹中的任意一個節點的關鍵字值都不小於該節點的關鍵字值。 在二叉查詢樹上可以進行搜尋、取最小值、取最大值、取指定節點的前驅

【學習筆記】平衡二叉樹（AVL樹）簡介及其查詢、插入、建立操作的實現

  目錄 平衡二叉樹簡介： 各種操作實現程式碼：   詳細內容請參見《演算法筆記》P319 初始AVL樹，一知半解，目前不是很懂要如何應用，特記錄下重要內容，以供今後review。   平衡二叉樹簡介： 平衡二叉樹由兩位前

二叉搜尋樹的查詢、插入與刪除操作（Binary Search Tree, Search, Insert, Delete）（C++）

一、概念     設 x 是二叉搜尋樹中的一個結點。如果 y 是 x 左子樹中的一個結點，那麼 y.key ≦ x.key。如果 y 是 x 右子樹中的一個結點，那麼 y.key ≧ x.key。  

二叉查詢樹的查詢、插入、刪除、釋放等基本操作的實現（C語言）

二叉查詢樹是一種特殊性質的二叉樹，該樹中的任何一個節點，它的左子樹（若存在）的元素值小於節點的元素值，右子樹（若存在）的元素值大於節點的元素值。 實現了二叉樹查詢樹的實現以及基本操作，包括查詢、插入、刪除、初始化、釋放等。 原始碼下載地址：http://download.c

二叉查詢樹（二叉排序樹）建立、插入、刪除、查詢-C語言

二叉查詢樹：或者是一顆空樹；或者是具有以下性質的二叉樹：（1）若它的左子樹不為空，則左子樹上所有結點的值都小於根結點的值；（2）若它的右子樹不為空，則右子樹所有結點的值均大於它的根結點的值；（3）左右子樹分別為二叉查詢樹； #include <std

二叉搜尋樹Java實現（查詢、插入、刪除、遍歷）

1 class Node { 2 int key; 3 int value; 4 Node leftChild; 5 Node rightChild; 6 7 public Node(int key, int value) { 8

資料結構與演算法：B樹（B-Tree）定義及搜尋、插入、刪除基本操作

B樹（B-Tree） 在介紹什麼是B樹（B-Tree）之前，先看看為什麼存在B樹結構？ B樹（B-Tree）是為磁碟或者其他輔助儲存裝置而設計的一種平衡搜尋樹，如有的資料庫系統使用B樹或者B樹的變種來儲存資訊。B樹的節點可以有很多孩子，從數個到數千個，不同於一

平衡二叉樹的C語言實現（建立、插入、查詢、刪除、旋轉）【資料結構】

平衡二叉樹(AVL)或者是一顆空樹，或者是具有下列性質的非空二叉搜尋樹： (1). 任一結點的左、右子樹均為AVL樹； (2). 任一結點的左、右子樹高度差的絕對值不超過1。 對於二叉樹中任一結點T，其“平衡因子”(Balance Factor, BF)定義為BF(T)

二叉排序樹的操作（建立、插入、刪除和查詢）

二叉排序樹的建立、插入、刪除和查詢 #include <stdio.h> #include <stdlib.h> typedef struct node { int key; struct node *lchild,*rchild

二叉排序樹（Binary Sort Tree）查詢、插入、刪除 Java實現

順序儲存的插入和刪除可以通過在表末端插入和刪除元素同最後一個元素互換來保持高效率，但是無序造成查詢的效率很低。 如果查詢的資料表是有序線性表，並且是順序儲存的，查詢可以折半、插值、斐波那契等查詢演算法來實現，但是因為有序在插入和刪除操作上，就需要耗費大量時間。 二叉排序樹可

（二叉樹）二叉搜尋樹的查詢、插入和刪除

1.二叉搜尋樹簡介 二叉搜尋樹或者是一棵空樹，或者是具有下列性質的二叉樹： 若它的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； 若它的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值； 它的左、右子樹也分別為二叉搜尋樹。二叉搜尋樹的特點之一即是其中序遍歷為升序。 2

二叉排序樹（查詢、插入、刪除）

“二叉排序樹，又稱為二叉查詢樹。它或者是一顆空樹，或者具有下列性質的二叉樹。 若它的左子樹不空，則左子樹上所有節點的值均小於它的根節點的值； 若它的右子樹不空，則右子樹上所有節點的值均大於它的根節點的值； 它的左、右子樹也分別為二叉排序樹。 構造一顆二叉排序樹的目的，

【資料結構樹表的查詢】二叉排序樹詳解和程式碼（生成、插入、查詢、最大值、最小值、刪除、中序遍歷、銷燬）

二叉排序樹（簡稱BST）又稱二叉查詢（搜尋）樹，其定義為：二叉排序樹或者是空樹，或者是滿足如下性質的二叉樹：       （1）若它的左子樹非空，則左子樹上所有記錄的值均小於根記錄的值；       （2）若它的右子樹非空,則右子樹上所有記錄的值均大於根記錄的值；     

二叉搜尋樹的查詢、插入、刪除的遞迴與非遞迴實現（C語言）

【概念】 什麼是二叉搜尋樹？ 二叉搜尋樹又稱二叉排序樹（按照中序遍歷，可以得到一組有序的序列），它或者是一顆空樹，或者是具有以下性質的二叉樹： 若他的左子樹不為空，則左子樹上所有節點的值都小於根結點的值。 若他的

二叉查詢樹（查詢、插入、刪除）——C語言

二叉查詢樹 二叉查詢樹（BST：Binary Search Tree）是一種特殊的二叉樹，它改善了二叉樹節點查詢的效率。二叉查詢樹有以下性質： （1）若左子樹不空，則左子樹上所有節點的值均小於它的根節點的值 （2）若右子樹不空，則右子樹上所有節點的值均大於它的根節點的值 （3）左、右子樹也分別為二叉排序樹 （

AVL樹（查詢、插入、刪除）——C語言

AVL樹 平衡二叉查詢樹（Self-balancing binary search tree）又被稱為AVL樹（AVL樹是根據它的發明者G. M. Adelson-Velskii和E. M. Landis命名的），是在二叉查詢樹的基礎上一個優化版本 AVL樹的特點： 1.本