1

DATA STRUCTURES

Weight balanced binary tree

ContentPage

Introduction

Chapter I : Binary Trees Foundation 04

A- Definition 04B- Types of binary trees 04C- Binary Tree Traversals 05D- Glossary 06

Chapter ii : Balanced tree Foundation 07

A- Definition 07B- Performance of balanced binary tree 08C- Big-O notation 09D- Glossary 10

Chapter iii: Weight balanced binary tree 11

A- Definition 11B- Properties of weight-balanced tree 11C- Methods of weight-balanced tree 11D- weight-balanced tree in depth 11E- Advantages of weight-balanced tree 12F- Implementation of weight-balanced tree 13

Chapter iv: weight Balanced Binary Tree in depth 15

A- Definitions 15B- Theorem 16C- Performance 16

References 17

2

INTRODUCTION

Data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently.

There are many books describing data structures around the world. Different kinds of data structures are there, and some are highly specialized to specific tasks. In Our work we have mission to report information about weight balanced binary tree. The binary search tree (BST) data structure is fundamental to computer science. Many variants of BSTs have been devised so far. Weight BSTs achieve logarithmic worst-case cost by using th size of the subtrees as balancing information [13].

So let us in this report talk about Weight BST

This report is subdivided in four sequences. Firstly we are going to present foundation and generalization in the tree structures. The second sequence of our work will talk about the balanced tree and the two last blocs should give more information about the main topic of this work.

3

Chapter i: Binary Trees Foundation

A- Definition

A binary tree is a finite set of elements that is either empty or is partitioned into three disjoint subsets. [1]

- The first subset contains a single element called the root of the tree.- The other two subsets are themselves binary trees, called the left and right subtrees of the original tree. A left or right subtree can be empty.

Each element of a tree is called a node of the tree.

There is a basic operation we can do in the tree: Searching, Insertion, Deletion, Traversal and Sort. [2]

B- Types of binary trees

A rooted binary tree A full binary tree [proper binary tree or 2-tree or strictly binary tree] A perfect binary tree A complete binary tree An infinite complete binary tree A balanced binary tree * A rooted complete binary tree A degenerate tree

Note that this terminology often varies in the literature, especially with respect to the meaning "complete" and "full". [2]

4

B

G

ED

IH

F

cA Binary tree

C- Binary Tree Traversals

A binary tree can be traversed using different algorithms [3]

Let L, V, and R stand for moving left, visiting the node, and moving right.

There are six possible combinations of traversallRr, lrR, Rlr, Rrl, rRl, rlR

Adopt convention that we traverse left before right, only 3 traversals remain

lRr, lrR, Rlr inorder, postorder, preorder

For better understanding [4]

M is the Root NodeP is the Left Child NodeN is the Right Child Node

+ Pre-Order : MPN+ In-Order : PMN+ Post-Order : PNM+ Level-Order : MPN

1. In-order: Left-Root-Right. Listing method in which the sequence of the nodes is left most child node, root node followed by remaining child nodes in a left to right order.

2. Post-order: Left-Right-Root. The sequence of the nodes is child notes in left to right followed by the root.

3. Pre-order: Root-Left-Right, It employs Depth First Search. The sequence of the nodes is root node followed by the child nodes taken in left to right order.

4. level-order, where we visit every node on a level before going to a lower level. This is also called Breadth-first traversal.

5

C- Glossary

Tree - a non-empty collection of nodes & edgesNode - can have a name and carry other associated informationThe maximum number of nodes on level i of a binary tree is 2 i-1, i>=1.The maximum number of nodes in a binary tree of depth k is 2k-1, k>=1.Path - a list of distinct nodes in which successive nodes are connected by edges. Any two nodes must have one and only one path between them, else it is not a treeA directed edge refers to the link from the parent to the childRoot - starting point (top) of the treeParent (ancestor) of a node A - the node "above" node AChild (descendent) of a node A - the node "below" node ASiblings - nodes that have same parentLeaf (terminal node) - a node with no childrenLevel of a node - the number of edges between this node and the rootDepth of a node - the number of edges from the root to that node.The depth of the root is 0.Height of a node - the largest number of edges from that node to a leaf.The height of each leaf is zeroHeight of a tree - the longest path from the root to a leaf node.The size of a node is the number of descendants it has including itself.In-degree of a node is the number of edges arriving at that node.Out-degree of a node is the number of edges leaving that node

6

Chapter ii: Balanced Tree Foundation

A- Definition

A balanced tree is a tree which is balanced - it has roughly the same height on each of its sub-nodes. A balanced tree will have the lowest possible overall height [7]. A binary tree where no leaf is more than a certain amount farther from the root than any other [8]. A balanced tree is a sorted collection of key/value pairs optimized for searching and traversing in order.

A balanced tree can be divided by two (three) [8]:

Height balanced : AVL trees, 2-3 trees, 2-3-4 trees, B treesWeight condition : BB[a]-Bäume(*) Structural conditions : Bruder-, 2-3-, a-b-, B-Bäume

A balanced binary tree is a tree that is explicitly kept balanced. It has a lookup and insertion complexity of O(log(n)), and an accumulative complexity of O(n*log(n)). All of them worst case!

It turned out to be faster than the sorted array, by about a factor of 2. For more (maximum) efficiency, a binary search tree stand be balanced.

7

B- Performance of balanced binary tree [10]

Binary search trees provide O(lg n) performance on average for important operations such as item insertion, deletion, and search operations. Balanced trees provide O(lg n) even in the worst case

Consider the binary tree, at each level the number of the nodes is doubled. There are three levels, and the total number of nodes is:

1 + 2 + 22 + 23 = 24 - 1 = 15

Note that 24 - 1 = 2*23 – 1 | also that 3 = log(23)

In general, if we have a tree with M levels, the number of the nodes would be:

1 + 2 + 22 + …. 2M = 2(M+1) - 1 = 2*2M – 1

Let N be the number of the nodes.

We will find now how M (the depth of the tree) depends on the number of the nodes.N = 2*2M – 1 --- > 2*2M = N + 1 --- >2M = (N+1)/2M = log((N+1)/2) = O(logN)

Thus, given a balanced binary tree with N nodes, the height of the tree is O( log(N)). Given a balanced binary tree with M levels, the number of the nodes is O(2M)

Average height of a binary tree : O(sqrt(N)) - computed by considering all possible cases of a binary tree with N nodes.Worst case: when the tree is a list - all nodes except the leaf have only one child: height: N-1.

8

9

C- Big-O notation

Definition: A theoretical measure of the execution of an algorithm, usually the time or memory needed, given the problem size n, which is usually the number of items. Informally, saying some equation f(n) = O(g(n)) means it is less than some constant multiple of g(n). The notation is read, "f of n is big oh of g of n".

Formal Definition: f(n) = O(g(n)) means there are positive constants c and k, such that 0 ≤ f(n) ≤ cg(n) for all n ≥ k. The values of c and k must be fixed for the function f and must not depend on n. [16]

The importance of this measure can be seen in trying to decide whether an algorithm is adequate, but may just need a better implementation, or the algorithm will always be too slow on a big enough input. For instance, quicksort, which is O(n log n) on average, running on a small desktop computer can beat bubble sort, which is O(n²), running on a supercomputer if there are a lot of numbers to sort. To sort 1,000,000 numbers, the quicksort takes 20,000,000 steps on average, while the bubble sort takes 1,000,000,000,000 steps! [17]

10

D- Glossary

Binary Search Tree – is binary tree and the following additional property:

Given a node T, each node to the left is “smaller” than TAnd each node to the right is “large”

Some examples of search-tree data structures are [12] :

Red-black trees and splay trees, both of which are instances of self-balancing binary search trees;Ternary search trees, in which each internal node has exactly three children;B trees, commonly used in databases;B+ trees, like B trees but with all data values stored in the leaves;van Emde Boas trees, very efficient if the data values are fixed-size integers.

(a) is not a BST. (b) and (c) are BSTs

11

Chapter iii: weight Balanced Binary Tree

A- Definition A weight-balanced binary tree is a binary tree which is balanced based on knowledge of the probabilities of searching for each individual node. Within each subtree, the node with the highest weight appears at the root. This can result in more efficient searching performance [11]. Also known as BB(α) tree [18]

B- Properties of weight-balanced tree

[13]Because the tree is weight-balanced, the distances between any node and each of the leaf node descendents of that node are equal. So, for any leaf nodes xy

C- Methods of weight-balanced tree

Weight balanced tree is balanced binary search trees because their “weight” is used as the criterion for balancing.

The weight of the tree is defined as the number of external nodes in the tree (this equals the number of null pointer in the tree) [1]. If the ratio of the weight of the left subtree of every node to the weight of the subtre rooed at the node is between some fraction a and a-1, the tree is a weight balanced tree of ratio a or is said to be in the class wb[a].

12

D- Advantages of weight-balanced tree

A weight-balanced binary tree has several advantages over the other data structures for large aggregates:

In addition to the usual element-level operations like insertion, deletion and lookup, there is a full complement of collection-level operations, like set intersection, set union and subset test, all of which are implemented with good orders of growth in time and space. This makes weight-balanced trees ideal for rapid prototyping of functionally derived specifications.

An element in a tree may be indexed by its position under the ordering of the keys, and the ordinal position of an element may be determined, both with reasonable efficiency.

Operations to find and remove minimum element make weight-balanced trees simple to use for priority queues.

