Stacks Queues and Linked Lists Stacks Last inFirst

  • Slides: 15
Download presentation
Stacks, Queues, and Linked Lists • Stacks (Last in/First out List) – Operations: Push,

Stacks, Queues, and Linked Lists • Stacks (Last in/First out List) – Operations: Push, Pop, Test Empty, Test Full, Peek, Size • Queue(First in/First out List) – Operations: Insert, Remove, Test Empty, Test Full, Peek, Size • Linked List(A list of elements connected by pointers) – Insert, Delete, Find, Traverse, Size – Advantages: can grow, delete/insert with assignments

Complexities • Stack: – – – Push O(1) Pop O(1) Peek O(1) is. Empty

Complexities • Stack: – – – Push O(1) Pop O(1) Peek O(1) is. Empty O(1) is. Full O(1) • Queue – – – Insert O(1) Remove O(1) Peek O(1) is. Empty O(1) is. Full O(1) • List – Insert O(1) – Remove O(1) – Search O(N)

Stack Implementation • With an array – Need stack array and top members. –

Stack Implementation • With an array – Need stack array and top members. – Push: (top<MAX) ? stack[++top] = data : <error>; – Pop: (top>0) ? return stack[--top]: <error>; • With a linked list – Push: insert at front of list. – Pop: remove from front of list. • What are the complexities?

Stack: Array Implementation int top, array. Size; Data *array[]; void Stack(int s) { array

Stack: Array Implementation int top, array. Size; Data *array[]; void Stack(int s) { array = malloc(sizeof(Data)*s; array. Size = s; top = -1; } int push(Data *s) { if (is. Full()) return false; array[++top] =s; return true; } Data *pop() { if (is. Empty()) return null; return array[top--]; } int is. Empty() { return (top < 0); } int is. Full() { return top+1 == array. Size; } Data *peek() { if (is. Empty()) return null; return array[top]; } Note: In C, non-zero = true, zero = false

Stack: Linked List Implementation Data *top; Stack() { top = NULL; } void push(Data*

Stack: Linked List Implementation Data *top; Stack() { top = NULL; } void push(Data* d) { d->link=top; top=d; } Data *Pop() { if (is. Empty()) return null; Data *value = top; top = value->link; return value; } int is. Empty() {return (top == NULL); } Data *peek() { return top; }

Queue Implementation • With an array – – Circular Queue Need queue array, size,

Queue Implementation • With an array – – Circular Queue Need queue array, size, head, and tail pointers. Insert: (size<MAX) ? queue[++tail%MAX] = data : <error>; Remove: (size > 0) ? return queue[++head%MAX] : <error>; • With a linked list – Insert: Insert to back of queue – Remove: Remove from front of queue. • What are the complexities?

Queue: Array Implementation int head, tail, entries; int size; Data *array[]; public Queue(int s)

Queue: Array Implementation int head, tail, entries; int size; Data *array[]; public Queue(int s) { array = malloc(sizeof(Data)*s); size = s; head =0; tail = -1; entries = 0; } public boolean insert(Data s) { if (is. Full()) return 0; if (tail==size) tail = -1; array[++tail] = s; entries++; return 1; } public Data *remove() { if (is. Empty()) return NULL; Data *temp = array[head]; head = (head+1)%size; entries--; return temp; } int is. Empty() Data *peek() } { return entries == 0; } { if (is. Empty() return 0; return array[head]; }

Queue: Linked List Implementation Data *head, *tail; Queue(int s) { head =null; tail =

Queue: Linked List Implementation Data *head, *tail; Queue(int s) { head =null; tail = null; } int Insert(Data *s) { if (is. Empty()) { head = tail = s } else { last->link = value; tail= s; } return true; } Data *Remove() { Data *value = head; if (is. Empty()) return NULL; head = head->link; if (head == NULL) : tail = NULL; return value; } int is. Empty() Data peek() { return (head == null; } { return head; }

Linked List Implementation See Text Example • With dynamic memory – The data structure

Linked List Implementation See Text Example • With dynamic memory – The data structure uses object links. – Insert/Delete: Search; assignments to change pointers • With an array (Use indices instead of data links) – – – Need to list array, size, and pointer to initial entry. Initialization: Create free entry chain. Insert: retrieve from free list if any and do normal insertion. Delete: Do normal insertion logic and then add to free list. The data structure uses primitive links rather than object links.

Ordered Linked List Insertion Item first; void insert(Item *d ) { Item *previous =

Ordered Linked List Insertion Item first; void insert(Item *d ) { Item *previous = null; Item *current = first; while (current!=NULL && d->key > current->key) { previous=current; current=current->next); } if (previous == NULL) first = d; else previous->next = d; d->next = current; } Note: Duplicates OK in this implementation

Linked List Removal Item remove(Item *d) { Item *current = first; *previous = NULL;

Linked List Removal Item remove(Item *d) { Item *current = first; *previous = NULL; do { if (current == null) return NULL; if (!equals(current->key, d->key)) { previous = current; current = current->next; } } while (current!=null && !equals(current->key, d->key)) if (previous == NULL) first = first->next; else previous->next = current->next; return current; }

Doubly Linked List See Text Example • Two links. One to next record and

Doubly Linked List See Text Example • Two links. One to next record and one to previous. • Characteristics. – More assignments to maintain links. – Don’t need the previous temporary pointer. – More memory per record. – More secure. Used for operating systems.

Doubly Linked Insertion void insert( Item *d ) { Item *current = first, *previous

Doubly Linked Insertion void insert( Item *d ) { Item *current = first, *previous = NULL; while (current!=NULL&&compare. To(d->key, current->key)<0) { previous = current; current=current->next); } if (current == NULL) { if (previous == NULL) first = current; else previous->next = d; } else { if (current->previous==NULL) { first=d; d->next=current; current->previous=d; } else { d->previous = current->previous; d->next = current; current->previous->next = d; current->previous = d; }

Doubly Linked Removal int remove(Item *d) { Item *current = first; do { if

Doubly Linked Removal int remove(Item *d) { Item *current = first; do { if (current == NULL) return NULL; if (current->key != d->key) {current = current->next; } } while (!equals(current->key, d->key)); if (current->previous == NULL) first = current->next; else current->previous->next = current->next; if (current->next != NULL) current->next->previous = current->previous; return true; }

Stack Examples • Matching pairs of delimiters • Evaluating infix expressions – Two stacks

Stack Examples • Matching pairs of delimiters • Evaluating infix expressions – Two stacks – First convert to postfix and then evaluate • Expression examples {…{…. [. . {. <. {. . {…}…}…>. . ]. }. . } 500/(1+2*(3+4*5/2))*(3*2+1)