CSCE 210 Data Structures and Algorithms

1
CSCE 210Data Structures and Algorithms

• Prof. Amr Goneid
• AUC
• Part R3. Dictionaries(1) Key Tables and Lists

2
Dictionaries(1)Key Tables and Lists

• The Key Table
• ADT Key Table
• The Key Table Class Definition
• Key Table Class implementation
• Example Application
• The Linked List
• ADT Linked List
• The Linked List Class Definition
• Linked List Class implementation
• Example Application

3
1. The Key Table

• Key Table Abstraction
• Key Table a container of data in the form of a
  linear configuration of elements in which we can
  insert and delete nodes in any order. It also
  supports search by content (key), and can
  represent a dictionary ADT.
• Element a container for one key and associated
  data item
• Current Element special element in the table,
  indicated by a pointer to the current position.
• EmptyKey a special key value to indicate that
  the table slot is empty. Initially all table
  positions are empty.

4
Ordered Key Table Class

• We will construct a class Ktable whose objects
  are key tables. They will be implemented as
  dynamic arrays.
• The data members will be the elements and a
  pointer to these elements.
• An element contains a key field and a data field.
  Search is by content (key)
• The table will be ordered on the key field.

5
(a) ADT Key Table

• Key Table Data Members
• Elements. Each element has
• Data or information field of type dataType.
• A key of type keyType
• Others
• T, a pointer to a dynamic array of elements
• P, a pointer to the current element
• MaxSize, The maximum size (Capacity) of the
  table
• csize, The current size of table (no. of filled
  slots)
• Empty, A special key value to indicate an empty
  slot

6
Element Specification

• // The element structure can be specified as a
  Class
• // in the private part of the main Ktable class.
• class element // Hidden from user
• public
• keyType key // key
• dataType data // Data
• // end of class element declaration

7
Key Table Operations

• construct Create table
• emptyTable (E) Initialize table and fill with
  empty symbol
• tableIsEmpty ? bool return True if table is
  empty
• tableIsFull ? bool return True if table is full
• occupancy ? int return the current no. of
  elements in the table

8
Key Table Operations

• updateData (d) to update the data portion of
  the current element to contain d assume the
  current position is nonempty.
• retrieveData (d) to return the data (d) in the
  current element assume the current position is
  nonempty.
• deleteCurrent delete the current element.
  Assume the current position is nonempty initially.

9
Key Table Operations

• search (k) ? bool Search the table for the slot
  with key part that matches (k). If found, set p
  to the slot and return True, else return false
• orderInsert (k,d) insert an element in a
  position that maintains an ascending order of the
  key portion.
• traverse traverse table to print key and info
  fields.

10
(b) Key Table Class Definition

• // File Ktable.h
• // Definition of Ktable Template Class
• ifndef KTABLE_H
• define KTABLE_H
• // Specification of the class
• template ltclass keyType, class dataTypegt
• class Ktable
• public

11
Key Table Class Definition

• // Member Functions
• Ktable(int nelements 128) // Constructor
• Ktable() // Destructor
• // Functions Prototype Definitions
• void emptyTable(const keyType )
• bool tableIsEmpty() const
• bool tableIsFull() const

12
Key Table Class Definition

• int occupancy() const
• void updateData(const dataType )
• void retrieveData(dataType ) const
• void deleteCurrent()
• bool search(const keyType )
• bool orderInsert(const keyType ,
• const dataType )
• void traverse() const

13
Key Table Class Definition

• private
• // Element Class
• class element
• public
• keyType key // key
• dataType data // Data
• // end of class element declaration

14
Key Table Class Definition

• element T // Pointer to Storage Array
• int p // Pointer to current element
• // Maximum and Current Sizes
• int MaxSize, csize
• keyType Empty // Empty symbol
• // end of Ktable Class definition
• endif // KTABLE_H
• include "Ktable.cpp"

15
(c) Implementation Files

• Full implementation of the Key Table
• class is found at
• http//www.cse.aucegypt.edu/csci210/codes.zip

16
Key Table Class Implementation

• Note
• Since the keys are kept in ascending order, it is
  possible to use the binary search algorithm in
  the search function.
• The implementation of this option is left as an
  exercise.

17
(d) Example Application

• An ordered list of characters and their
  frequencies in a string
• Given a string, build a List of characters and
  their count in the string. The list is ordered
  alphabetically on the characters.

18
Ordered List

• // File KTabletest.cpp
• // Applies Ktable Class
• include ltiostreamgt
• include ltstringgt
• using namespace std
• include "Ktable.h
• int main()
• Ktableltchar , intgt ctable
• string s
• char c
• int i, count
• bool keyfound

19
Ordered List

• // Read a string
• cout ltlt "Enter a string" ltlt endl
• getline(cin,s)
• cout ltlt s ltlt endl // display it
• ctable.emptyTable(char(126))
• for (i 0 i lt s.length() i) // for every
  character
• c toupper(s.at(i))
• // Search for character in the table
• keyfound ctable.search (c)

20
Ordered List

• if (keyfound) // if found
• ctable.retrieveData(count) // get data
• count // increment count
• ctable.updateData(count) // store back
• // Not found, a new node is inserted
• else ctable.orderInsert(c,1)

21
Ordered List

• // print characters and their frequencies
• ctable.traverse()
• cout ltlt ctable,occupancy() ltlt endl // current
  table size
• // empty table
• ctable.emptyTable(char(126))
• // the size now should be zero
• cout ltlt ctable.occupancy() ltlt endl
• return 0

22
Sample Output

• Enter a string
• The Rain in Spain
• The Rain in Spain
• 3
• A 2
• E 1
• H 1
• I 3
• N 3
• P 1
• R 1
• S 1
• T 1
• 10
• 0
• Press any key to continue

23
2. The Linked List

• Linked List Abstraction
• Linked List a container of data in the form of a
  linear configuration of nodes in which we can
  insert and delete nodes in any order. Each Node
  is linked to its successor in the list. If it
  also supports search by contents, it can
  represent a dictionary ADT.
• Node a container for one data item and has a
  direct relationship with at most two other nodes,
  its predecessor (if any) and its successor (if
  any).
• Head node or first node is the only node without
  a predecessor.
• Current node special node in the list, indicated
  by the current position.
• Previous Node the predecessor of the current node

24
Ordered Linked List Class

• We will construct a class List whose objects
  are linked lists. They will be implemented as
  dynamic lists.
• The data members will be the nodes and the
  pointers to these nodes.
• A node contains a key field and a data field.
  Search is by content (key)
• The list will be ordered on the key field.

25
(a) ADT Linked List

• Linked List Data Members
• Nodes. Each node has
• Data or information field of type dataType.
• A key of type keyType
• Link field (next) , a pointer to next node
• Pointers
• head, a pointer to the first node
• cursor, a pointer to the current node
• prev, a pointer to the previous node.

26
Data Members
Current

NULL
Last
head
First
prev
cursor
key
data
next
27
Node Specification

• // The linked structure for a node can be
• // specified as a Class in the private part of
• // the main linked list class.
• class node // Hidden from user
• public
• keyType key // key
• dataType data // Data
• node next // pointer to next node
• // end of class node declaration
• typedef node NodePointer
• // Pointers
• NodePointer head, cursor, prev

28
Linked List Operations

• Notation Meaning
• head the head pointer
• cursor pointer to current node
• prev pointer to predecessor node
• pnew pointer to a new node
• d item with the same type as the
• data portion of a node
• k item with type as the key portion
• of the node
• b boolean value
• L Length of list

29
Linked List Class Operations

• construct initialize list to empty
• listIsEmpty ? b return True if list is empty
• curIsEmpty ? b return True if current position
  is empty
• toFirst to make the current node the first
  node if list is empty, the current position is
  still empty
• atFirst ? b to return True if the current node
  is the first node or if the list and the current
  position are both empty.

30
Linked List Class Operations

• advance to advance to next node. Assume the
  current position is nonempty initially.
• toEnd to make the current node the tail node
  if list is empty, the current position is still
  empty
• atEnd ? b to return True if the current node is
  the tail node or if the list and the current
  position are both empty.
• listSize ? L to return the size of the list
• updateData (d) to update the data portion of
  the current node to contain d assume the current
  position is nonempty.

31
Linked List Class Operations

• retrieveData ? d to return the data in the
  current node assume the current position is
  nonempty.
• insertFirst (k,d) insert a node with key (k)
  and data (d) at the head of the list the new
  node becomes the current node.
• insertAfter (k,d) insert a node after the
  current node without changing the current
  position assume the current position is nonempty
  in a non-empty list.
