Introduction to Computer Science I

Size: px

Start display at page:

Download "Introduction to Computer Science I"

Ashlee Cook
5 years ago
Views:

1 Introduction to Computer Science I P 6.0: Data Structures Dr. Thomas Kühne, Juniorprofessor FG Metamodeling TU Darmstadt Data Structures Agenda why abstract datatypes? implementation of and use of some datatypes Dynamic Containers using references efficiency considerations Polymorphism use of special node types ICS- P6.0 2 Why Datatypes? Why add any more datatypes to the primitive and container types (e.g., array) we already know? In principle, we could achieve everything with the already known types Formulating algorithms becomes much easier though, if they can rely on datatypes with rich functionality Object-Oriented Development precisely consist of developing new types first and then write simple code using them ICS- P6.0 3 Example: Frequency Analysis Version with Frequency Array public static void main(string[] args) int[] freqs=new int[26]; for (int i=0; i<args[0].length(); i++) char c=args[0].charat(i); histogram of used characters if (c>='a'&& c<='z') freqs[c-'a']++; for (int i=0; i<26; i++) System.out.println((char)('a'+i) + ": "+freqs[i]); output histogram string input via commandline argument ICS- P6.0 4 Example: Frequency Analysis Version with Data Structure "Bag" public static void main(string[] args) Bag freqs=new Bag(); for (int i=0; i<args[0].length(); i++) freqs.add(args[0].charat(i)); System.out.println(freqs); output histogram even simpler! freqs.addall(args[0]) a "Bag" is a kind of set, keeping count of elements the algorithm becomes simpler algorithm will benefit from improvements to "Bag" bags are useful in many more contexts ICS- P6.0 5 LIFO Container Last-In First-Out Operations void push(element e) Data Structure: Stack One of the Most Important Data Structures in Computer Science stack of plates in the mensa theoretically unlimited capacity often one plate visible only void pop() // remove one from element () // peep at element spring pushes boolean isempty() plates upwards Applications expression evaluation, method calls, depth first search in graphs, undo functionality, etc ICS- P6.0 6

2 Example: Valid Parentheses Pairing boolean correct(string k) Stack s=new Stack(9); for (int i=0; i<k.length(); i++) char c=k.charat(i); if (c=='(' c=='[') s.push(c); Sample Input: "()([()()])" predefined stack size // opening bracket? // => remember in stack // closing bracket => if (!s.isempty() && // opening one available? s.()==match(c))//... & of correct type? s.pop(); // yes, matching pair found return false; // no, erroneous expression! easily extended to an expression evaluator return s.isempty(); // all opened ones used up?! ICS- P6.0 7 class Stack int[] elements; int count; Implementation with Array Caution: no error // element container // number of stored elements Stack(int n) // constructor with capacity elements=new int[n]; // create corresponding array count=0; // no element contained yet store element & increase count boolean isempty() return count==0; void push(int e) elements[count++]=e; void pop() count--; erasure unnecessary int () return elements[count-]; starting from zero element is at count ICS- P6.0 8 Advantages of Array Implementation simple implementation efficient access push, pop, : all O() Disadvantages of Array Implementation stack size must be known in advance dynamically growing the capacity is inefficient array elements need to be copied into a larger array this strategy is used by java.util.vector flexible but "expensive" ICS- P6.0 9 class Stack Node ; Implementation with Nodes Caution: no error // first element Stack() // no capacity needed =null; // no elements yet new node points to old skip current boolean isempty() return ==null; void push(int e) =new Node(e, ); element void pop() =.(); int () return.element(); access contents of element ICS- P6.0 0 Implementation with Nodes class Node int element; Node ; // stored content // successor node Node(int e, Node n) element=e; // store element =n; // store successor node int element() return element; Node () return ; ICS- P6.0 last node points to "null" Comparison of Implementation Variants operations are efficient in both cases: O() "Nodes"-Stack grows dynamically not required to know maximum capacity in advance growth without expansion "costs" size limited by main memory only; arrays need a contiguous block of memory space efficiency depends on element count arrays win when filled close to capacity linked nodes win when corresponding array would be pretty empty ICS- P6.0 2

