CS240 Mike Lam, Professor Linked Lists Retrospective Arrays are - - PowerPoint PPT Presentation

CS240

Mike Lam, Professor

Linked Lists

Retrospective

• Arrays are great

– O(1) access time to any element – Amortized O(1) insertion and removal – Referential arrays allow arbitrary-sized objects

• There are still disadvantages

– Occasional O(n) worst-case costs – Requires large chunks of reserved memory – Insertion/removal in the middle is expensive

Retrospective

• Goal: Do less work when inserting and removing in the

middle of our lists

2 3 5 8

Retrospective

• Goal: Do less work when inserting and removing in the

middle of our lists

• Let's "pull apart" the array

2 3 5 8 2 3 5 8

Retrospective

• Goal: Do less work when inserting and removing in the

middle of our lists

• Let's "pull apart" the array
• And add links between all the items

2 3 5 8 2 3 5 8 2 3 5 8

Linked Lists

• This is a "linked list"
• Every item has a "next" pointer/reference

– Last item has a NULL "next" pointer

• Add and remove items by manipulating the pointers
• Keep external pointers to the beginning ("head") and

end ("tail") of the list

2 3 5 8

Singly-Linked Lists

• Singly-linked list:

"a" "b" "c" NULL head tail single link per node

Singly-Linked Lists

• Node:

typedef struct linknode { data_t data; struct linknode *next; } linknode_t;

• Linked list:

typedef struct { linknode_t *head; linknode_t *tail; size_t size; } linklist_t;

Singly-Linked Lists

• Creating new linked-list nodes:

linknode_t* malloc_node(data_t value) {

linknode_t *new_node = (linknode_t*)malloc(sizeof(linknode_t));

// TODO: check for null new_node->value = value; new_node->next = NULL; return new_node;

}

Singly-Linked Lists

• Inserting at the head:

linknode_t *newest = malloc_node(x); newest->next = head; head = newest;

Singly-Linked Lists

• Inserting at the tail:

linknode_t *newest = malloc_node(x); newest->next = NULL; tail->next = newest; tail = newest;

Singly-Linked Lists

• Removing from the head:

if (head == NULL) ERROR!

• ld_head = head;

head = head->next; free(old_head);

Singly-Linked Lists

• Removing from the tail:

if (tail == NULL) ERROR

• ld_tail = tail;

tail = ???

• Problem: Can't access previous node

Singly-Linked Lists

• Removing from the tail:

if (tail == NULL) ERROR

• ld_tail = tail;

tail = ???

• Problem: Can't access previous node

– Solution: Track previous nodes as well

• (doubly-linked lists)

Challenge

• Given a singly-linked list called "data", write a

snippet of code that will print out all of the values in the list

Singly-Linked Lists

• Insert: O(1)

– if you have a reference to the location – O(n) if the new location is index-based or the list

needs to be sorted

• Delete: O(1)

– if you have a reference to the item – O(n) if you have to look for it

• Indexed access or search: O(n)

Linked Stack

• Consider stack implementation using a singly-

linked list

Linked Stack

• Consider stack implementation using a singly-

linked list

– Insert and remove at the head – Push, pop, and top are O(1)

Linked Queue

• Consider queue implementation using a singly-

linked list

Linked Queue

• Consider queue implementation using a singly-

linked list

– Insert at tail, remove from head

• Can't remove from the tail!

– Enqueue, dequeue, and first are O(1)

Looking ahead

• What if we kept two pointers?

– "next" and "prev" – This is a "doubly-linked list"

• What if tail.next pointed to the head?

– This is a "circularly-linked list"

• What if we kept multiple pointers to places

further down the list?

– This is a "skip list"

Doubly-Linked Lists

• Two references: prev and next

– To predecessor and successor nodes

• Allows insert and remove at both ends

– Can now implement stacks, queues, and deques – “Deque” = “double-ended queue”

Circularly-Linked Lists

• Keep a single node reference
• Useful for round-robin scheduling

– New operation: rotate()

• Can be used to implement regular list

– No need to track both head and tail – head = tail.next

Sentinels

• Placeholder (“fake”) nodes at head and/or tail

2 head tail head tail Empty list: After append(2): 2 3 head tail After append(3): 2 3 5 head tail After append(5):

Sentinels

• Simplifies logic of insertion and removal

void list_append(list_t *a, x) { linknode_t *new = malloc_node(x); new->prev = a->tail; new->next = NULL; if (list->head == NULL) { a->head = new; } else { a->tail->next = new; } a->tail = new; } void list_append(list_t *a, x) { linknode_t *new = malloc_node(x);

new->prev = a->tail->prev; new->next = a->tail; a->tail->prev->next = new; a->tail->prev = new; }

2 3 5 head tail head tail Empty list: Populated list:

Deques

• Double-ended queue
• Two sets of insert/remove methods:

– addfirst and removefirst – addlast and removelast

• Implementation using doubly-linked list w/

sentinels

Tradeoffs

• Advantages of linked lists

– Worst-case O(1) bounds

• No amortized bounds

– O(1) insertions and removals at arbitrary positions

• No need to shift elements
• This is a HUGE advantage!

Tradeoffs

• Advantages of arrays

– O(1) access to elements by index – Proportionally fewer actual operations

• Calculation and dereference vs. memory allocation and

reference re-arranging

– Proportionally less memory usage

• Both arrays and linked lists can be referential
• Arrays require at most 2n space overhead, while linked

lists are at least 2n (or 3n for doubly-linked lists)