Linked Lists CS-212 Dick 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 HeadTailSize 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 HeadTailSize 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 Based int front, rear, cursor; item list[MAXSIZE] ; Problem: a lot of data movement especialy on inserts or add at front Static Struct Based typedef 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

to insert a node next front free cursor 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 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 cursor t = 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 dont 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

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];