Basic data-structures-v.1.1
Preview:
DESCRIPTION
Basic types of data structures. Implementation in Java.
Citation preview
- 1. Lists, Stacks, Queues, Trees, Hash Tables Basic Data
Structures
- 2. Contents
- Abstract Data Types (ADT)
- Trees Terminology and Types
- Dictionaries HashMap Class
- 3. Abstract Data Types
- An Abstract Data Type (ADT) is a data type together with the
operations, whose properties are specified independently of any
particular implementation
-
- ADT are set of definitions of operations (like the interfaces
in Java)
-
- Can have several different implementations
-
- Different implementations can have different efficiency
- 4. Basic Data Structures
-
- Stacks: LIFO (last in first out) structure
-
- Queues: FIFO (first in first out) structure
-
- Contain pairs (key, value)
-
- Hash tables: Unordered lists which use a hash function to
insert and search
- 5. What Is a List?
- 6. The List ADT
- List is linear data structure (container) that contains a
sequence of elements (objects)
-
- Objects are arranged linearly
- Can be implemented in several ways
-
- Dynamically (linked implementation)
-
- Using the ArrayList class
- 7. Static and Linked Lists
- 8. Static List
-
- Provide direct access by index
-
- Usually has limited capacity
-
-
- Resizing is slow operation
0 1 2 3 4 5 6 7 8 11 7 18 14 L 5 2 33 47 3
- 9. Linked List
- Dynamic (pointer-based) implementation
-
- Singly-linked and doubly-linked
- Singly-linked List - each Object has value and next fields
11 next 7 next 18 next 14 next head null
- 10. Linked List (2)
- Doubly-linked List - each Object has value , next and prev
fields
11 next prev head tail 7 next prev 18 next prev 14 next prev null
null
- 11. Using the ArrayList class
- 12. The java.util.ArrayList Class
- Implements the list data structure using an array whose size is
dynamically increased as needed
-
- Allocates in advance buffer space for new elements (for better
performance)
-
- add(Object) adds an object at the end
-
- add (index , Object) inserts an object to the list at a
specified position
- size() returns the number of elements
- 13. The ArrayList Class
-
- remove(Object) removes the first occurrence of a specific
object
-
- remove( index) removes the element at the specified
position
-
- clear() removes all elements
- 14. The ArrayList Class(2)
- ArrayList can contain any data type
-
- Elements are added directly
-
- Typecasting is required when extracting elements unless we use
Generics
List list = new ArrayList(); list. a dd(5); // Add integer value
list. a dd("some string"); // Add string value int firstElement =
((Integer)(list.get(0))).intValue(); String secondElement =
(String)list.get(1); Integer[] arr = list.toArray(new
Integer[list.size()]);
- 15. What are Generics
- Generics are classes or interfaces that can be instantiated
with a variety of types
-
- They have 1 or more formal type parameters
-
- When using a generic you specify an actual type
List list = new ArrayList(); String s = new String(" li1 ");
list.add(s); list.add(5); // This will cause compile time error
Specifies that String is actual type of this List 5 is not a
String
- 16. Primes[n..m] Example
- Find all prime numbers in a specified interval
public static ArrayList getPrimes(int start, int end) { List
primesList = new ArrayList(); for (int num = start; num 0) { String
personName = stack.pop(); System.out.println(personName); } }
- 30. Live Demo Using the Stack class
- 31. Matching Brackets Example
- We are given an arithmetical expression with brackets that can
be nested. We want to extract all parts of the expression that are
closed in brackets.
-
- Example: 1 + (3 + 2 - (2+3) * 4 - ((3+1)*(4-2)))
-
-
- (3 + 2 - (2+3) * 4 - ((3+1)*(4-2)))
- 32. Matching Brackets Solution with a Stack String expression =
"1 + (3 + 2 - (2+3) * 4 - ((3+1)*(4-2)))"; Stack stack = new
Stack(); for (int i = 0; i < expression.length(); i++) { char ch
= expression.charAt(i); if (ch == '(') { stack.push(i); } else if
(ch == ')') { int startIndex = (int) stack.pop(); String contents =
expression.substring(startIndex, i + 1);
System.out.println(contents); } }
- 33. Live Demo Matching Brackets
- 34. What is a Queue?
- 35. The Queue ADT
- FIFO (first in first out) structure
- Elements inserted at tail (enqueue)
- Elements removed from head ( dequeue )
- Useful in many situations
-
- Processing jobs, print queues, messages
- Can be implemented in several ways
-
- Dynamically (using pointers)
-
- Using the LinkedList class
- 36. Static Queue
- Static (array-based) implementation
-
- Queue has limited (fixed) capacity
-
- Implement as a circular array
-
- Maintain Q.Capacity and Q.Length
-
- Has head and tail variables, pointing
0 1 2 3 4 5 6 7 8 11 7 18 14 Q head tail
- 37. Linked Queue
- Dynamic (pointer-based) implementation
-
- Each object has value and next fields
-
- Dynamically create and delete objects
11 next 7 next 18 next 14 next head tail null
- 38. Using the LinkedList class
- 39. The LinkedList Class Overview
- Implements the queue data structure using a doubly-linked
list
-
- offer(object) adds an object to the end of the queue
-
- poll() removes and returns the object at the beginning of the
queue
-
- peek() returns the object at the beginning of the queue without
removing it
- 40. The LinkedList Class More Methods
-
- size() gets the number of elements contained in the queue
-
- clear() removes all elements from the queue
-
- contains(object) determines whether given element is in the
queue
-
- toArray () converts the queue to array
- 41. Examples Using the LinkedList class
- 42. Queue Example
- Using offer () and poll () methods
public static void main(String[] args) { Queue queue = new
LinkedList(); queue.offer("Message One"); queue.offer("Message
Two"); queue.offer("Message Three"); queue.offer("Message Four");
queue.offer("Message Five"); while (queue.size() > 0) { String
msg = queue.poll(); System.out.println(msg); } }
- 43. Live Demo Using the LinkedList class
- 44. Sequence N, N+1, 2*N
- We are given the sequence:
-
- S = N, N+1, 2*N, N+2, 2*(N+1), 2*N+1, 4*N, ...
- Write a program to find the first index of given number P
-
- S = 3, 4, 6, 5, 8, 7, 12, 6, 10, 9, 16, 8, 14, ...
+1 *2 +1 *2 +1 *2
- 45. Sequence Solution int n = 3; int p = 16; Queue queue = new
LinkedList(); queue.offer(n); int index = 0; while (queue.size()
> 0) { index++; int current = queue.poll(); if (current == p) {
System.out.println("Index = " + index); return; }
queue.offer(current + 1); queue.offer(2 * current); }
- 46. Live Demo Sequence N, N+1, 2*N
- 47. Definition, Types of Trees What is Tree?
- 48. Trees
-
- Node, edge, root, child, children, siblings, parent, ancestor,
descendant, predecessor, successor, internal node, leaf, depth,
height
17 15 14 9 6 5 8 Height = 2 Depth 0 Depth 1 Depth 2
- 49. Binary Trees
- Binary trees: most used form
-
- Each node has at most 2 children
10 17 15 9 6 5 8 right child left subtree root left child
- 50. Binary Trees Traversals
- Traversal can be done in pre-order, in-order and
post-order
- Pre-order: left, root, right 6, 9, 12, 17, 19, 25
- In-order: root, left, right 17, 9, 6, 12, 19, 25
- Post-order: left, right, root 6, 12, 9, 25, 19, 17
17 19 9 6 12 25
- 51. Binary Search Trees
- Binary search trees are ordered
- A binary tree in which binary-search-tree property holds:
-
- For each node x in the tree
-
-
- All the elements of the left subtree of x are x
-
-
- All the elements of the right subtree of x are > x
- Binary search trees can be balanced
-
- Balanced trees has low height
- 52. Binary Search Trees
- Example of binary search tree
- If the tree is balanced, adding, searching, and deletion
operations take approx. log( n ) steps
17 19 9 6 12 25
- 53. What is a Dictionary (Map)?
- 54. The Dictionary (Map) ADT
- The ADT "dictionary" maps key to values
-
- Also known as "map" or "associative array"
-
- Contains a set of (key, value) pairs
- Dictionary ADT operations:
- Can be implemented in several ways
-
- List, array, hash table, balanced tree, ...
- 55. What is a Hash Table?
- 56. Hash Table
- A hash table is an array that holds a set of (key, value)
pairs
- The process of mapping a key to a position in a table is called
hashing
0 1 2 3 4 5 m-1 ... ... ... ... T h( k ) ... ... ...
- 57. Hash Functions and Hashing
- A hash function maps keys to positions
- The hash table has m slots, indexed from 0 to m-1
- For any value k in the key range and some hash function h
0 1 2 3 4 5 m-1 ... ... ... ... T h( k ) ... ... ...
- 58. Mapping Functions
- Perfect hashing function (PHF)
-
- h(k) : one-to-one mapping from each key k to integers in [ 0 ,
m -1 ]
- The PHF maps each key to a distinct integer within some
manageable range
- Finding a perfect hashing function is in most cases
impossible
-
- Hash functions h(k) map most of the keys onto unique integers,
but not all
- 59. Collisions in Hash Tables
- Collision is the situation when different keys can have the
same hash value
-
- h(k 1 ) = h(k 2 ) for k 1 k 2
- When the number of collisions is sufficiently small, the hash
tables work quite well (fast)
- Several collisions resolution strategies
-
- Chaining in a list, re-hashing, using the neighboring slots
(linear probing), ...
- 60. Collision Resolution - Chaining h( "Pesho" ) = 4 h( "Lili"
) = n-1 h( "Kiro" ) = 2 h("Mimi") = 1 h("Ivan") = 2 null T 0 1 2 3
4 5 n-1 null ... null chaining Kiro Ivan collision null Mimi null
Lili null Pesho null
- 61. Using the Hash Map class
- 62. The Hash Map Class Overview
- Implements the ADT dictionary as array dynamically increased as
needed
- Contains a collection of key-and-value pairs arranged by the
hash code of the key
- Collisions are resolved by chaining
- The Hash Map class relies on
-
- Object. h ashCode() method for calculating the hash codes of
the elements
-
- Object. equals( ) method for comparing elements
- 63. The Hash Map Class Major Operations
-
- put (key , value) adds an element with the specified key and
value into the hash table
-
- remove(key ) removes the element with the specified key from
the hash table
-
- get(key ) returns element by key
-
- clear() removes all elements from the hash table
- 64. The Hash Map Class More Operations
-
- size() returns the number of elements
-
- c ontains Key (key ) determines whether the hash table contains
given key
-
- c ontainsValue(value) determines whether the hash table
contains given value
-
- keySet( ) returns a set of the keys
-
- values() returns a collection of the values
- 65. Examples Using the HashMap Class
- 66. Hashtable - Example Map studentsMarks = new HashMap();
studentsMarks.put("Ivan", 4); studentsMarks.put("Peter", 6);
studentsMarks.put("Maria", 6); studentsMarks.put("George", 5); int
peterMark = studentsMarks.get("Peter");
studentsMarks.remove("Peter"); System.out.println("Is Peter in the
hash table: " + studentsMarks.containsKey("Peter")); for (Map.Entry
studentMark : studentsMarks.entrySet()) { System.out.printf("%s
--> %d%n", studentMark.getKey(), studentMark.getValue()); }
- 67. Live Demo Using the HashMap Class
- 68. Counting Words in a Text String s = "Welcome to our Java
course. In this " + "course you will learn how to write simple " +
"programs in Java"; String[] words = s.split("[ ,.]"); Map
wordsCount = new HashMap(); for (String word : words) if
(!"".equalsIgnoreCase(word)) { int count = 1; if
(wordsCount.containsKey(word)) count += wordsCount.get(word);
wordsCount.put(word, count); } for (String word :
wordsCount.keySet()) System.out.printf("%s --> %d%n", word,
wordsCount.get(word));
- 69. Live Demo Counting Words in a Text
- 70. Summary
- ADT are defined by list of operations independent of the
implementation
- The basic data structures in the computer programming are
-
- List ArrayList class in Java
-
- Stack Stack class in Java
-
- Queue LinkedList class in Java
-
- Trees can be binary, balanced, search trees, etc.
-
- Dictionaries Hash Map class in Java
- 71. Basic Data Structures Questions?
- 72. Exercises
- Write a program that reads from the console a sequence of
positive integer numbers. The sequence ends when the number 0 is
entered. Calculate and print the sum and average of the elements of
the sequence. Use the ArrayList class.
- Write a method that finds the longest subsequence of equal
numbers in given array. Use the ArrayList class.
- Write a program that reads N integers from the console and
reverses them using a stack. Use the Stack class.
- 73. Exercises (2)
- We are given the following sequence:
- Write a program to print its first 100 elements for given N.
Use the LinkedList class.
- Sequence: 2, 3, 5, 4, 4, 7, 5, 6, 11, 7, 5, 9, 6, ...
- 74. Exercises (3)
- Write a program that reads a sequence of integers ending with 0
and sorts them in an increasing order. Use the ArrayList
class.
- Write a program that finds in a given array of integers how
many times each of them presents. Use Hash Map and ArrayList .
-
- Example: array = {3, 4, 4, 2, 3, 3, 4, 3, 2}
- 75. Exercises (4)
- Write a program that removes from a given sequence all negative
numbers.
- Write a program that removes from a given sequence all the
numbers that present in it odd number of times. Example:
-
- {4, 2, 2, 5, 2, 3, 2, 3, 1, 5, 2} {5, 3, 3, 5}
- By definition the majorant of an array is a value that occur in
the least half of the elements of the array. Write a program to
find the majorant of given array (if any). Example:
-
- {2, 2, 3, 3, 2, 3, 4, 3, 3} 3
- 76. Exercises (7)
- Write a program that counts how many times each word from a
given text presents in it. The casing differences should be
ignored. The result words should be ordered by their number of
occurrences in the text. Example:
This is the TEXT. Text, text, text THIS TEXT! Is this the
text?
- 77. Exercises (5)
- We are given numbers N and M and the following operations:
- Write a program that finds the shortest sequence of operations
from the list above that starts from N and finishes in M
- 78. Exercises (6)
- We are given a labyrinth of size N x N. Some of its cells are
empty (0) and some are full (x). We can move from an empty cell to
another empty cell if they share common wall. Given a starting
position (*) calculate and fill in the array the minimal distance
from this position to any other cell in the array. Use "u" for the
unreachable cells. Example:
0 0 0 x 0 x 0 x 0 x 0 x 0 * x 0 x 0 0 x 0 0 0 0 0 0 0 x x 0 0 0 0 x
0 x 3 4 5 x u x 2 x 6 x u x 1 * x 8 x 10 2 x 6 7 8 9 3 4 5 x x 10 4
5 6 x u x