chapter 8: data abstractions senem kumova metin. 8-2 chapter 8: data abstractions 8.1 basic data...
Post on 12-Jan-2016
236 Views
Preview:
TRANSCRIPT
Chapter 8:Chapter 8:Data AbstractionsData Abstractions
Senem Kumova Metin
8-2
Chapter 8: Data Abstractions• 8.1 Basic Data Structures– Arrays– Lists, Stacks, Queues– Trees
• 8.2 Related Concepts– Static versus dynamic structures– Pointers
• 8.3 Implementing Data Structures
8-3
Data Structures• A data structure is a particular way of storing and
organizing data in a computer so that it can be used efficiently
• Basic Data Structures– Homogeneous array– Heterogeneous array– List• Linked list• Stack• Queue
– Tree
8-4
Basic Data Structures : Arrays• Homogeneous array: The block of data items whose entries
are of the same type
– int array1[6]; // includes 6 integers– float * array2 =new float [6]; // includes 6 floating-point numbers
• Heterogeneous array: The block of data items that might be of different types. (The items within block are usually called components)
– class Employee { public : int ID; string name;};Employee array[8];
Basic Data Structures : Lists• List : A collection whose entries are arranged sequentially.
– The beginning of the list is head.– The other end of the list is tail.
8-5
data next data next data next NULL
head
class Linked_list { int data; Linked_list*next; };
Linked_list * head;
tail
Basic Data Structures : Stacks• Stack : A list in which entries are inserted or removed only from head.
– The head of the stack is called top of the stack– Bottom or base: The tail of list (stack)– Inserting a new entry is called pushing.– Deleting an entry is called popping
– Last in first out (LIFO) : The last entry placed on a stack will always be the first entry to be removed
8-6
top
Basic Data Structures : Queue• Queue : A list in which entries are inserted only at the tail and removed only from head.
– First in first out (FIFO) : The first entry placed on a queue will always be the first entry to be removed
8-7
8-8
Figure 8.1 Lists, stacks, and queues
8-9
Figure 8.2 An example of an organization chart
8-10
Basic Data Structures : Tree• Tree: A collection of data whose entries have a
hierarchical organization
– Node: An entry in a tree– Root node: The node at the top– Terminal or leaf node: A node at the bottom
Root
Leaf nodes
8-11
Basic Data Structures : Tree (cont.)– Parent: The node immediately above a
specified node ( 3 is the parent of 1 and 6 )
– Child: A node immediately below a specified node ( 14 is a child of 10)
– Ancestor: Parent, parent of parent, etc. (10 is ancestor of 14 and 13)
– Descendent: Child, child of child, etc.(13 is a decendent of 14,10 and 7)
– Siblings: Nodes sharing a common parent (4 and 7 are siblings)
8-12
Basic Data Structures : Tree (cont.)• Binary tree: A tree in which every node has at most two
children
• Depth (The depth of tree): The number of nodes in longest path from root to leaf
• Subtree:The node (except root node) with the nodes below it
A subtree
Basic Data Structures : Tree (cont.)• The size of a binary tree is the
number of nodes in it– This tree has size 9
• The depth of a node is its distance from the root– a is at depth zero– e is at depth 2
• The depth of a binary tree is the depth of its deepest node– This tree has depth 3
a
b c
d e f g
h ı
8-14
Figure 8.3 Tree terminology
8-15
Related Concepts
• Static Data Structures: Size and shape of data structure does not change (compile time)
• Dynamic Data Structures: Size and shape of data structure can change (run time)
• Pointers: Used to locate data
8-16
Storing Arrays• Homogeneous arrays– Row-major order versus column major order– Address polynomial
• Heterogeneous arrays– Components can be stored one after the other in
a contiguous block– Components can be stored in separate locations
identified by pointers
8-17
Figure 8.5 The array of temperature readings stored in memory starting at address x
(Homogenous Array)
8-18
Figure 8.6 A two-dimensional array with four rows and five columns stored in row major order
19
Storage mapping function : ROW MAJOR ORDER
• the mapping b/w pointer values and array indices • EXAMPLE:
int d [3];d[i]*(&d[0]+i) *(d+i)
• EXAMPLE: int a [3] [4];a[i][j] *(&a[0][0]+4*i+j)
*(a+4*i+j) // address polynomial
• If indexing starts from 1 then x+ c*(i-1)+(j-1)
a[0][0]a[0][1]a[0][2]a[0][3]a[1][0]a[1][1]a[1][2]a[1][3]a[2][0]a[2][1]a[2][2]a[2][3]
8-20
Figure 8.7 Storing the heterogeneous array Employee
8-21
Storing Lists
• Contiguous list: List stored in a homogeneous array (Example: int a [10])
• Linked list: List in which each entries are linked by pointers– Head pointer: Pointer to first entry in list– NIL pointer: A “non-pointer” value used to
indicate end of list
8-22
Figure 8.8 Names stored in memory as a contiguous list
8-23
Figure 8.9 The structure of a linked list
8-24
Figure 8.10 Deleting an entry from a linked list
8-25
Figure 8.11 Inserting an entry into a linked list
8-26
Figure 8.19 A procedure for printing a linked list
8-27
Exercise : Question 8 (pg.428) Linked list
• The table represents a position in memory. Each entry in the list consists of two cells: The first contains a letter of alphabet; the second contains a pointer to the next list entry.
• Alter the pointers so that the letter N is no longer in the list then replace the letter N with the letter G and alter the pointers so that the new letter appears int he list in its proper place in alphabetical order
8-28
Storing Stacks and Queues
• Stacks usually stored as contiguous lists (arrays) but also may be implemented using linked lists
• Queues usually stored as Circular Queues– Stored in a contiguous block in which the first
entry is considered to follow the last entry– Prevents a queue from crawling out of its allotted
storage space
8-29
Figure 8.12 A stack in memory
Exercise :STACKS
x= pop(&n);
push(11,&n);
x= pop(&n);x= pop(&n);x= pop(&n);
push(3,&n);push(2,&n);
x= pop(&n); }
main(){
stack n; int x;reset(&n);
push(4,&n);push(5,&n);push(3,&n);push(2,&n);push(1,&n);
8-31
Figure 8.13 A queue implementation with head and tail pointers
// insert from tail//remove from head
enqueue(A)
enqueue(B)
enqueue(C)
X= dequeue()
enqueue(D)
Y= dequeue()
enqueue(E)
8-32
Figure 8.14 A circular queue containing the letters P through V
8-33
Storing Binary Trees• Linked structure– Each node = data cells + two child pointers– Accessed via a pointer to root node
struct node {int data; struct node * left;struct node * right; };
• Contiguous array structure (without pointers)– A[1] = root node– A[2],A[3] = children of A[1]– A[4],A[5],A[6],A[7] = children of A[2] and A[3]
8-34
Figure 8.15 The structure of a node in a binary tree
8-35
Figure 8.16 The conceptual and actual organization of a binary tree using a linked
storage system
8-36
Figure 8.17 A tree stored without pointers
8-37
Figure 8.18 A sparse, unbalanced tree shown in its conceptual form and as it would be stored
without pointers
8-38
Manipulating Data Structures
• Ideally, a data structure should be manipulated solely by pre-defined procedures.
– Example: • A stack typically needs at least push and pop
procedures.• A queue typically needs at least enqueue and dequeue procedures.
– The data structure along with these procedures constitutes a complete abstract tool.
top related