12 views

Uploaded by ila6890

save

- Binary Tree Overview
- lab3
- Heap
- Diameter
- Data Structures
- Enumerations
- Computer Notes - Data Structures - 24
- Hierarchical Model for Preserving Privacy in Horizontally Partitioned Databases
- Level Recur
- Study Mid
- 02. Binary Tree
- Huffman Coding
- adaptive-huffman-coding.pdf
- Coding Skills
- tree2004.pdf
- Data Structure and Algorithms
- Static Compression
- Links
- INFLUENCE OF MEDIA EXPOSURE TO SCHOOL SUCCESS – DECISION TREE ANALYSIS
- 09 DS and Algorithm Session 13
- lec18
- Binarysearch Tree
- Analco05.Ps
- Data Structure Lec28 Handout
- Gate Cs Paper 1997
- 09 DS and Algorithm Session 13
- 04-dynamic-programming.pdf
- final report
- Design Patterns Code
- Final
- Q100030088
- surat lamaranq
- PENGANTAR
- Browsing
- Dasar Pengolahan Citra Dg MatLab

You are on page 1of 3

Abstract

A tree for optimal coding is sometimes called a Huffman tree. We define this tree here and give an

efficient method to create (and store) such a tree.

**Definition of Huffman Tree
**

A binary tree consists of nodes, where each node specifies no or two successors. A node is called

inner node (or usually only node), if it has successors. A node with no successors is called a leave. A

tree is defined recursively by:

1. A binary tree has a unique node, called a root. A root can be an inner node or a leave.

2. If a binary tree is given and a leave is replaced by a node with two leaves, where the two

leaves are no members of the binary tree, then we get another binary tree.

The second condition states, that the connection between a node and its successors can never lead to

a node of the binary tree.

Let us have a sequence of N symbols, where the i-th symbol has a frequency y(i). This number will be

called the weight of symbol i. If a binary tree is given and each leave has a weight, than the weight of a

node is defined as the sum of the weights of its successors, i.e. of two leaves, a leave and an inner

node, or two inner nodes.

Let S be a set of N symbols. A Huffman tree is constructed in the following way:

Let W be the set of all weights of the symbols S, i.e. W={y(i) | i∈S}. The smallest two weights are

leaves of an inner node. The weight of this node is the sum of those two weights. Now those two

smallest weights are removed from W, while the sum of them is added to W. Again the smallest two

elements are searched for. A new inner node holds them as successors, where they might now be

leaves or inner nodes as well.

**Construction of a Huffman Tree
**

To construct this tree in an efficient way we use the following data structures:

struct leaveType {int Name; int Weight; int isNode;}

struct nodeType {int Name; int Weight; int left, right;}

struct leaveType Leaves[N];

struct nodeType Nodes[N];

**createLeaves(int number) // Initialises each entry in Leaves[number]
**

{ int index;

for(index=0; index<number; index++)

{ Leaves[index].Name = ..;

Leaves[index].Weight = ..;

Leaves[index].left = -1;

Leaves[index].Name = -1;

} // end for(index…)

}

makeHeap(int number) // Makes a heap from the field of Leaves[number]

{ int index;

for(index=number/2;index>=0; index--) sift(index, number-1);

}

