1. C and Data Structures Baojian Hua bjhua@ustc.edu.cn
Linked List
C and Data Structures
Baojian Hua

2. Recap The extensible array-based implementation of linear list:
may be too slow
insert or delete operations involve data movement
may be too space waste
only a small portion of the allocated space is occupied with data
General computer science idea
“pay as you go”

3. Polymorphic Abstract Data Types in C
// recall the poly ADT:
#ifndef LIST_H
#define LIST_H
typedef void *poly;
typedef struct listStruct *list;
list newList ();
int length (list l);
poly nth (list l, int n);
void insert (list l, poly x, int i);
poly delete (list l, int i);
void foreach (list l, void (*f)(poly));
#endif

4. Implementation Using Linked List
Linked list is a self-reference structure:
to simplify operations, we add a unique head node “head”
“head” does not belong to the list
may hold meta information of the list
head …

5. Linked List-based Implementation
// Turn the above figure into C, we have:
// in file “linkedList.c”
#include <stdlib.h>
#include “list.h”
struct listStruct {
poly data;
list next; };
data
next
head …

6. Operation: “newList” // “new” returns an empty list, which consists of
// a single head node.
list newList () {
list l = (list)malloc (sizeof (*l));
l->data = NULL; // Why this?
l->next = NULL;
return l; } /\ l

7. Operation: “length” int length (list l) { list p = l->next;
int n = 0;
while (p) {
p = p->next;
n++; }
return n;
n==0
data
next l … p

8. Operation: “length” int length (list l) { list p = l->next;
int n = 0;
while (p) {
p = p->next;
n++; }
return n;
n==1
data
next l … p

9. Operation: “length” int length (list l) { list p = l->next;
int n = 0;
while (p) {
p = p->next;
n++; }
return n;
n==2
data
next l … p

10. Operation: “length” int length (list l) { list p = l->next;
int n = 0;
while (p) {
p = p->next;
n++; }
return n;
n==3
data
next l … p

11. Operation: “nth” poly nth (list l, int n) { list p = l->next;
int i = 0;
if (n<0 || n>=length(l))
error (“invalid index”);
while (i!=n) {
p = p->next;
i++; }
return p;

12. Operation: “nth” n==2 i==0 l … p data next n==2 i==1 l … data p next

13. Operation: “insert” void insert (list l, poly x, int n) {
// 1. change the “next” field of pointer t;
// 2. change the “next” field of element (n-1) …; }
n==2
we’d search pointer p l …
data
next
data
next
data
next x
next t

14. Operation: “insert” void insert (list l, poly x, int n) { list p;
if (n<0 || n>length(l))
error (“invalid index”);
// search pointer p points to position n-1
p = n? (nth (l, n-1)) : l;

15. Operation: “insert” // continued… // Step #1: cook list node:
list temp = (list)malloc (sizeof (*temp));
temp->data = x;
// Step #2: temp points to n-th data item
temp->next = p->next;
// Step #3: link temp onto list
p->next = temp;
return; }

16. Operation: “delete” poly delete (list l, int n) {
// The key step is to search pointer p
// Leave this as exercise.
// See Lab #3. …; }
n==2
we’d search pointer p l …
data
next
data
next
data
next

17. Operation: “foreach” void foreach (list l, void (*f)(poly)) {
list p = l->next;
while (p) {
f (p->data);
p = p->next; } l …
data
next
data
next
data
next

18. Linked List Summary Linked list: Can be further generalized:
better space usage---no waste
good time complexity
insert or delete take linear time
but have to search the data sequential, :-(
Can be further generalized:
circular linked list
doubly linked list
doubly circular linked list

19. Circular Linked List All the pointers forms a circle
Note that the first node has two fields
head: points to the head of the list
tail: points to the tail of the list l
head
tail
data
next
data
next
data
next

20. Circular Linked List---Implementation
// in file “clist.c”
struct listStruct {
struct node *head;
struct node *tail; };
struct node
poly data;
struct node *next; }
head
tail
data
next l

21. Linear List Application #1: Polynomials
where ciR and n Nat
uniquely determined by a linear list:
For this representation, all the list operations apply

22. Linear List Application: Polynomials
Space waste:
Consider this:
20001 items with 3 non-zeros
A refined representation:
ci<>0 for 0<=i<=m
Ex:

23. Polynomial ADT: Interface
Abstract data type: polyn
represent the polynomial data type
operations:
polyn newPolyn (); // an empty polyn
polyn add (polyn p1, polyn p2);
real value (polyn p, real x0); // p(x0)
polyn mult (polyn p1, polyn p2);
// add an item c*x^n, which does not appear in p
void insert (polyn p, real c, int n);

24. Polynomial ADT in C: Interface
// in file “polyn.h”
#ifndef POLYN_H
#define POLYN_H
typedef struct polynStruct *polyn;
polyn newPolyn ();
polyn add (polyn p1, polyn p2);
real value (polyn p, real x0);
polyn mult (polyn p1, polyn p2);
void insert (polyn p, real c, int n);
#endif

25. Polynomial ADT in C: Implementation
// in file “polyn.c”
#include “linkedList.h”
#include “polyn.h”
struct polynStruct {
linkedList coefExps; };
// where “coefExps” is a list of tuples: (c, n)
// one way to read “list coefExps” is:
// list<tuple<double, nat>> coefExps
// However, C does not support this style of
// declaration… :-(

26. Operation: “newPolyn”
polyn newPolyn () {
polyn p = (polyn)malloc (sizeof (*p));
// use a linked list internally
p->coefExps = newLinkedList ();
return p; }

27. Operation: “insert” void insert (polyn p, real c, nat n) {
// could we use “double” and “int”, instead of
// “real” and “nat”?
tuple t = newTuple (c, n);
linkedListInsertAtTail (p->coefExps, t);
return; }
// Leave other functions as exercises.

28. Change to the Head #include <stdlib.h> #include “linkedList.h”
#include “tuple.h”
#include “polyn.h”
struct polyn {
linkedList coefExps; };

29. Linear List Application#2: Dictionary
Dictionay:
where ki are keys and vi are value
all ki are comparable and distinct
How can dict’ be represented in computers?
many ideas (we’d discuss some in future)
for now, we make use of a linear list

30. Dictionary ADT: Interface
Abstract data type: dict
represent the dictionary data type
operations:
dict newDict (); // an empty dict
void insert (dict d, poly key, poly value);
poly lookup (dict d, poly key);
poly delete (dict d, poly key);

31. “dict” ADT in C: Interface
// in file “dict.h”
#ifndef DICT_H
#define DICT_H
typedef struct dictStruct *dict;
dict newDict ();
void insert (dict d, poly key, poly value);
poly lookup (dict d, poly key);
poly delete (dict d, poly key);
#endif

32. “dict” ADT in C: Implementation
// in file “dict.c”
#include “linkedList.h”
#include “dict.h”
struct dictStruct {
linkedList l; };

33. Operations: “new” dict newDict () {
dict d = (dict)malloc (sizeof (*d));
d->l = newLinkedList ();
return d; }

34. Operations: “insert” void insert (dict d, poly key, poly value) {
tuple t = newTuple (key, value);
linkedListInsertAtHead (d->l, t);
return; }
// Leave other functions as programming
// exercises.