Transcript STRUCTURES AND LIST PROCESSING

LIST PROCESSING
1
Self Referential Structures 1/4
struct node {
int data;
struct node *next; };
A structure of type struct node
data
next
struct node a,b;
a
data
b
next
data
next
a.data=1; b.data=2;
a.next= b.next=NULL; // a and b do not point to some other node
a
1
b
NULL
2 Kumova Metin
NULL
Senem
2
Self Referential Structures 2/4
// next is a pointer to a “struct node” object
a.next= &b; // next node for a is b
// as a result b = *(a.next)
1
&b
a
2
a.next=&b
NULL
b
*(a.next).data =? a.next->data =?
3
Self Referential Structures 3/4
struct node { int data; struct node *next; };
struct node * p1 ;
struct node * p2;
// Create objects using pointers, pointers store the address of each object
p1= (struct node *)malloc(sizeof(struct node));
p2= (struct node *)malloc(sizeof(struct node));
p1->data = 4;
p2->data= 5;
p1
data=4 // next=p2
p2
data=5 // next=NULL
p1->next= p2; // p2 indicates adress of object
P2->next =NULL;
4
Self Referential Structures 4/4
struct node * p3= malloc(sizeof(struct node));
p3->data=1;
p3->next=NULL;
p2->next= p3;
p1
p2
data=4 // next=p2
p3
data=1 // next=NULL
data=5 // next=p3
p1->next
p1->next->next
==
==
p2->data
p3->data
p1->next->data
p1->next->next->data
==
==
p2
p3
5
Linear Linked Lists
data next
head
data
next
data next
NULL
head->next
Linear linked list is a data structure of explicit ordering of
items (nodes)
Each item(node) contains two portions:
•information(data) portion
•next address portion
Generally the variable head contains an address or pointer
that gives the location of the first node of the linked list
6
Linear Linked Lists : Definition
data next
head
data
next
data next
NULL
head->next
struct node
{ int data; struct node *next; };
// type name for new type is “struct node”
struct node * head; // declares the pointer for first node (head)
7
Linear Linked Lists : 2 nodes in main()
struct node
{ int data; struct node *next; };
main()
{
struct node * head;
/* Create List */
head = (struct node *)malloc(sizeof(struct node));
head->data=1;
head->next=NULL;
}
head
data=1
next=NULL
/* Add 1st element */
head->next= (struct node *) malloc(sizeof(struct node));
head->next->data =2;
head
head->next
head->next->next=NULL;
data=1
data=2
next=&
next=NULL
8
Linear Linked Lists :
Create and fill 3 nodes in main()
typedef struct node
{ int data; struct node *next; } NODE;
main()
{ NODE * head;
head = malloc(sizeof(NODE));
head->data=1; head->next=NULL;
/* Add 1st element */
head->next= malloc(sizeof(NODE));
head->next->data =2;
head->next->next=NULL;
/* Add 2nd element */
head->next->next = malloc(sizeof(NODE));
head->next->next->data =3;
head->next->next->next=NULL;
}
head
data=1
next=NULL
head
data=1
head->next
data=2
next=&
next=0
head
data=1
data=2
data=2
next=&
next=&
next=0
9
Linked List Types
Single linked lists (next)
next
Head
Tail
next
NULL
Double linked lists (next + previous)
previous
previous
Head
next
next
next
NULL
Circle linked lists (next)
Head next
Tail
next
10
Basic Linear Linked List Operations
1.
2.
3.
4.
5.
6.
7.
8.
Creating a list
Counting elements of list
Printing data in list
Inserting elements(nodes) to lists
Deleting elements(nodes) of list
Finding/searching elements in the list
Sorting elements
etc..
11
CREATING LINEAR LINKED LIST
An integer array (x[4]) will be used to create a list.
Example 1 : In main() add from head
Example 2 : In main() add from tail
Example 3 : In function ( Using Iteration)
Example 4 : In function ( Using Recursion)
How to call functions in Example 3 and 4
12
Example 1: In main() add from head
typedef struct node {int data; struct node *next; } NODE;
main(){ int x[4]={1,2,3,4};
NODE * head=NULL;
NODE* tmp=NULL;
for (i=0; i<4; i++)
{
if(head==NULL) // FIRST NODE IN LIST
{
head=malloc(sizeof(NODE));
head->data=x[i];
head->next =NULL;
else
{
}
tmp=malloc(sizeof(NODE));
tmp->data=x[i];
tmp->next=head;
head=tmp;
}
}
}
Senem Kumova Metin
13
Example 2 : In main() add from tail
typedef struct node {int data; struct node *next; } NODE;
main()
{
int x[4]={1,2,3,4};
NODE * head=NULL;
NODE * tail=NULL;
for (i=0; i<4; i++)
{
if(head==NULL) // FIRST NODE IN LIST
{
head=malloc(sizeof(NODE));
head->data=x[i];
head->next =NULL;
tail=head;
else
{
}
tail->next=malloc(sizeof(NODE));
tail=tail->next;
tail->data=x[i];
Senem
Kumova Metin
tail->next=NULL;
}
}
14
Example 3 : In function ( Using Iteration)
NODE * create_ite (int x[] , int size)
{ NODE * head = NULL; NODE * tail =NULL; int
i;
if(size!=0)
{
head = malloc(sizeof(NODE));
head -> data = x[0];
tail = head;
for (i = 1; i<size; ++i)
{
/* add to tail */
tail -> next = malloc(sizeof(NODE));
tail = tail -> next;
tail -> data = x[i]; }
tail -> next = NULL; /* end of list */
}
return head;
}
Senem Kumova Metin
15
Example 4 : In function (Using Recursion)
NODE * create _rec(int x[], int size)
{
NODE * head;
if (size==0 ) /* base case */
return NULL;
else {
/* method */
head = malloc(sizeof(NODE));
head -> data = x[0];
head -> next = create_rec(x + 1 , size-1);
return head;
}
}
16
How to call create functions in Example 3 and 4
typedef struct node
{ int data; struct node *next; } NODE;
NODE * create_ite (int x[] , int size) ; // prototype for iterative function
NODE * create _rec(int x[], int size) ; // prototype for recursive function
main()
{
int x[4]={1,2,3,4};
NODE * head1;
NODE * head2;
head1=create_ite(x,4);
head2=create_rec(x,4); }
17
Count Elements of a List
Example 1 : Using Iteration
Example 2: Using Recursion
How to call them in main()
18
Example 1 : Iteration
int count_list_ite (NODE * head)
{
int count=0;
for (; head != NULL; head = head -> next)
++count;
return count;
}
Example 2 : Recursion
int count_list_rec (NODE * head)
{
if (head == NULL)
else
return 0;
return(1 + count_list_rec(head -> next)); }
19
How to call count functions in Example 1 and 2
typedef struct node
{ int data; struct node *next; } NODE;
int count_list_ite (NODE * head); // prototype for iterative function
int count_list_rec (NODE * head); // prototype for recursive function
main()
{
int x[4]={1,2,3,4}; int size1, size2 ;
NODE * head;
head=create(x,4);
size1= count_list_ite(head);
size2= count_list_rec(head);
}
20
Print Elements of a List
Example 1 : Using Iteration
Example 2: Using Recursion
21
Example 1 : Using Iteration
void print_ite (NODE * head)
{
NODE * p;
if (head == NULL)
printf(“NULL list”);
else {
for (p = head; p != NULL; p = p -> next)
printf(“%d\n ”, p -> data);
}
}
22
Example 2 : Using Recursion
void print_rec (NODE * head)
{
if (head == NULL) printf(“NULL list”);
else
{
printf(“%d\n”, head -> data);
print_rec(head ->next);
}
}
23
Insertion of Elements in a List
void insert(NODE * p1, NODE * p2, NODE * q)
{
assert (p1-> next == p2);
/*
if the expression inside assert is false, the system will
print a message and the program will be aborted */
p1->next = q;
initially
q->next = p2; }
p2
p1
A
C
next
next
NULL
q
B
next
24
How to call insert function
typedef struct node
{ int data; struct node *next; } NODE;
/* Function prototypes */
NODE * create_rec( int x[], int size);
void insert(NODE * p1, NODE * p2, NODE * q)
void print_ite (NODE * head)
main()
{
int x[4]={1,2,3,4};
NODE * head;
NODE n;
n.data=7;
n.next=NULL;
head=create(x,4);
insert(head->next,head->next->next, &n);
print_ite(head);
}
25
Delete Elements of a List
Example 1 : Using Iteration
Example 2: Using Recursion
26
Example 1 : Using Iteration
void delete (NODE * head)
{
NODE * p; NODE * q;
if (head == NULL)
else
printf(“NULL list”);
{ p=head;
while (p != NULL;)
{
q=p;
p = p -> next ;
free(q);
}
}
}
27
Example 2 : Using Recursion
void delete (NODE * head)
{
if (head != NULL)
{ delete(head ->next);
free(head);
}
}
28