Transcript Stacks, Queues, and Linked Lists

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)
isEmpty O(1)
isFull O(1)
• Queue
–
–
–
–
–
Insert O(1)
Remove O(1)
Peek O(1)
isEmpty O(1)
isFull O(1)
• List
– Insert O(1)
– Remove O(1)
– Search O(N)
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, arraySize; Data *array[];
void Stack(int s)
{ array = malloc(sizeof(Data)*s; arraySize = s; top = -1; }
int push(Data *s)
{ if (isFull()) return false; array[++top] =s; return true; }
Data *pop()
{ if (isEmpty()) return null; return array[top--]; }
int isEmpty()
{ return (top < 0); }
int isFull()
{ return top+1 == arraySize; }
Data *peek()
{ if (isEmpty()) 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* d) { d->link=top; top=d; }
Data *Pop()
{ if (isEmpty()) return null;
Data *value = top; top = value->link; return value; }
int isEmpty() {return (top == NULL);}
Data *peek() { return top; }
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)
{ array = malloc(sizeof(Data)*s); size = s; head =0; tail = -1; entries = 0;}
public boolean insert(Data s)
{ if (isFull()) return 0; if (tail==size) tail = -1;
array[++tail] = s; entries++; return 1; }
public Data *remove()
{ if (isEmpty()) return NULL; Data *temp = array[head];
head = (head+1)%size; entries--; return temp; }
int isEmpty() { return entries == 0; }
Data *peek() { if (isEmpty() return 0;
return array[head]; }
}
Queue: Linked List Implementation
Data *head, *tail;
Queue(int s)
{ head =null; tail = null; }
int Insert(Data *s)
{ if (isEmpty()) { head = tail = s }
else { last->link = value; tail= s; }
return true; }
Data *Remove()
{ Data *value = head;
if (isEmpty()) return NULL;
head = head->link; if (head == NULL) : tail = NULL; return value;
}
int isEmpty()
Data peek()
{ return (head == null; }
{ return head; }
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 = 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;
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 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 = NULL;
while (current!=NULL&&compareTo(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 (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
– First convert to postfix and then evaluate
• Expression examples
{…{….[..{.<.{..{…}…}…>..].}..}
500/(1+2*(3+4*5/2))*(3*2+1)