FEN 2011-02-05UCN T&B: IT Technology1 Session 11: Data Structures and Collections Lists ( Array...

FEN 2011-02-05 UCN T&B: IT Technology 1

Session 11: Data Structures and Collections

Lists (Array based, linked)

Sorting and SearchingHashing

TreesSystem.Collections.Generic

• A data structure where elements are organised by position (index).

• ArrayList (List) and LinkedList• Sometimes lists are called sequences.

One fixed size segment in memory.

Each element has a reference to the next element. Hence elements may

be allocated at different memory locations.

numList

ArrayList

• Array-based:– Fixed size (statically allocated).– Always occupies maximum memory.– May grow or shrink dynamically, but that requires halting the

application and allocation of a new array. • Direct access to elements by position (index), otherwise

searching is required.• Inserting and deleting in the middle of the list requires moving

(many) elements.

Linked Lists (LinkedList)

• A linked list consists of nodes representing elements.• Each node contains a value (or value reference) and

a reference (pointer) to the next element:

• The list it self is represented by a reference to the first element, often called head

• The next-reference of the last element is usually null• The linked list is dynamic in size: it grows and shrinks

as needed.• Access by position is slow (may require traversing

the hole list).

• See this Java Example.

Linked Lists (LinkedList)

Figure 4.1a) A linked list of integers; b) insertion; c) deletion

Implementation

private class Node

private object val;

private Node next;

public Node(object v, Node n)

val= v;

next= n;

public object Val

get{return val;}

set{val= value;}

public Node Next

get{return next;}

set{next= value;}

Class Node

Linked Implementation of ADT list

class LinkedList

private class Node //…

Node head,tail;

int n;//number of elements

public LinkedList() {

head= null;

tail= null;

public int Count

get { return n; }

public void AddFront(object o)

Node tmp = new Node(o, null);

if (Count == 0)//list is empty

tail = tmp;

tmp.Next = head;

head = tmp;

public void Print(){//for debugging... Node p = head; //start of list while (p != null) //while not end of list {

Console.WriteLine(p.Val); //print current valuep = p.Next; //set p to next element of the list

Traversing a Linked List

head p

public int FindPos(object o){ //Returns the position of o in the list (counting from 0). //If o is not contained, -1 is return. bool found = false; int i = 0; Node p = head; while (!found && p != null){ if (p.Val.Equals(o)) found = true; else{ p = p.Next; i++; } } if (found) return i; else return -1;}

Finding a Position in a Linked List

Dynamic vs. Static Data Structures

• Array-Based Lists:– Fixed (static) size (waste of memory).– May be able to grown and shrink (ArrayList), but this is very

expensive in running time (O(n))– Provides direct access to elements from index (O(1))– May be sorted. Hence binary search gives fast access (O(log n))

• Linked List Implementations:– Uses only the necessary space (grows and shrinks as needed).– Overhead to references and memory allocation– Only sequential access: access by index requires searching

(expensive: O(n))

numList

Linked List - Variants

• Using a tail-reference

• Using a dummy head node

• Circular

Doubly Linked List

…operations become more complicated …

The Full Monty….(LinkedList)

Search Trees:Dynamic Data Structures with Fast Search

• Binary Trees• Binary Search Trees• General Trees (Composite Pattern)• Balanced Search Trees (2-3 Trees etc.)• B- Trees (external, database index)

Terminology

• General trees:– leaf/external node/terminal– root– internal node– siblings, children, parents, ancestors, descendents– sub trees – the depth or height of a node = number of ancestors– the depth or height of a tree = max depth/height for

any leaf

Binary Trees

• A binary tree can be defined recursively by– Either the tree is empty– Or the tree is composed by a root with left

and right sub trees, which are binary trees themselves

• Note: contrary to general trees binary trees– have ordered sub trees (left and right)– may be empty

Reference Based Implementation

Figure 10.9Traversals of a binary tree: a) preorder; b) inorder; c) postorder

Binary Search Trees

• Value based container:– The search tree property:

• For any internal node: the value in the root is greater than the value in the left child

• For any internal node: the value in the root is less than the value in the right child

– Note the recursive nature of this definition:• It implies that all sub trees themselves are search trees• Every operation must ensure that the search tree

property is maintained (invariant)

Example:A Binary Search Tree Holding Names

Balance Problems (skewed tree):

• Values are inserted in sorted order

InOrder:Traversal Visits Nodes in Sorted Order

Efficiency• insert• retrieve• delete

– All depends on the depth of the tree

– If insertions and deletions are uniformly distributed, then the tree will eventually grow skewed

