Elementary introduction to algorithm and data structure: 72 fork Find tree Eight balance find tree 2-3 tree Nine balance find tree red black tree 10 balance find tree B-Tree

The two-fork search tree is described earlier, and he has no problem with the efficiency of finding and inserting in most cases, but he is less efficient in the worst case. The data structure of the balanced lookup tree introduced in this article and later in this article ensures that the LGN efficiency can be achieved in the worst case, and we need to make sure that the tree remains in equilibrium after the insert is complete, which is the Balanced search tree. In a tree with n nodes, we want the height of the tree to be maintained at LGN so that we can find the desired value only if we need to lgn the comparison operation. Unfortunately, it is too expensive to maintain the balance of the tree after each element insertion. So here are some new data structures to ensure that in the worst case, insertion and lookup efficiency are guaranteed to be done in logarithmic time complexity. This article first introduces the 2-3 find tree (2-3 search trees), which will be followed by the introduction of red and black trees and B-trees.

Defined

Unlike a two-fork tree, 2-3 trees run each node to save 1 or two values. For the normal 2 node (2-node), he saves 1 keys and left and right two points. corresponding to 3 nodes (3-node), save two key,2-3 find tree is defined as follows:

1. Either empty, or:

2. For 2 nodes, the node holds a key and corresponding value, and two points to the left and right nodes, and a 2-3 node, all the values are more effective than key, there is a node is a 2-3 node, all the value is larger than key.

3. For the 3 node, the node holds two keys and corresponding value, and three points to the left and right nodes. The left node is also a 2-3 node, all values are smaller than the smallest key in two key, the middle node is also a 2-3 node, the key value of the middle node is between two and the node key value, the right node is also a 2-3 node, All key values for a node are larger than the largest key in the two key.

If the middle order traverses the 2-3 lookup tree, the ordered sequence can be obtained. In a fully balanced 2-3 lookup tree, the root node is the same distance from each of the empty nodes.

Find

Before we proceed to the balance of the 2-3 tree, we first assume that we are in equilibrium, and we look at the basic lookup operation first.

2-3 Tree Lookup is similar to a two-fork lookup tree, to determine whether a tree belongs to a 2-3 tree, we first compare it with the node, and if it is equal, the lookup succeeds; otherwise, based on the condition of the comparison, it is found recursively in its left-right subtree, if the found node is empty, it is returned. The lookup process is as follows:

Insert into a 2-node node

Inserting an element into a 2-3 tree and inserting an element into a binary lookup tree, you first look for it, and then you hang the node on the node that is not found. The reason why 2-3 trees can guarantee efficiency in the worst case is that they remain balanced after insertion. If a node that is not found after the lookup is a 2-node node, then it is easy to simply put the new element into the 2-node node and make it a 3-node node. But if the found node ends up in a 3-node node, it can be a bit of a hassle.

Insert into a 3-node node

Inserting a new node into a 3-node node may encounter many different situations, starting with a simple tree that contains only one 3-node node.

contains only a single 3-node node

For example, suppose that the 2-3 tree contains only one 3-node node, which has two keys and no space to insert a third key, the most natural way is to assume that the node can hold three elements, temporarily make it a 4-node node, and he contains four child nodes. We then promote the middle element of this 4-node node, the left node as its left node, and the right element as its right node. Insert complete, change to balance 2-3 find tree, tree height changed from 0 to 1.

node is 3-node , the parent node is 2-node

As in the first case, we can also insert a new element into the 3-node node, make it a temporary 4-node node, and then promote the intermediate element in that node to the parent node, the 2-node node, so that its parent node becomes a 3-node node. The left and right nodes are then hung in the proper place on the 3-node node, respectively. Operations such as:

node is 3-node , the parent node is also 3-node

When we insert the node is 3-node, we split the node, the intermediate element to the parent node, but at this point the parent node is a 3-node node, after the insertion, the parent node becomes the 4-node node, and then continues to promote the intermediate element to its parent node. Until you encounter a parent node that is a 2-node node and then turn it into 3-node, you do not need to continue splitting.

Root node splitting

When the root node to the byte point is the 3-node node, this is if we want to insert a new element in the byte point, will always check the node, and in the last step, with the node into a 4-node node, this time, it will need to be divided into two 2-node nodes, The height of the tree is added to 1, this operation is as follows:

Local conversion

Splitting a 4-node into 2-3node involves 6 possible operations. This 4-node may be in the same node as the left or right child node of the 2-node. Or a 3-node left, middle, and right child node. All of these changes are local, and there is no need to check or modify other parts of the node. So it takes only a few operations to complete the 2-3-tree balance.

Properties

These local operations maintain a 2-3-tree balance. For 4-node nodes, the height of the tree is not changed before and after the deformation of the 2-3 node. Only if the node is a 4-node node, the height of the tree is added one after the deformation. As shown in the following:

Analysis

For a fully balanced 2-3 lookup tree, the distance from each root node to the leaf node is the same:

2-3 Tree Search efficiency is closely related to the height of the tree.

• In the worst case, that is, all nodes are 2-node nodes, and the lookup efficiency is LGN
• In the best case, all nodes are 3-node nodes, the lookup efficiency is log3n approximately equal to 0.631lgN

Distance, for 1 million nodes of 2-3 trees, the height of the tree is 12-20, for 1 billion nodes of 2-3 trees, the height of the tree is between 18-30.

For inserts, it takes only a few operations to complete, because he only needs to modify the nodes associated with that node, and does not need to check other nodes, so efficiency and lookup are similar. Here is the efficiency of the 2-3 lookup tree:

Realize

The direct implementation of the 2-3 tree is more complex because:

1. Need to handle different node types, very cumbersome
2. A multiple comparison operation is required to move the node down
3. Need to move up to split the 4-node node
4. There are a number of scenarios for splitting 4-node nodes

2-3 Find trees are more complex to implement, and in some cases the balancing operation after insertion may result in reduced efficiency. The improved red-black tree based on the 2-3 find tree is not only more efficient, but also easier to implement than the 2-3 lookup tree.

But the 2-3 search tree as a more important concept and idea is very important to the red and black trees and B-trees to be talked about later. Hopefully this article will help you understand the 2-3 find tree

Http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html

A brief discussion on the algorithm and data structure: Nine balance search tree of red and black trees

The previous article introduced the 2-3 lookup tree, you can see that the 2-3 find tree can ensure that after inserting elements can maintain the balance of the tree, the worst case is all the child nodes are 2-node, the height of the tree is LGN, thus guaranteeing the worst case of time complexity. However, 2-3 trees are more complex to implement, this paper introduces a simple implementation of 2-3 tree data structure, that is, red-black trees (red-black tree)

Defined

The red and black trees are mostly like encoding the 2-3 lookup tree, especially adding additional information to the 3-nodes node in the 2-3 lookup tree. The red-black tree divides the links between nodes into two different types, the red link, which he uses to link two 2-nodes nodes to represent a 3-nodes node. A black link is used to link a normal 2-3 node. In particular, two 2-nodes with red links are used to represent a 3-nodes node, and to the left, where one 2-node is the left child node of another 2-node. The advantage of this approach is that you don't have to make any changes when looking for the same as a normal two-fork lookup tree.

According to the above description, the red and black tree is defined as follows:

The red-black tree is a balanced lookup tree with red and black links, while satisfying:

• Red nodes Tilt Left
• A node cannot have two red links
• The whole book is completely black balanced, that is, from the root node to the path of the leaf node, the number of black links is the same.

You can see that the red and black trees are actually another form of expression for the 2-3 trees: if we draw the red line horizontally, then the two 2-node nodes that he links are a 3-node node in the 2-3 tree.

Said

We can add a new token representing the color on each node of the binary lookup tree. The flag indicates the color that the node points to its parent node.

Private Const BOOL RED = True;private const BOOL BLACK = false;private node root;class node{public    Node left {get; s Et Public    Node Right {get; set;}    Public TKey Key {get; set;}    Public TValue Value {get; set;}    public int number {get; set;}    public bool Color {get; set;}    Public Node (TKey key, TValue value,int number, bool color)    {this        . key = key;        This. value = value;        This. Number = number;        This. color = color;    }} private bool Isred (node node) {    if (node = = null) return false;    Return node. Color = = RED;}

Implementation Lookup

The red and black tree is a special two-fork search tree, and his search method is the same as a two-fork search tree, so there is no need to make too many changes.

But because the red and black trees have a better balance than the average two-fork search tree, it is quicker to find them.

Lookup gets the specified value public override TValue Get (TKey key) {    return GetValue (root, key);} Private TValue GetValue (node node, TKey key) {    if (node = = NULL) return to default (TValue);    int cmp = Key.compareto (node. Key);    if (cmp = = 0) return node. Value;    else if (CMP > 0) return GetValue (node. Right, key);    else return GetValue (node. Left, key);}

Balance of

Before we introduce the INSERT, let's show how to keep the red-black tree balanced, because in general, after we insert it, we need to balance the tree to make it fit.

Rotate

Spin is divided into left and right . A left-hand operation is typically used to rotate a red link that tilts to the right to a left link. Before and after the contrast operation, it can be seen that the operation is actually moving a large node in the two nodes of the Red line link to the root node.

L-Operations such as:

Left Rotate private node Rotateleft (node h) {    node x = h.right;    The left node of x is copied to h right node    h.right = X.left;    Copy h to x right node    x.left = h;    X.color = H.color;    H.color = RED;    return x;}

The left-handed animation works as follows:

The right-hand is the inverse of the left-handed operation, as follows:

The code is as follows:

Right rotation private node Rotateright (node h) {    node x = h.left;    H.left = x.right;    X.right = h;    X.color = H.color;    H.color = RED;    return x;}

Right-handed animations are as follows:

Color reversal

When a temporary 4-node occurs, the two child nodes of a node are red, such as:

This is actually a a,e,s 4-node connection, we need to promote E to the parent node, the operation method is very simple, is to set the e-node connection to black, and its own color set to red.

With these basic operations in hand, we now balance the red and black trees with the previous balancing operation on the 2-3 tree, which can correspond to each other, such as:

Now to discuss the various situations:

Case 1 Towards a 2-node Insert a new node at the bottom of the node

First of all, let's look at the action of inserting a new node for a red-black tree with only one node:

This is a simple situation and requires only:

• Standard two-fork lookup tree traversal. The newly inserted node is marked red
• If the newly inserted node is on the right child node of the parent node, a left-hand operation is required

Case 2 Towards a 3-node Insert a new node at the bottom of the node

To warm up first, let's say we insert elements into a tree with only two nodes, such as the size of the element to be inserted and the existing element, and can be divided into the following three cases:

• This is easiest if the node with the insertion is larger than the existing two nodes. We just need to connect the newly inserted node to the right subtree, then elevate the middle element to the root node. So the root node of the left and right subtree are red nodes, we only need to investigate the Flipcolor method. Other cases are reversed and will be the same.
• If the inserted node is smaller than the smallest element, then add the new node to the leftmost, so there are two nodes that are connected to the red node, which is the right-hand operation of the middle node, making the intermediate nodes the root node. This translates to the first case where only one more flipcolor operation is required.
• If the value of the inserted node is between two nodes, the new node is inserted into the right child node of the left node. Because the right child node of the node is red, a left-hand operation is required. After the operation has become the second case, then the right-hand, and then call the Flipcolor operation to complete the balance operation.

With the above basics, let's summarize the steps to insert a new node at the bottom of a 3-node node, which is a typical operating procedure diagram:

As you can see, the procedure is as follows:

1. Performs a standard two-fork find tree insert operation, with the newly inserted node element identified in red.
2. If you need to rotate the 4-node node
3. If necessary, call the Flipcolor method to elevate the red node
4. If necessary, the left-hand operation causes the red node to leave.
5. In some cases, a recursive call to Case1 Case2 is required to perform a recursive operation. As follows:

Code implementation

After the balanced discussion above, it is time to implement the insert operation, and the general insert operation is to perform a standard two-fork lookup tree Insert before balancing. Compared with 2-3 trees, we can complete the balance through the three kinds of operation, which are discussed above, left-hand, right-handed and flipcolor.

Here's how it works:

• If the right child node of the node is red, and the left child node is black, the left-hand operation
• If the left child node of a node is red and the left child node of the left child node is also red, the right-handed operation
• If the left and right child nodes of the node are red, the Flipcolor operation is performed to promote the intermediate junction.

Based on this logic, we can implement the put method of inserting.

public override void put (TKey key, TValue value) {    root = Put (root, key, value);    Root. Color = BLACK;} Private node Put (node H, TKey key, TValue value) {    if (h = = null) return new Node (key, value, 1, RED);    int cmp = Key.compareto (h.key);    if (CMP < 0) H.left = Put (H.left, key, value);    else if (cmp > 0) h.right = Put (H.right, key, value);    else H.value = Value;    Balanced Operation    if (isred (h.right) &&! Isred (h.left)) H = rotateleft (h);    if (isred (h.right) && isred (h.left.left)) H = rotateright (h);    if (isred (h.left) && isred (h.right)) H = Flipcolor (h);    H.number = Size (h.left) + size (h.right) + 1;    return h;} private int Size (node node) {    if (node = = null) return 0;    Return node. number;}

Analysis

The analysis of the red and black tree is actually the analysis of 2-3 search tree, the red and black tree can ensure that all the operation of the symbol table in the worst case can guarantee the logarithmic time complexity, that is, the height of the tree.

Before analyzing, to be more intuitive, here is an animation of a red-black tree in ascending, descending, and random form:

• To build a red-black tree in ascending order:

• To build a red-black tree in descending order:

• Randomly inserted to build a red-black tree

From the above three animation effects, it can be very intuitive to see that the red and black trees in various situations can maintain good balance, so as to ensure the worst case of the search, insertion efficiency.

Below is a detailed analysis of the efficiency of the red and black trees:

1. In the worst case, the height of the red-black tree does not exceed 2lgN

The worst case scenario is that the red and black trees, except for the leftmost path, are all made up of 3-node nodes, that is, the red and black path length is 2 times the length of the full black path .

is a typical red-black tree from which you can see the longest path (the red-black path) is twice times the shortest path:

2. The average height of the red and black trees is about LGN

Is the time complexity of the red and black trees in various cases, it can be seen that the red and black tree is an implementation of the 2-3 search tree, he can ensure that the worst case still has a logarithmic time complexity.

Is the time complexity of the various operations of the red and black trees.

Application

Red and black tree This data structure is widely used in many programming languages as a symbol table implementation, such as:

• Java.util.treemap,java.util.treeset in Java
• C + + STL: Map,multimap,multiset
• . NET: Sorteddictionary,sortedset, etc.

Below with. NET as an example, through the reflector tool, we can see that the Add method of SortedDictionary is as follows:

public void Add (T item) {if (this.root = = null) {this.root = new node<t> (item, FALSE);    This.count = 1;        } else {node<t> root = this.root;        node<t> node = null;        Node<t> grandparent = null;        Node<t> greatgrandparent = null;        int num = 0; while (root = null) {num = This.comparer.Compare (item, root.            Item);                if (num = = 0) {this.root.IsRed = false;            Throwhelper.throwargumentexception (exceptionresource.argument_addingduplicate); } if (Treeset<t>. Is4node (root) {treeset<t>.                Split4node (root); if (TREESET&LT;T&GT;. Isred (node)) {this.                Insertionbalance (Root, ref node, grandparent, greatgrandparent);            }} greatgrandparent = grandparent;            grandparent = node; node = root;            root = (num < 0)? Root. Left:root.        right;        } node<t> current = new node<t> (item); if (num > 0) {node.        right = current; } else {node.        left = current; } if (node. isred) {this.        Insertionbalance (Current, ref node, grandparent, greatgrandparent);        } this.root.IsRed = false;        this.count++;    this.version++; }}

As you can see, the internal implementation is also a red-black tree, its operation method and this article will be similar, interested in words, you can use the Reflector tool to follow up to see the source code.

Summarize

This article explains the 2-3 lookup tree in the self-balancing lookup tree, which can be self-balanced after insertion, thus ensuring that the height of the tree is within a certain range to ensure the worst-case time complexity. But the 2-3 find tree is difficult to implement, and the red-black tree is a simple and efficient implementation of 2-3 trees, and he cleverly uses color tags instead of the more difficult-to-handle 3-node node problem in 2-3 trees. Red-black tree is a relatively efficient and balanced search tree, the application is very extensive, many of the internal implementation of programming languages are more or less the use of red and black trees.

I hope this article will help you understand the red and black trees, and we'll look at another kind of balanced tree structure that is widely used in file systems and database systems: B-trees.

Http://www.cnblogs.com/yangecnu/p/Introduce-B-Tree-and-B-Plus-Tree.html

Http://www.cnblogs.com/yangecnu/p/Introduce-B-Tree-and-B-Plus-Tree.html

On the algorithm and data structure: a ten-balanced search tree B-Tree

The 2-3 trees in the balance lookup tree are explained earlier and the red and black trees are implemented. 2-3 tree species, a node has a maximum of 2 keys, while the red-black tree uses a staining method to identify the two keys.

Wikipedia defines B-trees as "in computer science, B-Tree (B-tree) is a tree-like data structure that can store data, sort it, and allow the time complexity of O (log n) to run for lookups, sequential reads, insertions, and deletions. B-Tree, which is generally a node can have more than 2 child nodes of the two-fork lookup tree. Unlike the self-balancing binary lookup tree, B-tree is the system's most optimized read and write operation for large chunks of data . The b-tree algorithm reduces the intermediate process that is experienced when locating records, thus speeding up the access speed. Widely used in databases and file systems . ”

Defined

A B-tree can be seen as an extension of the 2-3 lookup tree, that is, he allows each node to have M-1 child nodes.

• Root node has at least two child nodes
• Each node has a M-1 key and is sorted in ascending order
• The values of the child nodes at M-1 and M key are located between M-1 and M key corresponding to value
• Other nodes have at least M/2 child nodes

is a m=4-order B-Tree:

You can see that the B-tree is an extension of 2-3 trees, and he allows a node to have more than 2 elements.

The insertion and balancing of the B-tree is similar to the 2-3 tree, which is not covered here. The following is inserted into the B-tree in turn

6 10 4 14 5 11 15 3 2 12 1 7 8 8 6 3 6 21 5 15 15 6 32 23 45 65 7 8 6 5 4

The Demo animation:

b + tree is a kind of deformation tree of the tree, which differs from B-tree in that:

• The nodes with K nodes must have K key codes;
• The non-leaf nodes only have index function, and the information related to the records is stored in the leaf node.
• All leaf nodes of a tree form an ordered list that can traverse all records in the order in which the key codes are sorted.

For example, is a B + tree:

Is the Insert animation for B + trees:

The difference between B and C + trees is that the non-leaf nodes of the + + tree contain only navigational information and do not contain actual values, and all leaf nodes and connected nodes are linked using a linked list for easy interval lookup and traversal.

The advantages of B + trees are:

• Since the B + tree does not contain data information on the internal node, it can store more keys in the memory page. The data is stored more tightly and has better spatial locality. So accessing the leaves at several points on the associated data also has a better cache hit ratio.
• B + Tree leaf nodes are chain-linked, so the convenience of the whole tree only need a linear traversal of the leaf node. And because the data order is arranged and connected, it is convenient to find and search the interval. The B-tree requires recursive traversal of each layer. Adjacent elements may not be contiguous in memory, so cache hit is not as good as a B + tree.

The advantage of B-trees, however, is that since each node in the B-tree contains both key and value, the frequently accessed elements may be closer to the root node and therefore more quickly accessed. Here is a diagram of the difference between B-and + + trees:

Analysis

The analysis of B-and + + trees is similar to the analysis of the 2-3 trees previously explained,

For a subtree with a node of n degrees m, finding and inserting requires logm-1n ~ logm/2n times comparison. This is a good proof that for the B-tree with degrees M, the number of child nodes per node is between M/2 and M-1, so the height of the tree is between logm-1n and logm/2n.

This efficiency is very high, for n=62*1000000000 nodes, if the degree is 1024, then logm/2n <=4, that is, in 62 billion elements, if the degree of the tree is 1024, it only needs less than 4 times to navigate to the node, Then use the binary search to find the value you are looking for.

Application

B-Tree and + + are widely used in file storage systems and database systems, before we look at the common storage structure before we explain the application:

The main memory of our computer is basically random access memory (random-access Memory,ram), he is divided into two categories: Static random access memory (SRAM) and dynamic random access memory (DRAM). SRAM is faster than DRAM, but much more expensive, generally as a CPU cache, and DRAM is usually used as memory. This kind of memory their structure and storage principle is more complex, basically is the use of electrical signals to save information, there is no machine operation, so the access speed is very fast, the specific access principle can be viewed Csapp, in addition, they are volatile, that is, if the power outage, the storage of DRAM and SRAM saved information will be lost.

The more we use disk, the disk can hold a lot of data, from GB to terabytes, but his reading speed is slow, because it involves machine operation, reading speed is millisecond, from DRAM reading speed is 100,000 times times faster than disk, from the SRAM read speed than from disk read faster than 1 million times times. Here's a look at the structure of the disk:

For example, disks consist of platters, each with two sides, also known as a disk surface, which is covered with magnetic materials. The center of the platter has a rotatable spindle (spindle) that rotates the disc at a fixed rotational rate, typically 5400 rpm (Revolution per minute,rpm) or 7200RPM. The disk contains more than one such platter and is encapsulated within a sealed container. On the left, a typical disk surface structure is shown. Each surface is composed of a set of concentric circles that become tracks (track), each of which is divided into a set of sectors (sector). Each sector contains an equal number of data bits, usually (512) sub-sections. Sectors are separated by gaps (GAP) and do not store data.

The above is the physical structure of the disk, now look at the disk read and write operations:

For example, a disk with a read/write header to read and write bits stored on a magnetic surface, while the read-write head is connected to one end of a transmission arm. By moving the drive arm back and forth along the radius axis, the driver can position the read-write head on any track, which is called a seek operation. Once the track is positioned, the disc rotates and each bit on the track passes through the head, the read-write head can perceive the value in place, and the value can be modified. Access time to the disk is divided into seek time , rotation time , and transfer time .

Due to the characteristics of the storage media, the disk itself is much slower than main memory, coupled with the mechanical movement of the cost, so in order to improve efficiency, to minimize disk I/O, reduce read and write operations. To do this, the disk is often not read strictly on-demand, but is read-ahead every time, even if only one byte is required, and the disk starts from this location, sequentially reading a certain length of data into memory. The rationale for this is the well-known local principle in computer science:

When a data is used, the data around it is usually used immediately.

The data that is required during the program run is usually relatively centralized.

Due to the high efficiency of disk sequential reads (no seek time required and minimal rotational time), pre-reading can improve I/O efficiency for programs with locality.

The length of the read-ahead is generally the integer multiple of the page. Page is the logical block of Computer Management memory, hardware and operating system tend to divide main memory and disk storage area into contiguous size equal blocks, each storage block is called a page (in many operating systems, the page size is usually 4k), main memory and disk in the page to exchange data. When the program to read the data is not in main memory, will trigger a page fault, the system will send a read signal to the disk, the disk will find the starting position of the data and sequentially read one or several pages back into memory, and then return unexpectedly, the program continues to run.

The designers of file systems and database systems use the principle of disk pre-reading to set the size of a node equal to one page, so that each node can be fully loaded with only one I/O. To achieve this, the following techniques are required to implement B-tree in practice:

Each time a new node is created, directly request a page space (512 or 1024), so that a node is physically stored in a page, in addition to the computer storage allocation is page-aligned, the implementation of a node only one time I/O. For example, the degree m of the B-tree is set to 1024, so that in the previous example, only less than 4 lookups in 60 billion elements can be located to a storage location.

At the same time in the B + tree, the inner node only stores the navigation key, does not store the specific value, so that the number of nodes less, to be able to read all the main memory, external contact storage key and value, and order, with good spatial locality. So B-plus + trees are more suitable for data structures with file systems. Below is a B-tree for content storage.

In addition, b/b+ tree is often used as the index of the database, it is recommended that you directly see the Zhang Yang MySQL index behind the data structure and algorithm principle this article, this article on how to use B + tree in MySQL index has a more detailed introduction, recommended reading.

Summarize

In the previous two articles, we introduced the 2-3 trees in the balance finding tree, and after the red and black trees, this paper introduces the b/b+ tree which is commonly used in file system and database system, and he expands the number of storage for each node, so that the continuous data can be quickly located and accessed, which can reduce the searching time effectively. Increase the spatial locality of storage and thus reduce IO operations. He is widely used in file systems and databases, such as:

• WINDOWS:HPFS File System
• mac:hfs,hfs+ File System
• LINUX:RESISERFS,XFS,EXT3FS,JFS File System
• Database: Oracle,mysql,sqlserver, etc.

I hope this article will help you understand the b/b+ tree.

Elementary introduction to algorithm and data structure: 72 fork Find tree Eight balance find tree 2-3 tree Nine balance find tree red black tree 10 balance find tree B-Tree