Arrays and Linked Lists. Johns Hopkins Department of Computer Science Course : Data Structures, Professor: Greg Hager

Save this PDF as:

Size: px
Start display at page:

Download "Arrays and Linked Lists. Johns Hopkins Department of Computer Science Course : Data Structures, Professor: Greg Hager"

Transcription

2 Value vs. Reference Variables Value i 10 j Reference 10 new performs dynamic memory allocation int i=10; int[] j = new int[1]; j[0] = 10; Or int[] j = {10}; Variables of primitive types are value variables Variables of arrays and classes are reference variables Reference variables are a safer form of pointers (In C++, you can choose)

3 A Review of References Recall that all objects in Java are really references, I.e. what happens when I do MyObject x = new MyObject(a,b,c); MyObject y = x; MyFunction(y); x = new MyObject;

4 Arrays Refer to several values of same type Example: int[] myarray = new int[20]; Length field holds allocated number of elements myarray.length == 20 Indexed from 0..length-1 bounds checked dynamically Initialized manually or in declaration int[] myarray2 = {18, 36}; myarray2 [0] [1]

5 java.util.arrays Predefined set of static methods operating on arrays equals(a,b) fill(a,x) sort(a) tostring(a)

6 2D (and higher D) Arrays May be allocated at once for rectangles int[][] i = new int[12][15]; Or deal with 1 dimension at a time int[][] i = new int[10][]; for (int j=0; j<10; j++) i[j] = new int[2*j + 1]; Note: multidimensional arrays appear as arrays of arrays e.g. i[3].length = 15 and i.length = 12;

7 Non-rectangular 2D Array i

8 Abstract Data Types Ideally, a data type can be described only in terms of operations and how they act, not in terms of how it is actually implemented or represented. This allows us to prove properties of the data type which may be useful for testing, implementation, optimization...

9 An Example: An Abstract Stack Basic rules: 1. There is a unique constant E (empty stack) 2. There are functions Push and Pop with rules 1. x.push(x.pop()) = x 2. x.pop(x.push(z)) = z 3. E.Pop() = error

10 List ADT What are the operations on a list of objects: print clear insert (where?) remove (what?) find access the kth element

11 A Warmup: Array Implementation How long do these take on an array-based implementation? print clear insert front rear at element remove at index find index of element access the kth element

13 Singly Linked List Node // Without generics. public class Node{ private Object element; private Node next; public Node(Object e, Node n) { element = e; next = n; } public Object getelement() { return element;} public Object setelement(ne) {element = ne;} public Node getnext() { return next;} public Node setnext(node nn) {next = nn;} }

14 SL List Implementation How long do these take on an singly-linked list-based implementation? print clear insert front rear at element remove at index find index of element access the kth element

15 Doubly Linked Lists The limitation of the singly linked lists stems from the fact we cannot look back Doubly linked lists overcome this problem With doubly linked lists, it is inconvenient to have an asymmetry at the beginning and end of the list. Sentinels are dummy nodes that do not hold data, but regularize the computation

16 Generic Doubly Linked List Node public class DNode<T> { private T element; private DNode<T> next, prev; public DNode(T e, DNode<T> n, DNode<T> p) { element = e; next = n; prev = p } }

17 Doubly Linked List Implementation public class MyList<T> { protected int numelts=0; protected Dnode<T> header, trailer; MyList () { header = new Dnode<T>(null,null,null); trailer = new Dnode<T>(null, header, null); header.setnext(trailer); } public Dnode<T> getprev(dnode<t> v) throws IllegalArgumentException { if (v == header) throw new IllegalArgumentException( At header ); return v.getprev(); } public Dnode<T> addbefore(dnode<t> p, Dnode<T> newnode) throws... { numelts++; newnode.setprev(p.getprev()); p.getprev().setnext(newnode); p.setprev(newnode); newnode.setnext(p); return newnode; } }

18 Exceptions Language-level support for managing run-time errors You can define your own exception classes Methods declare which exceptions they might possibly throw Calling methods either catch these exceptions or pass them up the call stack

19 Throw public void mymethod() throws BadThingHappened {... if (somecondition) throw new BadThingHappened;... } try... mymethod()... catch (BadThingHappened BTH) block catch (exceptiontype id) block finally block // ALWAYS executed!!

20 Removing public void remove(dnode v) { DNode u = getprev(v); DNode w = getnext(v); } w.setprev(u); u.setnext(w); v.setprev(null); v.setprev(null); size--;

21 DL List Implementation How long do these take on an doubly-linked list-based implementation? print clear insert front rear at element remove at index find index of element access the kth element

22 Java Collections Framework Collection: Any collection of objects; extends iterable and thus permits iteration with iterator() method Iterator: Basic iterator ADT List: Extends collection to include ArrayList and LinkedList; supports ListIterator (modification) ListIterator: Forward/backward and modification Stack: Add and remove from front Queue: Add to end, take from front All in java.util