The implementation is functional rather than imperative. This means that operations like `inserting' an association in a tree do not destroy the old tree, in much the same way that (+ 1 x) modifies neither the constant 1 nor the value bound to x. The trees are referentially transparent thus the programmer need not worry about copying the trees. Referential transparency allows space efficiency to be achieved by sharing subtrees.

These features make weight-balanced trees suitable for a wide range of applications, especially those that require large numbers of sets or discrete maps. Applications that have a few global databases and/or concentrate on element-level operations like insertion and lookup are probably better off using hash tables or red-black trees. A weight-balanced tree takes space that is proportional to the number of associations in the tree.

E- Implementation of weight-balanced tree

13

The following table shows a simple BB[alpha] tree (with alpha=1/4) and the balances of the nodes. [19]

1. TREE TRAVERSAL refers to the process of visiting (examining and/or updating) each node in a tree data structure.

Algorithm traversal

Parameter : root and keyInitialization : r receive the root L receive the number of leavesn receive r.key , r.left and r.rightl determine by floor((1-a)*L)Work: Repeat of these instruction

o If r is null return nullo Else if key = n.key then return no Else if key < n.key then r receive n.lefto Else r receive n.right

Noteso we obtain a simpler remainder function

W(pl) <= (1 - alpha) W(p)W(pr) <= (1 - alpha) W(p)

(W(p) denotes the number of leaves of p, p is a node, pl and pr its left and right child, respectively.)

2. TREE DELETION can be accomplished using the method: checking for the separate cases with no children, two children, or one.

Algorithm delete

Parameter : root and keyInitialization : t receive the root Work:

Progressing in the tree

14

o If t is null return nullo Else if t.key < key then return t.right receive delete

(t.right,key)o Else if t.key > key then return t.left receive delete(t.left,key)

Deletion if descendant is nullo Else if t.left = null then t receive t.righto Else if t.right = null then t receive t.left

Deletion if descendant is not null o Else if wt(t.left)>wt(t.right) then

[t=rrot(t) ; t.right = delete(t.right,key)]o Else [t=lrot(t) ; t.left = delete(t.left,key)]

Reconstruct weight informationo If t not null theno t.weight receive wt(t.left)+wt(t.right)o check(t)

Return(t) // end of programNotes

o wt is function wich give the weight of nodeo rrot and lrot is respectly right and left rotation o check controlled if the t is weight balanced

We have try to write essential implementation of weight balanced binary tree in this section, you can find other function for adaptation in WBBT here: a)http://www.cse.iitb.ac.in/~as/mit-scheme/scheme_12.html#SEC127b) http://www-users.aston.ac.uk/~beaumoaj/AJBcs124/DSA/Page2.3.html

Chapter iv: weight Balanced Binary Tree in depth

Let Alpha be a real such that 1/4 < Alpha <= 1 - Let T be a binary search tree Let Tl (Tr ) be the left (right) subtree of the root of T

Definitions

The root balance of T, Rho , is given by:Rho(T) = | Tl | / |T | = 1 - | Tr | / | T |where | T | = number of leaves of tree T

A tree T is of bounded balance Alpha , if for every subtree T' of T we have:Alpha <= Rho(T' ) <= 1 - Alpha

BB[ Alpha ] is the set of all trees of bounded balance Alpha

15

Example of BB[ Alpha ] tree Alpha <= 1/3

Node Root balancea ½b 2/5c 5/14d 2/3

Let bi denote the depth of node xi in tree T. The average path length of T is given by:

Theorem

Let T be a BB[ Alpha ] with n nodes. Then 

a) 

b) 

if   then theorem 2 states P <= 1.15(1 + 1/n) lg( n+1) - 1and height(T) <= 2 lg( n +1 ) – 1

Performance

Lemma

16

Let  .Let T' be a BB[ Alpha ] tree.Let T be result of adding (deleting) a node from T'.Assume that Tl and Tr are BB[ Alpha ] trees.Assume that T is no longer a BB[ Alpha ] tree.Then a single or double rotation will balance T

Theorem.Let  . Then there is a constant c such that the total number of single and double rotations required in a sequence of M insertions and deletions into an empty BB[ Alpha ] tree is <= cMFor = 3/11 the prove gives the value of c = 19.59

Experiments suggest that c is near 1

Theorem.Let  . Then insert, access, delete takes O(N) in a BB[ Alpha ] tree with N leaves

17

It has been shown that the cost W of a weight balanced binary tree satisfies the inequalities, H 5 W 5 H + 3, where H is the entropy of the set of the leaves. For a class of “smooth” distributions the inequalities, H 5 W 5 H + 2, are derived. These results imply that for sets with large entropy the search times provided by such trees cannot be substantially shortened when binary decisions are being used.

J. Rissanen: Bounds for Weight Balanced Trees

References and Books reviews

[1] Data Structure Using C and C++ 2nd Edition; ISBN 81-317-0328-2

[3] University of North Texas , CSCE 3110 Data Structures & Algorithm Analysis

[14] Abstract, Salvador Roma, http://www.springerlink.com/content/d9191wje6j4rqr4b/

[15] Handbook of DATA STRUCTURES and APPLICATIONS; Edited by Dinesh P. Mehta Colorado School of Mines Golden and Sartaj Sahni University of Florida Gainesville

[17] Jon Bentley, Programming Pearls: Algorithm Design Techniques, CACM, 27(9):868, September 1984 for an example of a microcomputer running BASIC beating a supercomputer running FORTRAN.

[2] http://en.wikipedia.org/wiki/Binary_tree

[4] http://www.laynetworks.com/cs04.htm

[5] http://sites.google.com/site/sumedhshende/binarytrees

[6]http://en.wikipedia.org/wiki/Binary_search_tree

[7] http://wiki.answers.com/Q/What_is_a_balanced_tree_in_data_structures

[8]: http://www.csie.ntu.edu.tw/~wcchen/algorithm/balanceTree/balanced.htm

[9] http://www.itl.nist.gov/div897/sqg/dads/HTML/balancedbitr.html

[10] http://faculty.simpson.edu/lydia.sinapova/www/cmsc250/LN250_Weiss/L07-Trees.htm

[11] http://en.wikipedia.org/wiki/Weight-balanced_tree

[12] http://en.wikipedia.org/wiki/Search_tree

[13] http://planetmath.org/encyclopedia/WeightBalancedBinaryTreesAreUltrametric.html

[16] http://www.itl.nist.gov/div897/sqg/dads/HTML/bigOnotation.html

[18] http://www.itl.nist.gov/div897/sqg/dads/HTML/bbalphatree.html

[19] http://www.auto.tuwien.ac.at/~blieb/woop/bbalpha.html

[20] http://www.eli.sdsu.edu/courses/fall95/cs660/notes/BB/BBtrees.html

18