• O(log n) / O(n)• O(log n) / O(n)• O(log n) / O(n)

Solution:

Balanced Search Trees• Trading time for space:

– In worst case additional space in O(n) is required; but:

– retrieve, insert and delete in O(log n) – also w.c..

• Principle:– A node may hold several keys

(n) and has several children (n+1)

– A node must be at least half filled (n/2 keys)

– Insert and delete can be performed, so the tree is kept balanced in O(logn)

2-3-tree:k = 2

FEN 2011-02-05 UCN T&B: IT Technology29

2-3-Trees (n=2)

FEN 2011-02-05UCN T&B: IT Technology

Retrieve

• Search using the same principle as in binary search trees:– Search the root– If not found, the search recursively in

the appropriate sub tree– Performance is proportional to the

height of the tree– Since the tree is balanced: O(log n)

Insertion

• The insert algorithm must ensure that the 2-3-tree properties are conserved. It goes like this:– Search down through the tree to the appropriate leaf node and

insert– If there is room in the leaf, then we are done– Otherwise split the leaf node into two new leafs and move the

middle value up into the parent node– If there is no room in the parent, then continue recursive until a

node with room is reached, or– Eventually the root is reached. If there is no room in the root,

then a new root is created, and the height of the tree is increased

– Performance depends on the height of the tree (searching down through the tree + in worst case a trip from the leaf to the root rebalancing on the way up)

– That is: O(log n)

Inserting 39 (there is room)

Inserting 38 (there is no room in the leaf)

• Insert any way,

• Split leaf and

• Move middle value up

Inserting 37 (there is room)

Inserting 36 (there is no room)

Split and move up

Inserting 35 , 34 and 33 (there is room)

Deletion• Like insertion – just the other way around:-)

– find the node with the value to be deleted– If this is not a leaf, the swap with its inorder

successor (which is always a leaf - why?), and remove the value

– If there now is too few values (< n/2) in the leaf, then merge the node with a sibling and pull down a value from the parent node

– If there now is too few values in the parent, then continue recursively until there are enough values or the root is reached

– If the root becomes empty, the remove it and the height of the tree is decreased

– Performance: once again: down and up through the tree : O(log n)

Balanced Search Trees• Variants:

– 2-3-trees– 2-3-4-trees– Red-Black-trees– AVL-trees– Splay-trees….

• Is among other used for realisation of the map/dictionary/table ADT

• In Java.Collections: TreeMap and TreeSet

An Alternative to Sorting and Searching: Hashing

• Keys are converted to indices in an array.

• A hash function, h maps a key to an integer, the hash code.

• The hash code is divided by the array size and the remainder is used as index

• If two or more keys gives the same index, we have a collision.

Collision Handling

• Avoiding collisions:– Use a prime as the size of the array:

• Trying to store keys with hash codes 200, 205, 210, 215, 220,.., 595 in an array of size 100 yields three collisions for each key.

• But an array with size 101 results in no collision.

– Choose a good hash function:• this is a (mathematical) discipline of its own

Collision Handling

• Probing is searching for a near by free slot in the array.• Probing may be:

– Linear(h(x)+1, +2, +3, +4,…)

– Quadratic(h(x)+1, +2, +4, +8,…)

– Double hashing– …

Chaining• The array doesn’t hold the element itself, but a reference to a

collection (a linked list for instance) of all colliding elements.• On search that list must be traversed

Efficiency of Hashing• Worst case (maximum collisions):

– retrieve, insert, delete all O(n)

• Average number of collisions depends on the load factor, λ, not on table size

λ = (number of used entries)/(table size)– But not on n.

• Typically (linear probing):

numberOfCollisionsavg = 1/(1 - λ)

• Example: 75% of the table entries in use:

– λ = 0.75:1/(1-0.75) = 4 collisions in average

(independent of the table size).FEN 2011-02-05UCN T&B: IT

Technology43

When Hashing Is Inefficient

• Traversing in key order.• Find smallest/largest key.• Range-search (Find all keys

between high and low).• Searching on something else than

the designated primary key.

See this Java Example

.NET 2:System.Collections.Generics

ICollection<T>

IList<T> LinkedList<T> IDictionary<TKey, TValue>

List<T>Dictionary

<TKey, TValue>SortedDictionary<TKey, TValue>

Index ableArray-based

Balanced search tree Hashtabel

(key, value) -pair

interface:

(i.e. Dictionary)

Specification