• insertBefore (k,d) insert a node before the
  current node current position becomes the new
  node

32
Linked List Class Operations

• insertEnd(k,d) insert a node at the end of the
  list, current position becomes the new node.
• deleteNode delete the current node and set the
  current position to the next node if the current
  node is the last node initially, the current
  position becomes empty assume the current
  position is nonempty initially.
• deleteFirst delete the first node and set the
  current position to the next node if it was
  initially the only node, the current position
  becomes empty

33
Linked List Class Operations

• deleteEnd delete the last node and set the
  current position to empty.
• makeListEmpty delete whole list
• search (k) ? b search the list for the node
  with key part that matches (k). If found, set
  cursor to the node and return True, else return
  false and the current position becomes empty.

34
Linked List Class Operations

• orderInsert (k,d) insert a node in a position
  that maintains an ascending order of the key
  portion of the nodes.
• traverse traverse list to print key and info
  fields.
• The Linked List will be implemented as a
• template class to allow different types for
• the key and data fields.

35
(b) Linked List Class Definition

• // File List.h
• // Definition of Simple Linked List Template
  Class
• ifndef LIST_H
• define LIST_H
• // Specification of the class
• template ltclass keyType, class dataTypegt
• class List
• public

36
List Class Header File

• // Member Functions
• // Create an empty List
• List()
• // Class Destructor
• List()
• // Functions Prototype Definitions
• bool listIsEmpty() const
• bool curIsEmpty() const
• void toFirst()
• bool atFirst() const
• void advance()

37
List Class Header File

• void toEnd()
• bool atEnd() const
• int listSize() const
• void updateData (const dataType )
• void retrieveData (dataType ) const
• void insertFirst (const keyType , const
  dataType )
• void insertAfter (const keyType , const
  dataType )
• void insertBefore (const keyType , const
  dataType )
• void insertEnd (const keyType , const dataType
  )
• void deleteNode()
• void deleteFirst()

38
List Class Header File

• void deleteEnd()
• void makeListEmpty()
• bool search (const keyType )
• void orderInsert(const keyType , const dataType
  )
• void traverse()

39
List Class Header File

• private
• // Node Class
• class node
• public
• keyType key // key
• dataType data // Data
• node next // pointer to next node
• // end of class node declaration

key
data
next
40
List Class Header File

• typedef node NodePointer
• // Pointers
• NodePointer head, cursor, prev
• // End of class List declaration
• endif // LIST_H
• include "List.cpp"

41
(c) Implementation Files

• Full implementation of the Linked List
• class is found at
• http//www.cse.aucegypt.edu/csci210/codes.zip

42
(d) Example Application

• An ordered list of characters and their
  frequencies in a string
• Given a string, build a List of characters and
  their count in the string. The list is ordered
  alphabetically on the characters.

43
Ordered List

• // File ListAppl.cpp
• // Applies List Class Ordered linked list
• include ltiostreamgt
• include ltstringgt
• using namespace std
• include "List.h"
• int main()
• Listltchar, intgt clist
• string s
• char c
• int i, count
• bool keyfound

44
Ordered List

• // Read a string
• cout ltlt "Enter a string" ltlt endl
• getline(cin,s)
• cout ltlt s ltlt endl // display it
• for (i 0 i lt s.length() i) // for every
  character
• c toupper(s.at(i)) // convert to upper case
• // Search for character in the list
• keyfound clist.searchForKey(c)

45
Ordered List

• if (keyfound) // if found
• clist.retrieveData(count) // get data in
  node
• count // increment count
• clist.storeData(count) // store back
• // Not found, a new node is inserted
• else clist.orderInsert(c,1)

46
Ordered List

• // print characters and their frequencies
• clist.traverse()
• cout ltlt clist.listSize() ltlt endl // current
  list size
• //clist.makeListEmpty() // empty list, or
• clist.List() // free memory
• // the size now should be zero
• cout ltlt clist.listSize() ltlt endl
• return 0

47
Sample Output

• Enter a string
• The Rain in Spain
• The Rain in Spain
• 3
• A 2
• E 1
• H 1
• I 3
• N 3
• P 1
• R 1
• S 1
• T 1
• 10
• 0
• Press any key to continue

48
Learn on your own about

• Array-based implementation of Linked Lists