Upload
duongtuyen
View
230
Download
1
Embed Size (px)
Citation preview
Informatik I für D-MAVT (FS 2013)
Data Structures – Trees
Sorting Algorithms
Christian Schumacher, [email protected]
Trees
Binary Trees
Binary Search Trees
Sorting Algorithms
© M. Gross, ETH Zürich, 2013
2
Linked Lists & Trees
A linked list is a „tree“ with degree 1
A binary tree is a tree with degree 2
Linked list Binary tree
© M. Gross, ETH Zürich, 2013
4
Tree Node Element Struct
Like a list element but with more than one child (pointer)
Value can be anything
„Empty Tree“ is just a NULL pointer
Example for binary tree node
struct Node
{
int value; // The value of the element
Node *left; // Pointer to the left child
Node *right; // Pointer to the right child
};
Node *root = NULL; //Pointer to root element
© M. Gross, ETH Zürich, 2013
5
Use Recursive Functions
A tree is a fractal:
If root is a (non-emtpy) tree, root->left and
root->right will also be a tree
A function that can handle the root node can also
handle the child nodes
© M. Gross, ETH Zürich, 2013
6
Use Recursive Functions
Create a function that takes any tree element as a
parameter
Let the function print the data of the element
Print the data of its child elements recursively
void print_recursive( Node *node )
{
cout << ... // print value
// to print the childrens content
print_recursive( node->left );
print_recursive( node->right );
}
© M. Gross, ETH Zürich, 2013
7
Use Recursive Functions
Don't forget the base
Otherwise: Endless loop or (here) NULL pointer
dereferencing
void print_recursive( Node *node )
{
if( node != NULL )
{
cout << ...
print_recursive( node->left );
print_recursive( node->right );
}
}
© M. Gross, ETH Zürich, 2013
8
Traversing Recursively
void recursive( Node *node )
{
if( node != NULL )
{
recursive( node->left );
//do something with this node
recursive( node->right );
}
}
Initial call
node
Iteration 1
node
Iteration 2
node
© M. Gross, ETH Zürich, 2013
9
Check if tree is empty
Check if value of current node is the value we
search
If so: return true;
Else look in child nodes recursively
Stop looking in child nodes when result was found or
there are no more children
Searching an Unsorted Tree
© M. Gross, ETH Zürich, 2013
10
bool rec_search( Node *node, int i )
{
if (node == NULL)
{
return false;
}
if (node->value == i)
{
return true;
}
return rec_search(node->left, i) || rec_search(node->right, i);
}
Searching an Unsorted Tree
© M. Gross, ETH Zürich, 2013
11
Deleting Tree Elements
It's simple to create a memory leak
void delete_element( Node * node )
{
delete node;
}
© M. Gross, ETH Zürich, 2013
12
Deleting Tree Elements
Check for empty trees
Recursively delete all child elements first
After that delete current node
void delete_element( Node *node )
{
if( node != NULL )
{
delete_element( node->left );
delete_element( node->right );
delete node;
}
}
© M. Gross, ETH Zürich, 2013
13
Binary Search Tree
Just like regular trees, but on the left there is always
the smaller key and on the right the larger (or vice
versa)
Makes it much easier to search for a given key
© M. Gross, ETH Zürich, 2013
14
Binary Search Tree Example
Binary search without recursion
Node *next = root;
int search = 6;
while( next != NULL && next->value != search )
{
if( next->value < search )
{
next = next->right;
}
else
{
next = next->left;
}
}
© M. Gross, ETH Zürich, 2013
15
Inserting element into tree
Create new node
Inserting into search tree:
Search for value you want to insert until reaching null
Change the adress of the null pointer to the adress of your new
node
Node *node = new Node;
node->value = 42;
node->right = NULL;
node->left = NULL;
© M. Gross, ETH Zürich, 2013
16
Sorting
Frequently used in software
File Manager: Detail View
Task Manager: Sort by RAM usage
Managing large music collections
Task: Sort a sequence of n data elements
The larger n, the more time t it takes to sort the
sequence
© M. Gross, ETH Zürich, 2013
Efficiency
Algorithm: Selection Bubble Merge Quick
Worst case О(n²) О(n²) O(n log n) O(n²)
Best case О(n²) O(n) O(n log n) O(n log n)
Average case О(n²) О(n²) O(n log n) O(n log n)
© M. Gross, ETH Zürich, 2013
Selectionsort
1. Find the minimum value in the list
2. Swap it with the value in the first position
3. Repeat the steps above for the remainder of the list
(starting at the second position and advancing each
time)
© M. Gross, ETH Zürich, 2013
Bubblesort
Simple sorting algorithm
Repeatedly step through the sequence
Compare each pair of adjacent items and
swap them if they are in the wrong order
The pass through the list is repeated until no swaps
are needed, which indicates that the list is sorted.
© M. Gross, ETH Zürich, 2013
Mergesort
Divide and conquer algorithm
Divide the unsorted list into n sublists, each
containing 1 element (a list of 1 element is
considered sorted).
Repeatedly merge sublists to produce new sublists
until there is only 1 sublist remaining.
© M. Gross, ETH Zürich, 2013
Quicksort
Divide and conquer algorithm. Divide a large list into two smaller sub-lists: the low elements
and the high elements.
Recursively sort the sub-lists
The steps are: Pick an element, called a pivot, from the list.
Reorder the list so that all elements with values less than the pivot
come before the pivot, while all elements with values greater than
the pivot come after it
After this partitioning, the pivot is in its final position. This is called
the partition operation.
Recursively sort the sub-list of lesser elements and the sub-list of
greater elements.
© M. Gross, ETH Zürich, 2013
31
Übung 12
Aufgabe 1: Binärer Suchbaum
void insert ( Node * node , int value )
Falls value den gleichen Wert wie der aktuelle Knoten hat, wurde der
Wert schon eingefügt → Funktion beenden
Falls value kleiner ist als der Wert des Knotens, überprüfe, ob der
Knoten einen linken Teilbaum hat
Falls ja: Rekursiver Funktionsaufruf: insert( node->left , value );
Falls nein: Erstelle einen neuen Knoten, setze ihn als linken Teilbaum
Falls value grösser ist als der Wert des Knotens, überprüfe, ob der
Knoten einen rechten Teilbaum hat
Falls ja: Rekursiver Funktionsaufruf: insert( node->right, value );
Falls nein: Erstelle einen neuen Knoten, setze ihn als rechten Teilbaum