isNode>=0) // points to the node it stands for Nodes[index]. else Nodes[index]. else Nodes[index].isNode.isNode.left = number + Leaves[1].isNode>=0) // points to the node it stands for Nodes[index]. sift(1.isNode. else Nodes[index]. if(Leaves[2].Weight += Leaves[0]. Leaves[1]. for(index=0.isNode>=0) // points to the node it stands for Nodes[index].number-index-1).Name. else Nodes[index].Name.Weight.isNode.left = number + Leaves[1].left = Leaves[1]. else Nodes[index].isNode>=0) // points to the node it stands for Nodes[index]. } main() { createLeaves(N).isNode.CreateNodes(int number) // Makes a heap from the field of Leaves[number] { int index. CreateNodes(). if(Leaves[1].} index++.left = number + Leaves[1]. } // end for(index. Leaves[1]..Weight += Leaves[0]. Leaves[1].left = Leaves[0].Weight < Leaves[2]. // == number-2 if(Leaves[1].Weight) // Sum up Leaves[0] and Leaves[1] { if(Leaves[0].Name.Name.isNode = index.Weight < Leaves[2]. makeHeap(N). index--) // for all but the last three elements { if(Leaves[1]. } Leaves[0] = Leaves[number-index-1]. sift(0. if(Leaves[1].isNode.left = number + Leaves[0].left = number + Leaves[0].isNode>=0) // points to the node it stands for Nodes[index].Name.isNode = index.Weight. } else {.number-index-2).Name.Weight) // Sum up Leaves[0] and Leaves[1] { if(Leaves[0]. if(Leaves[1]. else Nodes[index].left = Leaves[0].left = number + Leaves[2]. } else // Sum up Leaves[0] and Leaves[2] { .index<number-3. } .left = Leaves[2]. Leaves[1].left = Leaves[1].left = Leaves[1].isNode>=0) // points to the node it stands for Nodes[index].

This algorithm first makes a heap from the nodes. Thus the total complexity is O(N+N*log2 N). which is more efficient than scanning through all N-1 nodes and N leaves N times. A node is created in Nodes at index. then the variables left and right of this node are assigned the index of this node in the filed Nodes. while the next smallest weight stands either at index 1 or index 2. which points to those two smallest elements. we assign to its variable isNode the index of this node. Thus this algorithm can also be used to construct very large Huffman trees with many symbols. although similar. which means it points to a leave with that number. When the algorithm ends. Since this is now a node. If they are nodes. If there are only three elements left. Thus the smallest weight stands at index 0. Efficiency We show that this algorithm is efficient. . Each of N-3 elements is treated by sifting them into the heap. then the time to make a heap from N Symbols is O(N). Otherwise. the complexity of each is O(log2 N). If N is the number of symbols. Thus it can be distinguished from an index. its weight becomes the sum of the weights of the two smallest elements. the situation is to be treated differently. each nodes left and right variable point either to another node or they hold a value >= number. if they are Leaves. then the variables left and right of this node are assigned the Name of that leave plus the number of elements. The Element at index 1 or 2 becomes a node with the new weight as the sum of the two smallest ones.

- Binary Tree OverviewUploaded byDebnath JM
- lab3Uploaded byDeepakGupta
- HeapUploaded byNirmal
- DiameterUploaded byRavinder Singh
- Data StructuresUploaded bySantosh Sardar
- EnumerationsUploaded byHarshit Gupta
- Computer Notes - Data Structures - 24Uploaded byecomputernotes
- Hierarchical Model for Preserving Privacy in Horizontally Partitioned DatabasesUploaded byAnonymous vQrJlEN
- Level RecurUploaded byakg299
- Study MidUploaded byJosh Cohen
- 02. Binary TreeUploaded byAkif Vohra
- Huffman CodingUploaded byPushkar Anand
- adaptive-huffman-coding.pdfUploaded byDedenMaulana
- Coding SkillsUploaded byMaddy137
- tree2004.pdfUploaded byJenner Patrick Lopes Brasil
- Data Structure and AlgorithmsUploaded byShanmugha Priya Balasubramanian
- Static CompressionUploaded byRavish Nirvan
- LinksUploaded byice_cute21
- INFLUENCE OF MEDIA EXPOSURE TO SCHOOL SUCCESS – DECISION TREE ANALYSISUploaded byMirjana Pejić Bach
- 09 DS and Algorithm Session 13Uploaded byBiljana Kuzmanovic
- lec18Uploaded byPushparaj Karu
- Binarysearch TreeUploaded bySaurabh Kaushik
- Analco05.PsUploaded byraghav79
- Data Structure Lec28 HandoutUploaded byThts JD
- Gate Cs Paper 1997Uploaded bySahil Manchanda
- 09 DS and Algorithm Session 13Uploaded byAshish Srivastava
- 04-dynamic-programming.pdfUploaded byNilay Pochhi
- final reportUploaded byapi-335445548
- Design Patterns CodeUploaded bydeline90
- FinalUploaded byvivek patel