class Appl{

IDictionary d;

m= new XXXDictionary();

Application

class:

Dictionary

SortedDictionary

ADT Data Structures and Algorithms

Select and use ADT, i.e.:

Dictionary

Select and use data structure, i.e. SortedDictionary

Knowledge of.

Read and write (use)

specifications

Learning Goals

Exercises• Consider some of our programmes (Banking, Forest,

AndersenAndAsp, for instance).

• Would it be better to use some other collection instead of List?

• Try to chance the implementation in one or more of your programs, so, for instance a hash table is used.

• Implement InsertAt(int index, object element) and RemoveAt(int index) on the linked list.

Time Complexity – Big-”O”

• Investigation of the use of time and/or space of an algorithm

• Normally one looks at– Worst-case (easer to determine)– Only growth rates – not exact measures– Counts the number of some “basic

operations” (a computation, a comparison of to elements etc.).

FEN 2011-02-05 UCN T&B: IT Technology

Big-O notation:

• The complexity of an algorithm is notated with “Big-O”– O(f(n)), n is the size of the problem (number of input

elements, for instance), f is a function that indicates the efficiency of the algorithm, for instance n (the running time is linear in problem size)

– Big-O: is asymptotic (only holds for large values of n)– Big-O: only regards most significant term– Big-O: ignores constants

Examples public int sum (int a, b) {

int sum;sum = a + b;return sum;

What is the basic operation

public int sum (int[] a) {

int sum= 0;for(int i= 0; i<a.length; i++)

sum= sum+a[i];return sum;

What is the basic

operation?

Searching

• Linear search in a sequence with n elements: O(n) (why?)

• Binary search in a sorted sequence with n elements: O(log n) (why?)

• What about sweep algorithms?• Complexity O(n)

Constant and Linear complexity

• Consider an algorithm working on a sequence of length n:– If running time is independent of n, then the time

complexity is constant or O(1)– If we (in worst case) has to do some thing to every

element, then the time complexity is linear or O(n)– There are other possibilities:

• Quadratic O(n2) (some sorting algorithms), O(nlogn) (better sorting algorithms, logarithmic O(log n) (binary search), exponential O(2n) (“difficult” problems like the Towers of Hanoi – more on 3rd semester)

Does it matter…?

“år” means “year”

“døgn” means “day”

Assuming one basic operation in 1 ns (one billion operations pr. sec. – GHz)

A Rule of Thumb• For each nested loop the complexity must be

multiplied with a factor n:

for(int i = 0; i < n; i++) O(n){…}

for(int i = 0; i < n; i++) {

for(int j = 0; j < n; j++) O(n2){…}

public add(int n) {lastIndex++;data[lastIndex] = n;

Both statements are basic and their performanceis independent of the size of the array

public void insert(int i, int newInt) {// make room for newIntfor(int j = data.length; j > i; j++)

data[j] = data[j-1];data[i] = newInt;//insert newInt

The for-loop indicates a time complexity of O(n)

public void sort() { for (int j = 0; j < numbers.size(); j++){ for (int i = 0; i < numbers.size()-1; i++){ if (numbers.get(i) > numbers.get(i+1)) swap(i,i+1);//swaps elements i and i+1 }//end for }//end for }//end sort

Nested for-loops suggestO(n2)

FEN 2011-02-05UCN T&B: IT Technology1 Session 11: Data Structures and Collections Lists ( Array...

Documents

Ti 223 Fen

Ka 01069 Fen

Handbook of Frequency Stability Analysis · ·Semiconductor Electronics ·Radio-Frequency Technology1 ·Electromagnetic Technology1 ... ·Electron and Optical Physics ·Atomic Physics

Barcode latest technology1

Inventory for Rare and Uncommon Plants in Fen and Fen-like … · 2017-04-12 · Inventory for Rare and Uncommon Plants . in Fen and Fen-like Ecosystems on . Okanogan-Wenatchee National

PIERALISI Decanter Technology1

Clyde Fen - sapaastewards.comsapaastewards.com/PAInfo/NaturalAreas/PNT & CNT/Clyde Fen/Clyde Fen info.pdf · Clyde Fen Faces New Challenges Clyde Fen Natural Area is a Protective

Telnet/SSH: Connecting to Hosts Internet Technology1

SPE 156189 ESP Retrievable Technology1

Device Fabrication Technology1 - Chenming Hu59 3 Device Fabrication Technology1 CHAPTER OBJECTIVES While the previous chapters explain the properties of semiconductors, this chapter

Education Technology1

PV Technology1

Crazy Quilts And Patchwork Technology1

Innovative technology1

Fen Neonate

MODERN BLAST FURNACE IRONMAKING TECHNOLOGY1

Mirada FEN

Instructional Technology1

SmartDevices 8/12/2011FaST - Florida Institute of Technology1

CMOS Fabrication Technology1