Linked Lists CS-212 Dick Steflik. Linked Lists A sequential collection of information Can be...
-
Upload
sheila-starks -
Category
Documents
-
view
216 -
download
0
Transcript of Linked Lists CS-212 Dick Steflik. Linked Lists A sequential collection of information Can be...
Linked Lists
CS-212Dick Steflik
Linked Lists
A sequential collection of information
Can be unordered; i.e. in no specific order
Can be ordered; may be organized in ascending or descending order based on some specific piece of information called a key
List header contains : a link to the first node A link to the last node Other optional info (size)
List is made up of items called a node which contains: The key Other pertinent information A field called a link that indicated the location of the next node
Unordered List
Head Tail Size
4
AddAtFront()AddAtTail()TakeFromFront()TakeFromTail()
Unordered Lists
Stacks and Queues are special cases of unordered lists
An unordered list where only AddAtFront and TakeFromFront are used is a stack
An unordered list where only AddAtFront() andTakeFromRear() are used is a queue
Ordered List
Head Tail Size
4
9752
Key
Info
Link
Insert()
Take()
Delete()
Find()
Representations
Static usually used on systems without dynamic allocation
Array Array based list of static nodes Struct
Dynamic Array Collection of dynamically allocated nodes
use when you have no idea of how big or small the list will ultimately be
Static Array Basedint front, rear , cursor;
item list[MAXSIZE] ;
Problem: a lot of data movement especialy on inserts or add at front
Static Struct Basedtypedef struct {
int front, rear , cursor;
item data[MAXSIZE];
} list
Problem: same as above
Array of Nodes
typedef struct {
item v;
int next;
} node;
typedef struct {
int front , freelist , cursor;
node data[MAXSIZE];
} list;
lets say that an item is just an int
so a node is just a struct of two ints
and the list is an array where each element is two ints (it kinda looks like a 2 dim array) , but we will treat it as if it were two lists; a list of unused nodes and a list of nodes in use
next
front
free
cursor
to initialize the list(s) as empty, link all of the nodes to gether set free to point at the first free node and set front to -1 to indicate that the list is empty.
There are two lists; a list of free nodes that has all of the nodes and a empty list that has no nodes
1
2
3
4
5
6
7
-1
-1
0
to insert a node
next
front
free
cursor
-1
2
3
4
5
6
7
-1
0
1
insert(7) take the free pointer and put it in front
take the next pointer of the front node an put it in free
replace the next pointer of the front node with -1 to indicate it is the end of the list
put the data (7) in the front node
Now the list has one node in it and the free list is one node shorter
7
allocate
Lets call this process of moving a node from the free list to the list “allocate”; it should always move the node at the front of the freelist to wherever a new piece of data is to be added (front, back or middle i.e. between two nodes). Every insert should start off by allocating a node, then inserting it into the list and finally putting the data into it
This is exactly like using malloc to allocate dynamic node from the system heap, malloc and free allow the OS to manage the memory. In the absence of an OS (embedded systems) you have to do this yourself
deallocate
This is the process of moving a node from the list back to the free list and is functionally the same as the free operation used to move unneeded memory back to the system heap. In the case of deleting a node from the list the process consists of two steps; find the node to be deleted then deallocate it
Note that deleting a node will effect the next pointers of the node preceding it and that the list will now be one node shorter. The deallocated node should always be added at the front of the free list making it one node longer
Linked List Improvements
Header Node if instead of using a variables for the front pointer
we use a node that contains no information (dumy node) that just points to the first node
then insertion into an empty list and insertion at the end of the list look the same and eliminate one of the 3 special cases (front, back and middle) that need to be checked for
front dummy
cursor = id->front;
while (id->Nodes[cursor].next != NULL)
cursor = id->Nodes[cursor]. next;
//insert after cursor
t = allocate();
id->Nodes[t].next = NULL;
id->Nodes[cursor].next = t;
front dummy
cursor
cursor
See how the empty case and the end case look the same…
Another Improvement
Make the list circular with a dummy header node
If the dummy header node initially points at itself then the insertion of the first node looks like its between the front and back
List is empty when front = dummy.next
front dummy
cursor
front dummy
cursor
this again simplifies insertion and deletion as the action is always taking place between two nodes
cursor = id->front;while (id->Nodes[cursor].next != NULL) cursor = id->Nodes[cursor]. next;//insert after cursort = allocate();id->Nodes[t].next = NULL;id->Nodes[cursor].next = t;
Doubly Linked Lists each node has two pointers
one to the predecessor one to the successor
this simplifies insert and delete as you always have a pointer to the predecessor you don’t have to drag an extra pointer behind the
cursor to keep track where the predecessor is The cost of this is
one additional pointer per node two additional assignment instructions
prev next
t
cursor
// inserting
t = allocate(id);
pv = id->Nodes[cursor].prev ;
id->Nodes[pv].next = t;
id->Nodes[cursor].prev = t ;
id->Nodes[t].next = cursor ;
id->Nodes[t].prev = pv
// deleting
pv = id->Nodes[cursor].prev ;
nx = id->Nodes[cursor].next ;
id->Nodes[pv].next = nx ;
id->Nodes[nx].prev = pv ;
deallocate(cursor)
cursor
DLL Improvements
Make it circular eliminates special cases for empty list and adding
at the end of list
Multilists
if a list needs to be sorted by different key values for various reasons
add an additional next pointer for each sorting insert then inserts a node into several list at the
same time can get very complicated very quickly but can be
very useful if you need data sorted multiple ways
Sparse Arrays
Another use for linked lists is to represent sparse arrays needs two forward links per node
one for row pointer one for column pointer
2 0 0 04 0 0 30 0 0 08 0 0 10 0 6 0
typedef enum {head,entry} tagfield;
typedef struct matrixNode *matrixPointer;
typedef struct entryNode {
int row;
int col;
int value; };
typedef struct matrixNode {
matrixPointer down;
martixPointer right;
tagfield tag;
union {
matrixPointer next;
entryNode entry;
} u;
matrixPointer hdnode[MAXSIZE];