CCSB364 Data Structures & Algorithms Pointer & Linked List
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
CCSB364 Data Structures & Algorithms
Pointer & Linked List
Introduction
If we have a set of data, we can keep it in an array. But the problem with array is, the size is fixed Overflow Size can’t be extended Wasted if unused
To overcome this – we use linked list. To understand linked list, we must first
understand the fundamentals – the pointer.
Pointer ? Variable concept
Declaring a variable Memory allocation
Pointer ? A variable which give location of other variable.
Linked List? Put a pointer in a structure, giving the next
location of the next structure. Static variable vs. Dynamic variable
Static variable – declared and named in program Dynamic – created during program execution.
Understanding Pointers
Declare a pointerint *aPtr;int *aPtr = null;
Assigning a pointeraPtr = &aVar;
Read the pointer valueprintf(“%d “, *aPtr);
Exercise
1. Declare an integer variable a and b2. Declare pointer variables aPtr and
bPtr3. Assign a to has a value of 100, and
b to has a value of 2004. Assign aPtr to points to a5. Assign bPtr to points to aPtr6. By using bPtr, change value of a to
be the same as b.
Linked List
123
A C
a pointer in a structure, giving the next location of the next structure.
Linked List - Declaration
Linked List consist of structure Llist – is a pointer, pointing to a
linked list structure Next is a pointer in the linked list
structure
Temp
Item Next
Item NextLlist
NULL
Structure Declaration
typedef char item;typedef struct node{
item data;struct node *next;
} Node;
Declaring the linked list
Item Next
Llist
NULL
To declare a linked list
Node *Llist; //Llist –pointer pointing to a node type
Linked List Operation
Create a Nod Verify for an empty list Traversal along the linked nodes Insert new nodes Delete a node
Creating New Node
Node *newnode (item c) {
Node *n;n = (Node *) malloc (sizeof (Node));if ( n != NULL) {
n-> data = c;n->next = NULL;
}return n;
}
Insert New Node at the begining
Item Next
Temp
NULL
Item Next Item Next
Llist
NULL
Item Next
Temp
X
Item Next Item Next
Llist
NULL
Inserting node in the middle
Item Next
Temp
NULL
Item Next Item Next
Llist
NULLItem Next
CurrPtr
Item Next
Temp
Item Next Item Next
Llist
NULLItem Next
CurrPtr
Insert New Node - implementation
void InsertNode( Node *Llist, Node *temp, Node *CurrPtr){
{if (CurrPtr ==NULL) {
temp->next = Llist;Llist = temp;
}else {
temp->next = CurrPtr->next;CurrPtr –>next = temp;
}}
Traverse The List
void Traversal ( Node *Llist) {Node *Temp;Temp = Llist;while ( Temp != NULL) {
printf (“data = %c", Temp->data);Temp = Temp-> next;
}}
Item Next Item Next
Llist
NULL
Item Next Item Next
Llist
NULL
Temp
Deleting first nodeTemp
Item Next Item NextLlist
NULL
Temp
Item Next Item Next
Llist
NULLX
Deleting middle or last node
Temp
Item Next Item Next
Llist
NULLItem Next
CurrPtr
Temp
Item Next Item Next
Llist
NULL
Item Next
CurrPtr
Deleting Node - implementation
void DeleteNode( Node *Llist, Node *CurrPtr){Node *temp;
if (CurrPtr ==NULL) {temp = Llist;Llist = temp->next;
}else {
temp = CurrPtr->next;CurrPtr –>next = temp->next;
}free(temp)}
Type of Linked List
Simple one-way linked list
L
x1 x2 x3 x4
Type of Linked List
Circular Linked ListFormed by having the link in the l
ast node of a one way linked list point back to the first node.
L
x1 x2 x3 x4
Type of Linked List
Two Way Linked ListFormed from nodes that have
pointers to both their left and right neighbours in the list
L
x3x1 x2
Type of Linked List
Linked List with Header NodeHeader points to the first node
As a marker / stopping placeEase the deletion process of a node
L x1 x2 x3 x4L
Header Node
Linked List Using Array
Older and widely used computer language (COBOL, Fortran, BASIC) do not provide facilities for dynamic storage allocation (pointers)
Workspace (several arrays hold different part of a logical record) is used for programming languages which do not support records.
Linked List Using Array
Implementation of linked list using array is preferred if: Number of entries is known in advance Few insertions or deletions Data are sometimes best treated as a
linked list and other times as a contiguous
Linked List Using Array
typedef char ListEntry;typedef int ListIndex;typedef struct listnode{
ListEntry entry;ListIndex next;
} ListNode;typedef int Position;typedef struct list{
ListIndex head;int count;
}List;ListIndex avail,lastused;ListNode workspace[10]
Array Linked List – New NodeListIndex NewNode (void){
ListIndex newindex = -1;
if(avail != -1) {newindex = avail;avail = workspace[avail].next; workspace[newindex].next = 0;
} else if (lastused < MAXLIST - 1) {
newindex = ++lastused;workspace[newindex].next = 0;
} elseprintf (“ Error Overflow : workspace for linked list is full”);
return newindex;}
Array Linked List - Insertvoid InsertList ( Position p, ListEntry x, List *list){
ListIndex newindex, previous;if ( p <0 || p > list->count) printf(“ Error inserting into a nonexistent position”);else { newindex = NewNode(); workspace[newindex].entry = x; if (p == 0) {
workspace[newindex].next = list->head; list->head = newindex;
} else {
SetPosition(p-1, &previous, list); workspace[newindex].next=workspace[previous].next;
workspace[previous].next = newindex; } list->count ++;
}}
Array Linked List - Disposevoid DisposeNode (ListIndex oldindex, List *list){
ListIndex previous;if( oldindex == -1)
printf(“Error : Disposing a nonexistent node”); else {
if ( oldindex == list-> head)list->head = workspace[oldindex].next;
else { SetPosition(CurrentPosition(oldindex,list)– 1, &previous, list);
workspace[previous].next=workspace[oldindex].next; }
workspace[oldindex].next = avail; avail = oldindex;
}}
Array Linked List - Traverse
void TraverseList (List *list){
ListIndex current;
for (current= list->head ; current != -1; workspace[current].next)printf(”data of workspace[%d].entry = %c”, current,
workspace[current].entry);}
Class Exercise Write a complete program to create, insert and
delete a linked list. Each list will consist of ID (an integer) and Grade (a character)
Guides Declare linked list structure Writes all the ADT funtions (newNode, InsertNode,
DeleteNode, TraverseNode) In main program:
Create new node Traverse the list Create another node Insert into the existing list Traverse list Delete the last node Traverse list Insert new node Traverst list
Related Documents
