Basic Data Structures

Basic Data Structures • Elementary Structures • Arrays • Lists • Sequence Structures • Stacks • Queues • Search Structures • Binary search Tree • Hash Tables Graphs Data Structures

What is a data structure? A data structure (DS) is essentially a device that collects and allows the manipulation of data within the structure. • DS = Model (idea) + operations • Example: A Stack • Model: A Stack • Operations: • Add to stack • Remove from stack • check for empty • look into stack • empty the stack. • Functionality specified using interface • public interface Stack{ • public void push(Object o); • public Object pop(); • public Object peek(); • public boolean isEmpty(); • public void makeEmpty(); • } • A DS is independent of • its implementation. • In Java, use interface to • specify operations of DS • The interface describes the • operation, but says nothing • about its implementation. Data Structures

Stack Structure An array implementation of a Stack max-1 public class StackArray impements Stack{ private Objects[] s; private int top; public StackArray(int size){ s = new Object[size]; top = -1; } public void push(Object item){ s[++top] = item;} public Object pop(){return s[top--];} public Object peek(){return s[top];} public boolean isEmpty(){return (top==-1);} public void makeEmpty(){top = -1;} public boolean isFull(){return (top==s.length-1);} } top 3 3 2 1 0 Data Structures

Queue Structure Implementation 1: Front always at array[0] 3 0 1 2 • DS: A Queue • Idea: A Queue or a line • Operations: • Add to the Queue • Remove from the Queue • peek at front element • check for empty • Make empty front back Implementation 2: With wrap around. public interface Queue{ public void enQueue(Object x); public Object deQueue(); public boolean isEmpty(); public void makeEmpty(); public Object peek(); } 0 1 2 back front Can overflow Data Structures

Queue Structure public class QueueCircularArray implements Queue{ private Object[] q; private int front, back; private int usedSpace; public QueueCircularArray(int size){ q = new Object[size]; front = 0; back = size-1; usedSpace=0; } public void enqueue(Object item){ back = (back+1)%q.length; q[back] = item; usedSpace++; } public Object dequeue(){ Object item = q[front]; q[front] = null; front = (front+1)%q.length; usedSpace--; return item; } public boolean isEmpty(){ (usedSpace==0); } public boolean isFull() { (usedSpace==q.length);} public Object peek(){return q[front];} } Data Structures

What is a Dynamic Structure? A data structure where there is “no” size limitation. Characteristics of dynamic structures: • Max size usually limited by machine memory • Amount of memory used is a function of data stored in the structure. • Data access is usually not random • There is overhead involved in creating and maintaining such a structure Data Structures

Fixed (or static) verses Dynamic structures Static structures: • Disadvantages: • Fixed size results in either overflow or under use of internal resources. • Resizing is a computationally expensive operation. • Advantages: • Random/Direct access to data • Usually easy to develop data structures using static structures • Disadvantages: • Lose of random access. • Usually harder to implement. • Advantages: • No overflow or under use problems. • Resizing is usually not expensive. Dynamic Structures: Data Structures

Data Structure - a generic view: method1() Implementation Either static of Dynamic method2() Interface method3() method4() • Example: • Queue …dequeue(…)… …enqueue(…)… Array or dynamic implementation of queue Methods of Queue …isEmpty(…)… …makeEmpty(…) Data Structures

Dynamic Structures - preliminaries p p p a2 q q q a3 a3 a2 a1 a3 a1 a2 a2 a3 a2 a2 a3 6 9 6 5 5 6 9 9 6 6 q q = new Integer(9); Integer p; Integer q; ? p = new Integer(5); p p = null; a1 p = new Integer(6); p a2 q=p; q = p; p a2 a2 q Data Structures

Dynamic Structures - preliminaries n2 n1 n1 n2 n1 a2 a2 a1 ? a1 a2 a2 a1 a1 item next item next item next item next IntegerNode n1; public class IntegerNode{ private int item; private IntegerNode next; public IntegerNode(int item){ setItem(item); next =null; } public void setItem(int item){ this.item = item; } public int getItem(){ return item; } public void setNext(InegerNode next){ this.next = next; } public IntegerNode getNext(){ return next; } } n1 = new IntegerNode(5); 5 IntegerNode n2 = new IntegerNode(7); 7 n1.setNext(n2); 5 a2 7 Data Structures

Dynamic Structures - preliminaries n2 n2 n3 n1 n3 n1 n2 n1 n3 n1 n1 n2 n2 n1 n2 a2 a1 a1 a3 a2 a2 a1 a1 a1 a1 a2 a2 a1 a2 item next item next a1 a1 a3 a1 a2 a2 a1 a2 a4 a3 a2 a4 a1 a3 a2 a3 5 a2 7 a3 7 a3 5 a2 5 a2 7 a3 5 a2 9 a4 9 a4 5 a2 7 3 3 9 7 9 IntegerNode n3 = n2; n2 = n2.getNext(); n2 =null; 5 a2 7 n2.setNext(new IntegerNode(3)); n2 = null; n2 = n1.getNext(); n3.setNext(null); n2.setNext(new IntegerNode(9)); Data Structures

A dynamic Stack public class DStack implements Stack{ class StackNode{ int data; StackNode next; StackNode(int d){data = d; next = null;} }//inner class private StackNode top; private int size; public DStack(){ Rules regarding Constructors: ALWAYS initialize instance variables to null. } public void push(int d){ Rules regarding adding to dynamic structures: Consider 2 cases Case 1: Adding to an empty structure Case 2: Adding to the front of structure (maybe covered in 1) Case 2: Inserting to an internal position. } Data Structures

A dynamic Stack public int pop(){ Rules regarding removing from a dynamic structure: Case 1: Deleting a “root” element Case 2: Deleting an internal element Data Structures

a4 3 … front a1 temp a1 a1 a3 a2 an 9 a4 5 a2 7 a3 # Traversing a Structure Moving back and fourth along the structure. Rules regarding traversing a structure: 1. Never move the reference pointing to the root of the structure 2. Check for null before moving. Traversing the structure below: Plain traversal: Printing the nodes in the structure: IntegerNode temp = front; while(temp != null){ temp = temp.getNext(); } IntegerNode temp = front; while (temp!=null){ Integer item = temp.getItem(); System.out.println(item.toString()); temp = temp.getNext(); } view animation! Data Structures

a1 a2 a3 an 5 a2 9 a4 7 a3 # Dynamic Queue a4 …enQueue(…)… 3 … …deQueue(…)… …isEmpty(…)… an a1 back front …makeEmpty(…) … peek(…)… Instance variables of class Queue Data Structures

Dynamic Queue public class DynamicQueue implements Queue{ class ListNode{ //inner class int data; ListNode next; ListNode(int d, ListNode n){ data = d; next = n; } } private ListNode front; back; public Queue(){ front = null; back = null; } RULE Always initialize instance references Data Structures

Dynamic Queue public class DynamicQueue implements Queue{ class ListNode{ //inner class int data; ListNode next; ListNode(int d){ data = d; next = null; } } private ListNode front; back; public void enQueue(Object o){ //Case 1- adding the initial element ListNode n = new ListNode(o,null); if (front == null){ //Case 2- adding subsequent elements Data Structures

a1 a2 a3 an 5 a2 7 a3 9 a4 # Dynamic Linked List a4 …get(…)… 3 … …remove(…)… a1 …add(…)… front …search(…) Data Structures

0 1 2 back List Structure List Structure: public Interface List{ public Object get(int index) throws IndexOutOfBoundsException; public void remove(int index) throws IndexOutOfBoundsException; public void add(Object item, int index) throws IndexOutOfBoundsException; public int search(Object item); public boolean isEmpty(); public void makeEmpty(); public int size(); } Cannot add/remove/get items beyond “back” Can you implement this? Data Structures

Dynamic Linked List public class DList implements List{ class ListNode{ int data; ListNode next; ListNode(int o, ListNode n){ data = o; n = next; } } private ListNode front; public List(){ …} public void add(Object o, int pos) throws … {…} public Object get(int pos) throws… {…} public void remove(int pos) throws… {…} public int search(Object o){…} public boolean isEmpty(){…} public int size(){…} public void makeEmpty(){…} } • Observe: • Inner class • A single instance variable, front • Client’s view same for both dynamic and static implementations. Data Structures

Dynamic Linked List RULE: Always initialize references to null or other known value in all dynamic structures. • public class DList implements List{ • class ListNode{ • int data; • ListNode next; • ListNode(int o, ListNode n){ • data = o; • n = next; • } • } • private ListNode front; • public List(){ • front = null; • } • … • } Data Structures

Dynamic Linked List RULE: When making a change to any dynamic structure, treat changing a node referenced by a named variable as special case. public void add(Object o, int pos) throws IndexOutOfBoundsException { 0. Check for exception case 1. Create a new ListNode with o as the data 2. if inserting at the front of the list, then //named variable, front, changing!!! 3. Insert the new ListNode in front so as not to lose the remaining elements } 4. else{ //front, named variable, does not change 5. traverse to one-before the place to add 6. Insert the new element in so as not to lose the remaining list. } } Data Structures

public class DList implements List{ • … • /** • * This method will add the data object o into position pos • * in the list. • * @param o the data item to be added • * @param pos the position to which o should be added in the list • * @exception IndexOutOfBoundsException will be thrown if (pos<0) • * or (pos > size of the list) • */ • public void add(int o, int pos) • throws IndexOutOfBoundsException{ • if (pos<0)||(pos>size()) throw new IndexOutOfBoundsException(); • ListNode n = new ListNode(o,null); //create a new node • if (pos == 0){ //adding to front? • n.next(front); //add carefully! • front = n; • } • else{ //adding internally • ListNode temp = front; //traverse • for(int i=0; i<pos-1; i++) temp = temp.next; • n.next = temp.next; //insert in • temp.next = n; • } • } Dynamic Linked List Data Structures

Dynamic Linked List RULE: When making a change to any dynamic structure, treat making a change to a node referenced by a named variable a special case. • public void remove(int pos) • throws IndexOutOfBoundsException { • 0. Check for exception case • 1. Remove the first Node? • //Named variable, front, changing!!! • 2. Remove so as not to lose the rest of the list • 3. else • 4. Traverse to one before the node to remove • 5. Detach the node so as not to lose the rest of the list • } Data Structures

Dynamic Linked List • public class DList implements List{ • … • /** • * The purpose of this method is to remove a data object from • * the list at the given position • * @param the item position to be removed • * @exception IndexOutOfBoundsException will be thrown if (pos<0) • * or (pos>=size()) • */ • public void remove(int pos) • throws IndexOutOfBoundsException{ • if (pos<0)||(pos>=size()) throw new IndexOutOfBoundsException(); • ListNode temp; • if (pos == 0){ //remove the first node? • temp = front; //carefully - so as not to lose • front = front.next; //the list! • } • else{ //remove an interior node • ListNode n = front; //traverse • for(int i=0; i<pos-1; i++) n = n.next; • temp = n.next; • n.next = temp.next; //remove • } • temp.next = null; • } Data Structures

Dynamic Linked List • public class DList …{ • … • public int search(int target){ • IntegerNode temp = front; • int location = 0; • while (temp!=null){ • if (temp.getItem() == target) return location; • location++; • temp = temp.getNext(); • } • return -1; • } • public boolean isEmpty(){ • return (front == null); • } • public int size(){ • 1. traverse the list counting the elements • 2. return the count • } • public void makeEmpty(){ • front = null; • } • } Data Structures

Basic Data Structures