Lecture 13 - Linked Lists Flashcards
linked list
struct node {
int value;
struct node *next_ptr;
};
- create three and put them together in memory
- let each one point to the next, and the last have a NULL pointer
- this creates a linked list
code for basic linked list
struct node *one_ptr = NULL;
struct node *two_ptr = NULL;
struct node *three_ptr = NULL;
one_ptr = malloc(sizeof(struct node))’
one_ptr->value = 12;
// same for two/three
one_prt->next_ptr = two_ptr;
two_ptr->next_ptr = three_ptr;
three_ptr->next_ptr = NULL;
why that basic code has too many pointers
- in practice, we would do the previous example without using so many pointers
- for instance, we can refer to any element within any of the structures via the first structure
- ex. one_ptr->next_ptr->value is the value of the second element in the list
forming a linked list: growing “forward”
- adding to end of list
- use one pointer to refer to the “head” of the list
- use second pointer to refer to the “tail” of the list
- add every new structure to tail->next_ptr
forming a linked list: growing “backward” (adding to the beginning)
- adding to beginning of list
- use one pointer to refer to the “head” of the list
- use a temporary pointer to refer to a new structure
- set temp->next_ptr = head
- set head = temp
special case for first node
- the first thing we must to for LLs is allocate the head
- if (head == NULL) {
head = malloc(sizeof(struct node));
assert(head != NULL);
head->next_ptr = NULL;
} - in the forward growing case, we then set the tail to the head
forward growing initial setup
- declare head and tail variables
- set tail equal to head
- they will both be pointing to the same next value
- the next value’s next_ptr is NULL
forward growing (step two)
- make the next_ptr of head/tail point to the value you want to add
- added value’s next-ptr is NULL
- allocate size for added value
forward growing (step three)
- change it so the tail is equal to the final added value
- tail = tail->next_ptr;
reverse growing (initial setup)
- create head and temp variables
- head’s next_ptr points to a value, temp is NULL
reverse growing (step two)
- temp points to a value now
- head points to the same thing
reverse growing (step three)
- make the head point to the same next_ptr as the temp
- temp->next_ptr = head;
- head = temp;
traversing a linked list
- usually, you do not know how many structures are in a linked list
- have to “traverse” it to find an item or do work on the structures
- you can traverse a linked list with one extra pointer
p = head;
while (p != NULL) {
p->value++;
p = p->next_ptr;
}
deleting a linked list
- deletion of a linked list is a special case of the traversal process
common mistakes with deleting a linked list
- freeing the memory of the pointer before saving it to another variable
functions to simplify list management
- writing code to do operations on list can be repetitive, tedious, error prone
- usually a good idea to encapsulate the functionality into functions to create, delete, insert, and spend new structures
create_node() example code
- allocate a new node, check the malloc() return value and set the fields
struct node *create_node(int new_value) {
struct node *temp = NULL;
temp = malloc(sizeof(struct node));
assert(temp != NULL);
temp->value = new_value;
temp->next_ptr = NULL;
return temp;
}
linked list structs w/more variables
- normally a structure in a linked list contains many more elements than just a single value and a list pointer
doubly linked list
- without the head can’t traverse a linked list/move nodes
- a doubly linked list contains two pointers
- a “next” pointer and “previous” pointer
- goes forward and backward with pointers
example of doubly linked list declaration
include <stdio.h></stdio.h>
#include <malloc.h>
#include <assert.h></assert.h></malloc.h>
struct double_l {
int value;
struct double_l *next_ptr;
struct double_l *prev_ptr;
};
doubly linked list use example
int main() {
struct double_l *ptr = NULL;
ptr = malloc(sizeof(struct double_l));
assert(ptr != NULL);
ptr->next_ptr = NULL;
ptr->prev_ptr = NULL;
ptr->value = 15;
return ptr->value;
}
what’s wrong with this?
p = head
while (p != NULL) {
free(p);
p = p->next_ptr;
}
- the node is being freed before moving to the next node
- the pointer b becomes invalid after being freed, so this results in undefined behavior
- must save next pointer before freeing the current node
what’s wrong with this?
p = head;
while (p != NULL) {
struct node *tmp = p->next;
free(p);
p = tmp;
}
- correct way to delete a linked list
- stores pointer in tmp before freeing the current node
- free(p) deallocate s the memory but tmp still points to the next node in the list
- p = tmp updates p to point to he next node, letting the loop continue