23 Iterators Once we have a linear data structure, a natural model of computation is iteration An iterator abstracts this idea from the underlying data storage format! public interface Iterator<E> {!!public boolean hasnext();!!public E next();!!void remove( ); // last item return by next! }

24 Iterators Each class using an iterator can support Iterable<E>! public interface Iterable<E> {!!// return an iterator object!!public java.util.iterator<e> iterator();! }!!!

25 The Collection Interface In Java.util public interface Iterator<AnyType> { boolean hasnext( ); AnyType next( ); void remove( ); // last item returned by next } public interface Collection<AnyType> extends Iterable <AnyType> { int size( ); boolean isempty( ); void clear ( ); boolean contains( AnyType x ); boolean add( AnyType x ); boolean remove( AnyType x ); java.util.iterator<anytype> iterator( ); }

26 Why Iterable? Allows the use of special : syntax public static <T> void print( Collection<T> c ) { for (T item : c) System.out.println( item ); } // VS public static <T> void print( Collection<T> c ) { Iterator<T> itr = c.iterator( ); while (itr.hasnext( )) { T item = itr.next( ); System.out.println( item ); } }

27 The Dangers of Iterators Iterators make sense if data structures are static while they are in use. What if the DS changes? Could make copy (O(n)) Positions continue to make sense (although difficult to guarantee behavior). In Java, the list iterator in Java does not expose a position concept --- iterators are invalidated if container is changed.

28 What is the problem here? for (Integer x : lst ) if (x % 2 == 0) lst.remove(x) FAILS! Iterator itr = lst.iterator(); while (itr.hasnext()) if (itr.next() % 2 == 0) itr.remove();

29 The List Interface public interface List<T> extends Collection<T> { T get (int i); T set (int i); void add (int i, T x); void remove (int i); ListIterator<AnyType listiterator(int pos); } public interface ListIterator<T> extends Iterator<T> { boolean hasprevious( ); T previous( ); void add (T x); void set (T x); } Implemented by ArrayList and LinkedList!

30 Example of ListIterator I start with: and execute System.out.println( iter.next() ); iter.add( 1 ) ; System.out.println( iter.next( ) ); iter.remove ( ) ; System.out.println( iter.next( ) ); iter.set ( 7 ) ; System.out.println( iter.next( ) ); x.set(4,20); What is the result?

31 Take Care How long do each of these take with linked list or array? for (int i=0; i< N; i++)!!lst.add( i, i );!! for (int i=0; i< N; i++)!!lst.add(0, i);!! for (int i=0; i< lst.size(); i++)!!total += lst.get(i);!

32 Take Care int i = 0;! while (i < lst.size)!!if lst(get(i)) % 2 == 0!!!!lst.remove(i);!!else!!!i++;! for (Integer x : lst)!!if (x%2 == 0)!!!lst.remove(x);!! Iterator<Integer> itr = lst.iterator();! while (itr.hasnext( ))!!if (itr.next( ) % 2 == 0)!!!itr.remove();!

33 ArrayList class Things to note: outer vs. inner vs. nested class for iterator inner good if 1-1 association nested allows non-associated exception handling automatic sizing

34 LinkedList Class Note: The use of sentinel nodes Visibility of nested class members Use of modcount

35 Amortization Useful analysis tool When some calls are more expensive than others, average out the costs over the total number of calls After every n calls to add, 1 call takes O(n) instead of O(1) Averaged out over n calls, each call is still O(1)

36 Formal Amortization Analysis Assume each add( ) costs \$1 in compute time Overcharge these add( ) operations charge \$3 each store \$2 in the bank for each operation Now when the extend happens, use money from the bank to pay for the copy operations We pay for all n operations using a constant cost for each operation implies O(n) total cost, or average of O(1) per operation

37 Analysis with Summations Work done in extend for n pushes: n = log n i = 0 2 i = 2 logn+1 1 = 2 * 2 logn 1 = 2n 1 = O(n) for n pushes (this is a base 2 number with logn + 1 bits, all set to 1)

38 On to Stacks and Queues

39 What is a Stack? Stores a set of elements in a particular order Accessed in Last-In-First-Out (LIFO) fashion Real life examples: Pile of books PEZ dispenser Cup trays in cafeteria CS examples: program execution stack, parsing/ evaluating expressions

40 Stack Abstract Data Type push(o): insert o on top of stack pop( ): remove object from top of stack top( ): look at object on top of stack (but don t remove) size( ): number of objects on the stack isempty( ): does (size = = 0)?

41 An Example: Call Stack Frames

42 HP 3000 Minicomputer (RIP)

43 Stack Exception public class StackEmptyException!!!!!extends RuntimeException {!! public EmptyStackException(String err) {!!!super(err);! }! }!

44 Exceptions Language-level support for managing run-time errors You can define your own exception classes Methods declare which exceptions they might possibly throw Calling methods either catch these exceptions or pass them up the call stack

45 Throw public void mymethod() throws BadThingHappened {... if (somecondition) throw new BadThingHappened;... } try... mymethod()... catch (BadThingHappened BTH) block catch (exceptiontype id) block finally block // ALWAYS executed!!

46 A Java Interface for Stack ADT public interface Stack<T> {!!public int size();!!public boolean isempty();!!public T top() throws!!!stackemptyexception;!!public void push (T element);!!public T pop() throws!!!stackemptyexception;! }!

47 Linked List Stack Implementation Benefits Avoids maximum stack size restriction Only allocates memory for stack elements actually used How Allocate a node for each stack element Nodes are chained together by reference to next node in the chain

48 Linked List Node public class Node<E> {!!private E element;!!private Node next;!!public Node(E e, Node n) {!!!element = e; next = n; }!!public E getelement() { return element;}!!public Node<E> getnext() { return next;}!!public void setelement(e newe) {element = newe;}!!public void setnext(node<e> newn) {next = newn;}! }!

49 Linked List Stack Implementation public class LinkedStack<E> implements Stack<E> {!!private Node<E> top = null;!!private int size = 0;!!!public void push(e elem) {!!!Node<E> v = new Node<E>(elem,top);!!!top = v;!!!size++; }!!!public E pop() throws StackEmptyException {!!!if (isempty()) throw new!!stackemptyexception( empty );!!!E temp = top.getelement();!!!top = top.getnext();!!!size --;!!!return temp; }! }!

50 Array-based Stack Implementation Allocate array of some size Maximum # of elements in stack Bottom stack element stored at index 0 first index tells which element is the top increment first when element pushed, decrement when pop d

51 Array-based Implementation public class ArrayStack<T> implements Stack<T> {!!private T[] S;!!private int topindex = -1;!!!public ArrayStack(int cap) {!! capacity cap;!! S = (T[]) new Object[capacity];! }!!!

52 Array-based Implementation! public void push(t obj) throws StackFull {!!!if (size() == S.length)! throw new StackFullException( stack full );!!!S[++topIndex] = obj; }!!! public T pop() throws StackEmpty {!!!if (isempty())! throw new StackEmptyException( empty );!!!T elem = S[topIndex];! S[topIndex--] = null;!!!return elem; }!!

53 Analysis Each operation is O(1) running time Independent of number of items in stack push, pop, top, size, isempty Space can be O(n) or may be much more depends if n is known at initialization time

54 Analysis All stack functions still O(1) push, pop, top, size, isempty

55 Examples Reversing an Array Paren matching HTML tags postfix arithmetic Converting to postfix

56 What is a Queue Stores a set of elements in a particular order Accessed in First-In-First-Out (FIFO) fashion Real life examples: Waiting in line at cafeteria Waiting on hold for technical support CS Example: Buffered I/O

57 Queue ADT enqueue(o): Insert object o at rear of queue dequeue( ): remove object from front of queue size( ): number of elements isempty( ): size == 0? front( ): look at object at front of queue

58 Queue Interface in Java public interface Queue<E> {!!public int size();!!public boolean isempty();!!public E front() throws QueueEmptyException;!!public void enqueue (E element);!!public E dequeue() throws QueueEmptyException;! }!

59 Array-based Queue Implementation Array of fixed size Index array element for front and rear of queue Indices wrap around when they cross end of array

60 Array Queue Implementation public class ArrayQueue<E> implements Queue<E> {!!private E[] Q;!!private int size=0;!!private int front=0, rear = 0;!!public void enqueue(e o) {!!!if (size() == Q.length) throw!!new QueueFullException( full );!!!Q[rear] = o;!!!rear = (rear + 1) % Q.length; size++;!!}! public E dequeue() {!!!if (size() == 0) throw!!new QueueEmptyException( hungry );!!!E tmp = Q[front];!!!front = (front + 1) % Q.length; size--;!!!return tmp;!}!

61 List Queue Implementation Head and tail node references for front and rear of queue Insert at tail, remove from head Remove from tail too slow for singly linked list Updating tail reference with new tail takes full traversal So use tail of list for rear of queue

62 List Queue Implementation public class ListQueue<E> implements Queue<E> {!!private Node<E> head = null;!!private Node<E> tail = null;!!private int size = 0;!!...!!public void enqueue(e elem)!!!node<e> node = new Node<E>(E,null);!!!if (empty()) head=node;!!!else tail.setnext(node);!!!tail = node; size++;!!}!!!!public E dequeue() throws QueueEmptyException {!!!if (empty()) throw QueueEmptyException( grr );!! E tmp = head.getelement();!! head = head.getnext(); size--;!! if (empty()) tail = null;!! return tmp;! }!

63 Analysis All queue operations are O(1) size( ), isempty( ) enqueue( ), dequeue( ), front( )

64 Examples Round-robin scheduling Buffered I/O Printing...

65 Example: The JVM JVM divides memory into two parts: stack and heap Stack is used for procedure calls and static allocation Heap is used for dynamic allocation In addition, the JVM maintains a queue of active threads

66 Double-ended Queue Sometimes called deque (dek) Similar to stack and queue Allows insertion and removal at both ends of the queue Stack or queue is easily implemented using a deque

67 Deque ADT insertfirst(e) : insert element at front insertlast(e) : insert element at rear removefirst( ) : remove first element removelast( ) : remove element at rear first( ) : examine first element last( ) : examine last element size(e) : number of elements in deque isempty( ) : size == 0?

68 Summary 1. Basic data structures: arrays, singly linked lists, doubly linked lists 2. Iterators, Iterable, Collections, Lists 3. Stacks, Queues and their uses 4. Time-analysis of implementations

What is a Stack? Stacks and Queues. Stack Abstract Data Type. Java Interface for Stack ADT. Array-based Implementation

Stacks and Queues What is a Stack? Stores a set of elements in a particular order Accessed in Last-In In-First-Out (LIFO) fashion Real life examples: Pile of books PEZ dispenser Cup trays in cafeteria

STACKS,QUEUES, AND LINKED LISTS Stacks Queues Linked Lists Double-Ended Queues Case Study: A Stock Analysis Applet 1 Stacks Astack is a container of objects that are inserted and removed according to the

Queues Outline and Required Reading: Queues ( 4.2 except 4.2.4) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

Queues Outline and Required Reading: Queues ( 4. except 4..4) COSC, Fall 3, Section A Instructor: N. Vlajic Queue ADT Queue linear data structure organized according to first-in/first-out (FIFO) principle!

Algorithms and Data Structures

Basic Data Structures Page 1 BFH-TI: Softwareschule Schweiz Basic Data Structures Dr. CAS SD01 Basic Data Structures Page 2 Outline Data Structures and Abstract Data Types Linear Data Structures Implementing

csci 210: Data Structures Stacks and Queues

csci 210: Data Structures Stacks and Queues Summary Topics stacks and queues as abstract data types implementations arrays linked lists analysis and comparison application: searching with stacks and queues

This lecture. Abstract data types Stacks Queues. ADTs, Stacks, Queues 1. 2004 Goodrich, Tamassia

This lecture Abstract data types Stacks Queues ADTs, Stacks, Queues 1 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations

Stacks & Queues. Data structures and Algorithms

Stacks & Queues Data structures and Algorithms Acknowledgement: These slides are adapted from slides provided with Data Structures and Algorithms in C++ Goodrich, Tamassia and Mount (Wiley, 2004) Outline

Universidad Carlos III de Madrid Algorithms and Data Structures (ADS) Bachelor in Informatics Engineering Computer Science Department Lists, Stacks and Queues. Authors: Isabel Segura Bedmar April 2011

Linked Lists, Stacks, Queues, Deques. It s time for a chainge!

Linked Lists, Stacks, Queues, Deques It s time for a chainge! Learning Goals After this unit, you should be able to... Differentiate an abstraction from an implementation. Define and give examples of problems

Queues and Stacks. Atul Prakash Downey: Chapter 15 and 16

Queues and Stacks Atul Prakash Downey: Chapter 15 and 16 Queues Queues occur in real life a lot. Queues at checkout Queues in banks In software systems: Queue of requests at a web servers Properties of

Stacks. Stacks (and Queues) Stacks. q Stack: what is it? q ADT. q Applications. q Implementation(s) CSCU9A3 1

Stacks (and Queues) 1 Stacks Stack: what is it? ADT Applications Implementation(s) 2 CSCU9A3 1 Stacks and ueues A stack is a very important data structure in computing science. A stack is a seuence of

Chapter 7: Queues and Deques

Chapter 7: Queues and Deques After the stack, the next simplest data abstraction is the queue. As with the stack, the queue can be visualized with many examples you are already familiar with from everyday

Sequential Data Structures

Sequential Data Structures In this lecture we introduce the basic data structures for storing sequences of objects. These data structures are based on arrays and linked lists, which you met in first year

Chapter 3: Restricted Structures Page 1

Chapter 3: Restricted Structures Page 1 1 2 3 4 5 6 7 8 9 10 Restricted Structures Chapter 3 Overview Of Restricted Structures The two most commonly used restricted structures are Stack and Queue Both

Collections & Data Structures. CS 3: Computer Programming in Java

Collections & Data Structures CS 3: Computer Programming in Java Objectives The concept of a collection Separating the interface from the implementation Dynamic data structures Linked lists Queues and

Data Structures and Algorithms Lists

Data Structures and Algorithms Lists Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/19 5-0: Abstract Data Types An

Analysis of a Search Algorithm

CSE 326 Lecture 4: Lists and Stacks 1. Agfgd 2. Dgsdsfd 3. Hdffdsf 4. Sdfgsfdg 5. Tefsdgass We will review: Analysis: Searching a sorted array (from last time) List ADT: Insert, Delete, Find, First, Kth,

D06 PROGRAMMING with JAVA

Cicles Formatius de Grau Superior Desenvolupament d Aplicacions Informàtiques D06 PROGRAMMING with JAVA Ch20 Data Structures I PowerPoint presentation, created by Angel A. Juan - ajuanp(@)gmail.com, for

Linked Lists and Iterators Chapter 4 Click to proceed How To View This Presentation This presentation is arranged in outline format. To view the slides in proper order For each slide Read the entire slide

Course: Programming II - Abstract Data Types. The ADT Stack. A stack. The ADT Stack and Recursion Slide Number 1

Definition Course: Programming II - Abstract Data Types The ADT Stack The ADT Stack is a linear sequence of an arbitrary number of items, together with access procedures. The access procedures permit insertions

22c:31 Algorithms. Ch3: Data Structures. Hantao Zhang Computer Science Department http://www.cs.uiowa.edu/~hzhang/c31/

22c:31 Algorithms Ch3: Data Structures Hantao Zhang Computer Science Department http://www.cs.uiowa.edu/~hzhang/c31/ Linear Data Structures Now we can now explore some convenient techniques for organizing

1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D. base address 2. The memory address of fifth element of an array can be calculated

Module 2 Stacks and Queues: Abstract Data Types

Module 2 Stacks and Queues: Abstract Data Types A stack is one of the most important and useful non-primitive linear data structure in computer science. It is an ordered collection of items into which

Data Structures and Algorithms

Data Structures and Algorithms CS245-2016S-05 Abstract Data Types and Lists David Galles Department of Computer Science University of San Francisco 05-0: Abstract Data Types Recall that an Abstract Data

Last not not Last Last Next! Next! Line Line Forms Forms Here Here Last In, First Out Last In, First Out not Last Next! Call stack: Worst line ever!

ECE 551 C++ Programming, Data structures, and Algorithms Abstract Data Type: Stack Last In First Out (LIFO) 1 2 2 1 4 3 1 3 4 Stacks in Programming Worst line ever! 5 3 1 5 Stacks are not useful for waiting

Cpt S 223. School of EECS, WSU

Abstract Data Types 1 Topics Abstract Data Types (ADTs) Some basic ADTs: Lists Stacks Queues 2 Primitive Data Type vs. Abstract Data Types Primitive DT: ADT: programmer progra ammer Interface (API) e.g.,

Programming with Data Structures

Programming with Data Structures CMPSCI 187 Spring 2016 Please find a seat Try to sit close to the center (the room will be pretty full!) Turn off or silence your mobile phone Turn off your other internet-enabled

CmpSci 187: Programming with Data Structures Spring 2015

CmpSci 187: Programming with Data Structures Spring 2015 Lecture #12 John Ridgway March 10, 2015 1 Implementations of Queues 1.1 Linked Queues A Linked Queue Implementing a queue with a linked list is

Data Structures in the Java API

Data Structures in the Java API Vector From the java.util package. Vectors can resize themselves dynamically. Inserting elements into a Vector whose current size is less than its capacity is a relatively

Common Data Structures

Data Structures 1 Common Data Structures Arrays (single and multiple dimensional) Linked Lists Stacks Queues Trees Graphs You should already be familiar with arrays, so they will not be discussed. Trees

Course: Programming II - Abstract Data Types. The ADT Queue. (Bobby, Joe, Sue, Ellen) Add(Ellen) Delete( ) The ADT Queues Slide Number 1

Definition Course: Programming II - Abstract Data Types The ADT Queue The ADT Queue is a linear sequence of an arbitrary number of items, together with access procedures. The access procedures permit addition

Linked Lists Linked Lists, Queues, and Stacks CSE 10: Introduction to C Programming Fall 200 Dynamic data structure Size is not fixed at compile time Each element of a linked list: holds a value points

DATA STRUCTURES USING C

DATA STRUCTURES USING C QUESTION BANK UNIT I 1. Define data. 2. Define Entity. 3. Define information. 4. Define Array. 5. Define data structure. 6. Give any two applications of data structures. 7. Give

1.00 Lecture 35. Data Structures: Introduction Stacks, Queues. Reading for next time: Big Java: 15.1-15.3. Data Structures

1.00 Lecture 35 Data Structures: Introduction Stacks, Queues Reading for next time: Big Java: 15.1-15.3 Data Structures Set of reusable classes used in algorithms, simulations, operating systems, applications

Outline. The Stack ADT Applications of Stacks Array-based implementation Growable array-based stack. Stacks 2

Stacks Outline The Stack ADT Applications of Stacks Array-based implementation Growable array-based stack Stacks 2 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure

1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++

Answer the following 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++ 2) Which data structure is needed to convert infix notations to postfix notations? Stack 3) The

Questions 1 through 25 are worth 2 points each. Choose one best answer for each.

Questions 1 through 25 are worth 2 points each. Choose one best answer for each. 1. For the singly linked list implementation of the queue, where are the enqueues and dequeues performed? c a. Enqueue in

10CS35: Data Structures Using C

CS35: Data Structures Using C QUESTION BANK REVIEW OF STRUCTURES AND POINTERS, INTRODUCTION TO SPECIAL FEATURES OF C OBJECTIVE: Learn : Usage of structures, unions - a conventional tool for handling a

Linked Lists: Implementation CS 311 Data Structures and Algorithms Lecture Slides Monday, March 30, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org

Data Structures Using Java

Data Structures Using Java D. S. Malik P. S. Nair THOMSON COURSE TECHNOLOGY Australia Canada Mexico Singapore Spain United Kingdom United States TABLE OF Contents PREFACE XXV 1.Software Engineering Principles

Data Structures and Algorithms

Data Structures and Algorithms CS245-2016S-04 Stacks and Queues David Galles Department of Computer Science University of San Francisco 04-0: Abstract Data Types An Abstract Data Type is a definition of

TIE-20106 1 TIE-20106 2

TIE-20106 1 1 List structures In this chapter, a few simple data structures (stack and queue) that can be implemented with arrays and/or lists are covered. Two more complex structures based on lists are

1 ADTs,, Arrays, Linked Lists Outline and Required Reading: ADTs ( 2.1.2) Arrays ( 1.5) Linked Lists ( 4.3.1, 4.3.2) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic Abstract Data Type (ADT) 2 abstract

Concrete collections in Java library. Java Collection framework: On concrete collections and their implementation. LinkedList: doubly-linked list

Concrete collections in Java library Java Collection framework: On concrete collections and their implementation 1 ArrayList: indexed sequence that grows/shrinks dynamically LinkedList: ordered sequence

DATA STRUCTURE - STACK

DATA STRUCTURE - STACK http://www.tutorialspoint.com/data_structures_algorithms/stack_algorithm.htm Copyright tutorialspoint.com A stack is an abstract data type ADT, commonly used in most programming

Krishna Institute of Engineering & Technology, Ghaziabad Department of Computer Application MCA-213 : DATA STRUCTURES USING C

Tutorial#1 Q 1:- Explain the terms data, elementary item, entity, primary key, domain, attribute and information? Also give examples in support of your answer? Q 2:- What is a Data Type? Differentiate

Data Structures and Algorithms Stacks and Queues

Data Structures and Algorithms Stacks and Queues Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/23 6-0: Stacks and

Class Overview. CSE 326: Data Structures. Goals. Goals. Data Structures. Goals. Introduction

Class Overview CSE 326: Data Structures Introduction Introduction to many of the basic data structures used in computer software Understand the data structures Analyze the algorithms that use them Know

PES Institute of Technology-BSC QUESTION BANK

PES Institute of Technology-BSC Faculty: Mrs. R.Bharathi CS35: Data Structures Using C QUESTION BANK UNIT I -BASIC CONCEPTS 1. What is an ADT? Briefly explain the categories that classify the functions

Stacks and queues. Algorithms and Data Structures, Fall 2011. Rasmus Pagh. Based on slides by Kevin Wayne, Princeton

Algorithms and Data Structures, Fall 2011 Stacks and queues Rasmus Pagh Based on slides by Kevin Wayne, Princeton Algorithms, 4 th Edition Robert Sedgewick and Kevin Wayne Copyright 2002 2011 Stacks and

Outline. Computer Science 331. Stack ADT. Definition of a Stack ADT. Stacks. Parenthesis Matching. Mike Jacobson

Outline Computer Science 1 Stacks Mike Jacobson Department of Computer Science University of Calgary Lecture #12 1 2 Applications Array-Based Linked List-Based 4 Additional Information Mike Jacobson (University

Data Structures and Algorithms

Data Structures and Algorithms Lecture 4 2016 Stacks and... 1/28 1 2 Circular Linked 3 Queue Syntax and Functions in C++ 4 Stacks and... 2/28 FIFO and LIFO Outline Data structures can be specialized versions

12 Abstract Data Types

12 Abstract Data Types 12.1 Source: Foundations of Computer Science Cengage Learning Objectives After studying this chapter, the student should be able to: Define the concept of an abstract data type (ADT).

QUEUES. Primitive Queue operations. enqueue (q, x): inserts item x at the rear of the queue q

QUEUES A queue is simply a waiting line that grows by adding elements to its end and shrinks by removing elements from the. Compared to stack, it reflects the more commonly used maxim in real-world, namely,

Estrutura com iterador-1 public class MyContainer Object [ ] items; int size; public Object get( int idx )... public boolean add( Object x )... public MyContainerIterator iterator( ) return new MyContainerIterator(this);

Abstract Data Type. EECS 281: Data Structures and Algorithms. The Foundation: Data Structures and Abstract Data Types

EECS 281: Data Structures and Algorithms The Foundation: Data Structures and Abstract Data Types Computer science is the science of abstraction. Abstract Data Type Abstraction of a data structure on that

Quiz 4 Solutions EECS 211: FUNDAMENTALS OF COMPUTER PROGRAMMING II. 1 Q u i z 4 S o l u t i o n s

Quiz 4 Solutions Q1: What value does function mystery return when called with a value of 4? int mystery ( int number ) { if ( number

Collections in Java. Arrays. Iterators. Collections (also called containers) Has special language support. Iterator (i) Collection (i) Set (i),

Arrays Has special language support Iterators Collections in Java Iterator (i) Collections (also called containers) Collection (i) Set (i), HashSet (c), TreeSet (c) List (i), ArrayList (c), LinkedList

UNIVERSITI MALAYSIA SARAWAK KOTA SAMARAHAN SARAWAK PSD2023 ALGORITHM & DATA STRUCTURE

STUDENT IDENTIFICATION NO UNIVERSITI MALAYSIA SARAWAK 94300 KOTA SAMARAHAN SARAWAK FAKULTI SAINS KOMPUTER & TEKNOLOGI MAKLUMAT (Faculty of Computer Science & Information Technology) Diploma in Multimedia

UIL Computer Science for Dummies by Jake Warren and works from Mr. Fleming

UIL Computer Science for Dummies by Jake Warren and works from Mr. Fleming 1 2 Foreword First of all, this book isn t really for dummies. I wrote it for myself and other kids who are on the team. Everything

ECE 250 Data Structures and Algorithms MIDTERM EXAMINATION 2008-10-23/5:15-6:45 REC-200, EVI-350, RCH-106, HH-139

ECE 250 Data Structures and Algorithms MIDTERM EXAMINATION 2008-10-23/5:15-6:45 REC-200, EVI-350, RCH-106, HH-139 Instructions: No aides. Turn off all electronic media and store them under your desk. If

Algorithms and Data Structures

Algorithms and Data Structures Part 2: Data Structures PD Dr. rer. nat. habil. Ralf-Peter Mundani Computation in Engineering (CiE) Summer Term 2016 Overview general linked lists stacks queues trees 2 2

2. Names, Scopes, and Bindings

2. Names, Scopes, and Bindings Binding, Lifetime, Static Scope, Encapsulation and Modules, Dynamic Scope Copyright 2010 by John S. Mallozzi Names Variables Bindings Binding time Language design issues

4.3 Stacks and Queues. Pushdown Stacks. Data Structures and Data Types. Collections

Data Structures and Data Types 4.3 Stacks and Queues Data types Set values. Set operations on those values. Some are built in to Java: int, double, char,... Most are not: Complex, Picture, Charge, Stack,

DATA STRUCTURE - QUEUE

DATA STRUCTURE - QUEUE http://www.tutorialspoint.com/data_structures_algorithms/dsa_queue.htm Copyright tutorialspoint.com Queue is an abstract data structure, somewhat similar to stack. In contrast to

A linear structure is an ordered (e.g., sequenced) arrangement of elements.

Lists, Stacks, and Queues 1 A linear structure is an ordered (e.g., sequenced) arrangement of elements. There are three common types of linear structures: list stack queue random insertion and deletion

243 Week 3 Lecture - Interfaces

One problem, many solutions 243 Week 3 Lecture - Interfaces Suppose we want to implement a set of classes to represent various shapes such as circles and rectangles. We want to be able to calculate the

recursion, O(n), linked lists 6/14 recursion reducing the amount of data to process and processing a smaller amount of data example: process one item in a list, recursively process the rest of the list

Chapter 8: Bags and Sets

Chapter 8: Bags and Sets In the stack and the queue abstractions, the order that elements are placed into the container is important, because the order elements are removed is related to the order in which

Unordered Linked Lists Derive class unorderedlinkedlist from the abstract class linkedlisttype Implement the operations search, insertfirst, insertlast, deletenode See code on page 292 Defines an unordered

Data Structures Using C++ 2E. Chapter 5 Linked Lists

Data Structures Using C++ 2E Chapter 5 Linked Lists Doubly Linked Lists Traversed in either direction Typical operations Initialize the list Destroy the list Determine if list empty Search list for a given

Stacks. The stack ADT Stack Implementation. Stack Examples. using arrays using generic linked lists using List ADT. EECS 268 Programming II 1

Stacks The stack ADT Stack Implementation using arrays using generic linked lists using List ADT Stack Examples 1 Stacks and Queues Linear data structures each item has specific first, next, and previous

Sequences in the C++ STL

CS 311 Data Structures and Algorithms Lecture Slides Wednesday, November 4, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org 2005 2009 Glenn

CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team

CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team Lecture Summary In this lecture, we learned about the ADT Priority Queue. A

Introduction to Data Structures and Algorithms

Introduction to Data Structures and Algorithms Chapter: Elementary Data Structures(1) Lehrstuhl Informatik 7 (Prof. Dr.-Ing. Reinhard German) Martensstraße 3, 91058 Erlangen Overview on simple data structures

Linked Lists: Implementation Sequences in the C++ STL

Linked Lists: Implementation Sequences in the C++ STL continued CS 311 Data Structures and Algorithms Lecture Slides Wednesday, April 1, 2009 Glenn G. Chappell Department of Computer Science University

LINKED DATA STRUCTURES 1 Linked Lists A linked list is a structure in which objects refer to the same kind of object, and where: the objects, called nodes, are linked in a linear sequence. we keep a reference

&DUORV'HOJDGR.ORRV,QJHQLHUtD7HOHPiWLFD 8QLY&DUORV,,,GH0DGULG. Copyright 2001 cdk@it.uc3m.es Java: Pilas y Colas / 1

3LODV &DUORV'HOJDGR.ORRV,QJHQLHUtD7HOHPiWLFD 8QLY&DUORV,,,GH0DGULG Copyright 2001 cdk@it.uc3m.es Java: Pilas y Colas / 1 MHPSOR Copyright 2001 cdk@it.uc3m.es Java: Pilas y Colas / 2 1 MHPSOR Copyright

Algorithms and Data Structures

Algorithms and Data Structures Lists and Arrays Marcin Sydow Web Mining Lab PJWSTK Marcin Sydow (Web Mining Lab PJWSTK) Algorithms and Data Structures 1 / 35 Topics covered by this lecture: Linked Lists

Data Structures Using C++ 2E. Chapter 5 Linked Lists

Data Structures Using C++ 2E Chapter 5 Linked Lists Test #1 Next Thursday During Class Cover through (near?) end of Chapter 5 Objectives Learn about linked lists Become aware of the basic properties of

7.1 Our Current Model

Chapter 7 The Stack In this chapter we examine what is arguably the most important abstract data type in computer science, the stack. We will see that the stack ADT and its implementation are very simple.

CSE373: Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks/Queues. Linda Shapiro Spring 2016

CSE373: Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks/Queues Linda Shapiro Registration We have 180 students registered and others who want to get in. If you re thinking of dropping

Collections and Data Structures. array vs ArrayList. Using a collection or ADT

Collections and Data Structures CMPT 126: Lecture 11 Collections: Abstract Data Types and Dynamic Representation (Chapt. 12) Tamara Smyth, tamaras@cs.sfu.ca School of Computing Science, Simon Fraser University

CSE373: Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks/Queues. Nicki Dell Spring 2014

CSE373: Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks/Queues Nicki Dell Spring 2014 Registration We have 140 students registered and 140+ on the wait list! If you re thinking of

CHAPTER 4 ESSENTIAL DATA STRUCTRURES

CHAPTER 4 ESSENTIAL DATA STRUCTURES 72 CHAPTER 4 ESSENTIAL DATA STRUCTRURES In every algorithm, there is a need to store data. Ranging from storing a single value in a single variable, to more complex

Java Software Structures

INTERNATIONAL EDITION Java Software Structures Designing and Using Data Structures FOURTH EDITION John Lewis Joseph Chase This page is intentionally left blank. Java Software Structures,International Edition

14 Stacks, Queues, And Linked Lists

14-1 Java Au Naturel by William C. Jones 14-1 14 Stacks, Queues, And Linked Lists Overview This chapter requires that you have a solid understanding of arrays (Chapter Seven) and have studied Exceptions

Data Structures and Algorithms(3)

Ming Zhang Data Structures and Algorithms Data Structures and Algorithms(3) Instructor: Ming Zhang Textbook Authors: Ming Zhang, Tengjiao Wang and Haiyan Zhao Higher Education Press, 2008.6 (the "Eleventh

Introduction to Data Structures

Introduction to Data Structures Albert Gural October 28, 2011 1 Introduction When trying to convert from an algorithm to the actual code, one important aspect to consider is how to store and manipulate

1. What is the most important feature of Java? Java is a platform independent language. 2. What do you mean by platform independence? Platform independence means that we can write and compile the java

Lecture 11 Doubly Linked Lists & Array of Linked Lists In this lecture Doubly linked lists Array of Linked Lists Creating an Array of Linked Lists Representing a Sparse Matrix Defining a Node for a Sparse

Linked List as an ADT (cont d.) Default constructor Initializes list to an empty state Destroy the list Deallocates memory occupied by each node Initialize the list Reinitializes list to an empty state

! stack, queue, priority queue, dictionary, sequence, set e.g., a Stack is a list implements a LIFO policy on additions/deletions.

Abstract Data Types and Data Structures Often, these terms are used as synonyms. But it s better to think of them this way: ADTs and Data Structures An Abstract Data Type (ADT) represents a particular

Comp 245 Data Structures. Stacks

Comp 245 Data Structures Stacks What is a Stack? A LIFO (last in, first out) structure Access (storage or retrieval) may only take place at the TOP NO random access to other elements within the stack An

St S a t ck a ck nd Qu Q eue 1

Stack and Queue 1 Stack Data structure with Last-In First-Out (LIFO) behavior In Out C B A B C 2 Typical Operations Pop on Stack Push isempty: determines if the stack has no elements isfull: determines

Introduction to Stacks

Introduction to Stacks What is a Stack Stack implementation using array. Stack implementation using linked list. Applications of Stack. What is a Stack? Stack is a data structure in which data is added

Bhakta Kavi Narsinh Mehta University, Junagadh

Bhakta Kavi Narsinh Mehta University, Junagadh Draft Syllabus for B.Sc. (Computer Science) Bachelor of Science (Computer Science) (Semester - 1) Effective From June - 2016 B.Sc. (C.S.) (Semester - 1) CS-101:

Stacks. Linear data structures

Stacks Linear data structures Collection of components that can be arranged as a straight line Data structure grows or shrinks as we add or remove objects ADTs provide an abstract layer for various operations