3 Given that Comparison: Array vs. Nodes every element requires i bytes every reference requires r bytes array of size c requires c * i bytes nodes require n * (i + r) bytes memory consumption is identical, if: n = i * c (r + i) n = c linked list requires r * n more bytes than an array, however, the risk of meeting the array capacity is high the higher i/r, the more advantageous is the linked list Two Ends instead of one Top... FIFO container Data Structure: Queue queue at back... First-In First-Out theoretically Operations unlimited capacity void enqueue(element e) void dequeue() // remove one element front() // look at front boolean isempty() Applications queue in mensa...being served at front buffering of events/data, queuing "threads", breadthfirst search in graphs, etc ICS- P ICS- P6.0 4 Data Structure: Queue Implementation with Array naïve implementation requires moving elements upon serving "circular" array avoids movement simple updating of "front" & "size" upon reaching upper array bound, positions are reset to zero "modulo arithmetic" front front+size serving position queuing position ICS- P6.0 5 Data Structure Queue Implementation with Array Caution: no error class Queue int[] elements; int front, size; int c; // element store // dequeue position & size // shorter than "elements.length" Queue(int n) // capacity parameter elements=new int[n]; // create corresponding array size=front=0; // no element contained yet c=elements.length; // just a shortcut name calculation modulo "capacity" boolean isempty() return size==0; void enqueue(int e) elements[(front+size++)%c]=e; void dequeue() front=(front+)%c; size--; int front() return elements[front]; only valid if!isemtpy() ICS- P6.0 6 Data Structure Queue Implementation with Nodes class Queue Node front, end; Queue() front=end=null; Caution: no error // serving // & queue node references // no capacity required // no element contained yet skip old "front" boolean isempty() return front==null; void dequeue() front=front.(); int front() return front.element(); void enqueue(int e) if (front==null) empty queue front=end=new Node(e, null); "front" & "end" point to same node end.setnext(new Node(e, null); end=end.(); queue not empty append node at back update "end" ICS- P6.0 7 Data Structure Queue Comparison of Implementations "nodes"-queue may dynamically grow analog to Stack... Access equally efficient: O() array implementation only achieves this by "circular" usages of the array. Otherwise, elements would have required being shifted: O(n). nodes implementation only achieves it by using an additional "end" pointer. Otherwise, appending would have required traversing the whole queue: O(n) ICS- P6.0 8

4 Stack and Queue Restrict Access restriction to one input/output channel without these restrictions no predictions about the expected elements were possible List enables Random Access free access to all positions e.g., "TO-DO" list were an element position indicates its priority but arbitrary selection is possible implies the idea of a "current element" cursor ICS- P6.0 9 Implementation of "Insert" three cases (depending on cursor position): insert at front insert in the middle insert at end void insert(int e) if (cursor==null) setnext() must return inserted element establish new node as successor of cursor node // front? front=new Node(e, front); // => prepend! if (cursor==end) // end? end=end.setnext(new Node(e, null));// => append! // insert cursor.setnext(new Node(e, cursor.())); ICS- P Implementation of "Remove" three cases (depending on cursor position): delete at front delete from middle delete at end finds node located before "cursor" node void remove() // remove not allowed on empty list if (cursor==front) // at front? cursor=(front=front.()); // => skip first! if (cursor==end) // at end? (cursor=end=prev(cursor)).setnext(null);// cut off // prev(cursor).setnext(cursor.());// cut out // now update cursor ICS- P6.0 2 same problem with An Efficiency Problem... the "prev()" function if the cursors is moved backwards, the whole list must be traversed to find the respective node 3 cursor must be altered upon deletion of current element......requiring this object to be changed, which is not accessible from the cursor position a double linked list improves this bad positioning efficiency O(n)) to O()! ICS- P Double Linked List Forward and Backward References using this reference it is easy to access the predecessor node 3 previous cursor previous efficiency boost doesn't come for free memory required for backward references more complex insertion and deletion operations ICS- P Array Implementation is not an Option insertion & deletion possible with O(n) only elements must be moved combining lists is expensive elements must be copied & array potentially needs resizing a sorted indexable list, however, would enable "binary search"! so called "skip lists" have been invented for this if efficient searching, insertion, and deletion are important (in contrast to sequential access), the data structure "tree" is to be preferred ICS- P6.0 24

5 In general, operations on lists have to make a case analysis list empty / cursor at at front only one element contained / cursor at end multiple elements present / cursor in the middle Problems extending the functionality (e.g., counting elements), requires implementation of the same case analysis some case distinctions can be quite complex (nested if-statements) ICS- P Use of Different Node Types Empty Stack size fi 0 One Element size fi 3 size fi + ().size() Multiple Elements size fi + ().size() 3 size fi ICS- P Emtpy Stack element count = 0 popping not possible common superclass of all node types class EmptyNode extends Node int element() return 0; // Error Node () return null; // Error int size() return 0; Node pop() return this; // Error Node push(int e) return new EndNode(e, null); pushing results in an "EndNode" object One Element Stack features element(), () class EndNode extends DataNode EndNode(int e, Node n) super(e, n); int size() return ; Node pop() return new EmptyNode(); Node push(int e) return new InnerNode(e, this); element count = popping results in the "EmptyNode" object pushing results in an "InnerNode" object ICS- P ICS- P Multiple Elements Stack class InnerNode extends DataNode InnerNode(int e, Node n) super(e,n); int size() return + ().size(); Node pop() return (); Node push(int e) return new InnerNode(e, this); element count = + element count of rest popping yields the rest of the stack pushing yields an "InnerNode" object again Usage by a Stack class PolyNodeStack Node ; PolyNodeStack() =new EmptyNode(); // no element contained yet int size() return.size(); // delegate void pop() =.pop(); // requests void push(int e) =.push(e); update "" after operation not a single case analysis required! different cases distributed to respective node types ICS- P ICS- P6.0 30

6 Data Structures: Summary data structures facilitate the formulation of algorithms basic OOP principle: introduce new types node implementations support dynamic growth of element containers double linked lists may support all sequential operations in O() use of polymorphic node types may simplify programming distribution of cases/responsibilities ICS- P6.0 3

CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University

CS 112 Introduction to Computing II Wayne Snyder Department Boston University Today Introduction to Linked Lists Stacks and Queues using Linked Lists Next Time Iterative Algorithms on Linked Lists Reading: