Category Archives: Linked List

Under this section you will learn linked list operations.

Collision Resolution in Hash Table (by linked list)

June 30, 2013 admin

Colision Resolution ( By separate chaining using linked list )

We have seen hash implementation in Array , where we can fill only one value in one slot. If new value comes it overwrites previous value. But using collision resolution by linked list we can resolve this problem and preserve the values. Whenever new value comes to the slot which is already filled then we can put new value in linked list associated with that slot.

In this method performance degrades when more values are matching with same slot.

The below picture is for hash table with collision resolution using channed linked list.

Hash function is key % 5

Collision Resolution in Hashtable in C

C Code for Collision Resolution in Hash Table is below

/* Hash Table Collision Resolution code by codingstreet.com */  
#include<stdio.h>
#include<stdlib.h>
    struct hash {

struct hashnode *ptr;

};

struct hashnode {

int val;

 struct hashnode *next;

};

struct hash *create_hash(int size)
{

struct hash *htable;

int i;

htable = (struct hash *) malloc(sizeof(struct hash) * size);

if (htable == NULL) {

printf("\n Out of Memory !!");

return NULL;
    }

for (i = 0; i < size; i++)
	htable[i].ptr = NULL;

return htable;

}

struct hashnode *create_hashnode(int val)
{

struct hashnode *tmp;

tmp = (struct hashnode *) malloc(sizeof(struct hashnode));

if (tmp == NULL)
	printf("\n System out of Memory");

tmp->next = NULL;

tmp->val = val;

}

int insert_value(struct hash **htable, int val, int hsize)
{

int slot;

struct hash *htptr = (*htable);

struct hashnode *tmp;

if ((*htable) == NULL) {

printf("\n Hash Table is not created");

return 0;

}

slot = (val) % hsize;

if (htptr[slot].ptr == NULL) {

tmp = create_hashnode(val);

htptr[slot].ptr = tmp;

}

    else {

tmp = create_hashnode(val);

tmp->next = htptr[slot].ptr;

htptr[slot].ptr = tmp;

}

return 1;

}

void print_hashtable(struct hash **htable, int size)
{

int i;

struct hashnode *tmp;

struct hash *htmp = (*htable);

for (i = 0; i < size; i++) {

tmp = htmp[i].ptr;

while (tmp != NULL) {

printf(" %d ", tmp->val);

tmp = tmp->next;

}

printf("\n");

}

}

int seach_hashtable(struct hash **htable, int val, int size)
{

int slot, found = 0;

slot = val % size;

struct hashnode *tmp;

tmp = (*htable)[slot].ptr;

while (tmp != NULL) {

if (tmp->val == val) {

found = 1;

break;

}

tmp = tmp->next;

}

return found;

}

int main()
{

struct hash *hashtable1;

int hashtable1size;

printf("\n Enter the size of HashTable : ");

scanf("%d", &hashtable1size);

hashtable1 = create_hash(hashtable1size);

if (hashtable1 != NULL)
	printf("\nTable Created Successfully !!");

int key, val, found;

    do {

printf("\n Hash Table Collision Resolution by Codingstreet.com");

printf("\n 1. Insert value ");

printf("\n 2. Search Value");

printf("\n 3. Print Table");

printf("\n 4. Exit");

printf("\n Enter the key [1-4] :");

scanf("%d", &key);

switch (key) {

case 1:

printf("\n Enter Val : ");

scanf("%d", &val);

insert_value(&hashtable1, val, hashtable1size);

break;

case 2:

printf("\n Enter Val : ");

scanf("%d", &val);

found = seach_hashtable(&hashtable1, val, hashtable1size);

if (found == 0)
		printf("\n Val not found");

	    else
		printf("\n %d found at slot %d ", val,
		       val % hashtable1size);

break;

case 3:

print_hashtable(&hashtable1, hashtable1size);

break;

case 4:

printf("\n Thank you !!! ");

break;

default:

break;

}

} while (key != 4);

printf("\n Thanks for using Codingstreet.com 's Data structure solution\n");

return 0;

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

/* Hash Table Collision Resolution code by codingstreet.com */

#include<stdio.h>

#include<stdlib.h>

struct hash {

struct hashnode *ptr;

};

struct hashnode {

int val;

struct hashnode *next;

};

struct hash *create_hash(int size)

{

struct hash *htable;

int i;

htable = (struct hash *) malloc(sizeof(struct hash) * size);

if (htable == NULL) {

printf("\n Out of Memory !!");

return NULL;

}

for (i = 0; i < size; i++)

htable[i].ptr = NULL;

return htable;

}

struct hashnode *create_hashnode(int val)

{

struct hashnode *tmp;

tmp = (struct hashnode *) malloc(sizeof(struct hashnode));

if (tmp == NULL)

printf("\n System out of Memory");

tmp->next = NULL;

tmp->val = val;

}

int insert_value(struct hash **htable, int val, int hsize)

{

int slot;

struct hash *htptr = (*htable);

struct hashnode *tmp;

if ((*htable) == NULL) {

printf("\n Hash Table is not created");

return 0;

}

slot = (val) % hsize;

if (htptr[slot].ptr == NULL) {

tmp = create_hashnode(val);

htptr[slot].ptr = tmp;

}

else {

tmp = create_hashnode(val);

tmp->next = htptr[slot].ptr;

htptr[slot].ptr = tmp;

}

return 1;

}

void print_hashtable(struct hash **htable, int size)

{

int i;

struct hashnode *tmp;

struct hash *htmp = (*htable);

for (i = 0; i < size; i++) {

tmp = htmp[i].ptr;

while (tmp != NULL) {

printf(" %d ", tmp->val);

tmp = tmp->next;

}

printf("\n");

}

int seach_hashtable(struct hash **htable, int val, int size)

{

int slot, found = 0;

slot = val % size;

struct hashnode *tmp;

tmp = (*htable)[slot].ptr;

while (tmp != NULL) {

if (tmp->val == val) {

found = 1;

break;

}

tmp = tmp->next;

}

return found;

}

int main()

{

struct hash *hashtable1;

int hashtable1size;

printf("\n Enter the size of HashTable : ");

scanf("%d", &hashtable1size);

hashtable1 = create_hash(hashtable1size);

if (hashtable1 != NULL)

printf("\nTable Created Successfully !!");

int key, val, found;

do {

printf("\n Hash Table Collision Resolution by Codingstreet.com");

printf("\n 1. Insert value ");

printf("\n 2. Search Value");

printf("\n 3. Print Table");

printf("\n 4. Exit");

printf("\n Enter the key [1-4] :");

scanf("%d", &key);

switch (key) {

case 1:

printf("\n Enter Val : ");

scanf("%d", &val);

insert_value(&hashtable1, val, hashtable1size);

break;

case 2:

printf("\n Enter Val : ");

scanf("%d", &val);

found = seach_hashtable(&hashtable1, val, hashtable1size);

if (found == 0)

printf("\n Val not found");

else

printf("\n %d found at slot %d ", val,

val % hashtable1size);

break;

case 3:

print_hashtable(&hashtable1, hashtable1size);

break;

case 4:

printf("\n Thank you !!! ");

break;

default:

break;

}

} while (key != 4);

printf("\n Thanks for using Codingstreet.com 's Data structure solution\n");

return 0;

}

C Code, Linked List

Queue implementation in C using linked list

June 21, 2013 admin

Queue implementation in C using linked list

Queue structure :

struct snode{
int val;
struct snode *next;
}

struct snode{

int val;

struct snode *next;

}

/* Queue using linked list in C. C code by codingstreet.com */ 
#include<stdio.h>
#include<stdlib.h>
struct snode{
int val;
struct snode *next;
};
void enqueue_sll(int val,struct snode **qhead,struct snode **qtail){
struct snode *tmp;
if((*qhead)==NULL){
tmp=malloc(sizeof(struct snode));
tmp->val=val;
tmp->next==NULL;
(*qhead)=tmp;
(*qtail)=tmp;
}
else {
tmp=malloc(sizeof(struct snode));
tmp->val=val;
tmp->next=NULL;
(*qtail)->next=tmp;
(*qtail)=tmp;
}
}
void dequeue_sll(struct snode **qhead){
struct snode *tmp;
if((*qhead)==NULL) return;
tmp=(*qhead);
(*qhead)=(*qhead)->next;
tmp->next=NULL;
free(tmp);
}
void print_queue(struct snode **qhead){
struct snode *tmp;
tmp=(*qhead);
while(tmp!=NULL){
printf(" %d ",tmp->val);
tmp=tmp->next;
}
printf("\n");
}
int is_queue_empty(struct snode **qhead){
if((*qhead)==NULL) return 1;
else return 0;
}
int main(){
struct snode *qh1=NULL,*qt1=NULL;
int key,val;
do{
printf("******* Queue by SLL Menu ******\n");
printf("C Code by codingstreet.com \n");
printf("[1] Enqueue \n");
printf("[2] Dequee \n");
printf("[3] PRINT Queue \n");
printf("[4] IS QUEUE EMPTY\n");
printf("[5] Exit \n");
printf("Enter the key : ");
scanf("%d",&key);
switch(key){
case 1:
printf("Enter the value : ");
scanf("%d",&val);
enqueue_sll(val,&qh1,&qt1);
break;
case 2:
if(is_queue_empty(&qh1)!=1){
dequeue_sll(&qh1);}
else printf("\n\t\t Can't dequeue because Queue is Empty !!! \n");
break;
case 3:
printf("\n Queue Contents are : \n ");
print_queue(&qh1);
break;
case 4:
if(is_queue_empty(&qh1)==1){
printf("\n Queue is Empty \n");}
else printf("\n Queue is Not Empty \n");
break;
case 5:
break;
default :
printf("\n Enter the Valid key .. . ."); 
}
}while(key!=5);
printf("\n Thanks for using codingstreet.com's Data structure solutions ");
return 0;
}

/* Queue using linked list in C. C code by codingstreet.com */

#include<stdio.h>

#include<stdlib.h>

struct snode{

int val;

struct snode *next;

};

void enqueue_sll(int val,struct snode **qhead,struct snode **qtail){

struct snode *tmp;

if((*qhead)==NULL){

tmp=malloc(sizeof(struct snode));

tmp->val=val;

tmp->next==NULL;

(*qhead)=tmp;

(*qtail)=tmp;

}

else {

tmp=malloc(sizeof(struct snode));

tmp->val=val;

tmp->next=NULL;

(*qtail)->next=tmp;

(*qtail)=tmp;

}

void dequeue_sll(struct snode **qhead){

struct snode *tmp;

if((*qhead)==NULL) return;

tmp=(*qhead);

(*qhead)=(*qhead)->next;

tmp->next=NULL;

free(tmp);

}

void print_queue(struct snode **qhead){

struct snode *tmp;

tmp=(*qhead);

while(tmp!=NULL){

printf(" %d ",tmp->val);

tmp=tmp->next;

}

printf("\n");

}

int is_queue_empty(struct snode **qhead){

if((*qhead)==NULL) return 1;

else return 0;

}

int main(){

struct snode *qh1=NULL,*qt1=NULL;

int key,val;

do{

printf("******* Queue by SLL Menu ******\n");

printf("C Code by codingstreet.com \n");

printf("[1] Enqueue \n");

printf("[2] Dequee \n");

printf("[3] PRINT Queue \n");

printf("[4] IS QUEUE EMPTY\n");

printf("[5] Exit \n");

printf("Enter the key : ");

scanf("%d",&key);

switch(key){

case 1:

printf("Enter the value : ");

scanf("%d",&val);

enqueue_sll(val,&qh1,&qt1);

break;

case 2:

if(is_queue_empty(&qh1)!=1){

dequeue_sll(&qh1);}

else printf("\n\t\t Can't dequeue because Queue is Empty !!! \n");

break;

case 3:

printf("\n Queue Contents are : \n ");

print_queue(&qh1);

break;

case 4:

if(is_queue_empty(&qh1)==1){

printf("\n Queue is Empty \n");}

else printf("\n Queue is Not Empty \n");

break;

case 5:

break;

default :

printf("\n Enter the Valid key .. . .");

}

}while(key!=5);

printf("\n Thanks for using codingstreet.com's Data structure solutions ");

return 0;

}

C progam to Queue implementation using linked list , Queue implementation in C using linked list

C Code, Linked List, stack

stack implementation using linked list in c

June 20, 2013 admin

C program to implement stack using linked list.

/* Stack implementation by linked list in C from Codingstreet.com */
#include<stdio.h>
#include<stdlib.h>
struct snode{
    int val;
    struct snode *next;
};
void push_sstack(int val,struct snode **stack){
    struct snode *stop,*tmp;
    stop=*stack;
    if(stop==NULL){
    tmp=malloc(sizeof(struct snode));
    tmp->val=val;
    tmp->next=NULL;
    (*stack)=tmp;    
    }
    else {
    tmp=malloc(sizeof(struct snode));
    if(tmp!=NULL){
    tmp->val=val;
    tmp->next=stop;
    (*stack)=tmp;}
    else     printf(" \n Memory is Full Can't insert value\n ");
    }
}
void pop_sstack(struct snode **stack){
    if((*stack)!=NULL)
    {
    struct snode *tmp,*stop;
    stop=(*stack);
    tmp=stop;
    stop=stop->next;
    *stack=stop;
    tmp->next=NULL;
    free(tmp);
    }
}
int is_stack_empty(struct snode **stack){
    if((*stack)==NULL) return 1;
    else return 0;
}
void print_sstack(struct snode **stack){
    struct snode *tmp;
    tmp=*stack;
    while(tmp!=NULL){
    printf(" %d ",tmp->val);
    tmp=tmp->next;
    }
    printf("\n");
}
int main(){
    struct snode *stack;
    int key,val;
    do{
    printf("******* Stack by SLL Menu ******\n");
    printf("[1] PUSH \n");
    printf("[2] POP \n");
    printf("[3] PRINT STACK \n");
    printf("[4] IS STACK EMPTY\n");
    printf("[5] Exit \n");
    printf("Enter the key : ");
    scanf("%d",&key);
    switch(key){
    case 1:
    printf("Enter the value : ");
    scanf("%d",&val);
    push_sstack(val,&stack);
    break;
    case 2:
    if(is_stack_empty(&stack)!=1){
    pop_sstack(&stack);}
    else printf("\n\t\t Can't Pop Value  stack is Empty !!! \n");
    break;
    case 3:
    printf("\n Stack Contents are : \n ");
    print_sstack(&stack);
    break;
    case 4:
    if(is_stack_empty(&stack)==1){
        printf("\n Stack is Empty \n");}
    else printf("\n Stack is Not Empty \n");
    break;
    case 5:
    break;
    default :
    printf("\n Enter the Valid key .. . .");    
    }
    }while(key!=5);
    printf("\n Thankyou for using Codingstreet.com 's Data structure Solution ");
return 0;
}

/* Stack implementation by linked list in C from Codingstreet.com */

#include<stdio.h>

#include<stdlib.h>

struct snode{

int val;

struct snode *next;

};

void push_sstack(int val,struct snode **stack){

struct snode *stop,*tmp;

stop=*stack;

if(stop==NULL){

tmp=malloc(sizeof(struct snode));

tmp->val=val;

tmp->next=NULL;

(*stack)=tmp;

}

else {

tmp=malloc(sizeof(struct snode));

if(tmp!=NULL){

tmp->val=val;

tmp->next=stop;

(*stack)=tmp;}

else printf(" \n Memory is Full Can't insert value\n ");

}

void pop_sstack(struct snode **stack){

if((*stack)!=NULL)

{

struct snode *tmp,*stop;

stop=(*stack);

tmp=stop;

stop=stop->next;

*stack=stop;

tmp->next=NULL;

free(tmp);

}

int is_stack_empty(struct snode **stack){

if((*stack)==NULL) return 1;

else return 0;

}

void print_sstack(struct snode **stack){

struct snode *tmp;

tmp=*stack;

while(tmp!=NULL){

printf(" %d ",tmp->val);

tmp=tmp->next;

}

printf("\n");

}

int main(){

struct snode *stack;

int key,val;

do{

printf("******* Stack by SLL Menu ******\n");

printf("[1] PUSH \n");

printf("[2] POP \n");

printf("[3] PRINT STACK \n");

printf("[4] IS STACK EMPTY\n");

printf("[5] Exit \n");

printf("Enter the key : ");

scanf("%d",&key);

switch(key){

case 1:

printf("Enter the value : ");

scanf("%d",&val);

push_sstack(val,&stack);

break;

case 2:

if(is_stack_empty(&stack)!=1){

pop_sstack(&stack);}

else printf("\n\t\t Can't Pop Value stack is Empty !!! \n");

break;

case 3:

printf("\n Stack Contents are : \n ");

print_sstack(&stack);

break;

case 4:

if(is_stack_empty(&stack)==1){

printf("\n Stack is Empty \n");}

else printf("\n Stack is Not Empty \n");

break;

case 5:

break;

default :

printf("\n Enter the Valid key .. . .");

}

}while(key!=5);

printf("\n Thankyou for using Codingstreet.com 's Data structure Solution ");

return 0;

}

C Code, Linked List

Memory Efficient doubly linked list in C

June 20, 2013 admin

So far we have seen doubly linked list which have two pointers next and previous. but in efficient doubly linked list we will use only one pointer to move at next and previous nodes.

We know XOR is used for bit recovery the same concept we will use here to store both the ptr (next and previous) information in single variable.

structure for efficient doubly linked list :

struct ednode{
int val;
struct ednode *ptr;
}

Suppose we have linked list of 4 nodes [ W | X | Y | Z ]

W->ptr= NULL ^ X

X->ptr= W ^ Y

Y->ptr= X ^ Z

Z->ptr= Y->NULL

To move at W from X

(W^Y)^Y ==> which is (X->ptr^Y) ==> which is W

similar way to move at Y from X

(W^Y)^W ==> which is (X->ptr^W) ==> which is Y

/*C Code for Memory Efficient Doubly linked list by Codingstreet.com*/
#include<stdio.h>
#include<stdlib.h>
struct ednode{
int val;
struct ednode *ptr;
};
int create_ednode(int val,struct ednode **node){
struct ednode *tmp;
tmp=malloc(sizeof(struct ednode));
if(tmp==NULL) return 0; 
tmp->val=val;
tmp->ptr=NULL;
(*node)=tmp;
return 1;
}
void insert_ednode(struct ednode **head,struct ednode **node,struct ednode **tail){
struct ednode *prev,*next,*tmp;
if((*head)==NULL && (*tail)==NULL){
(*head)=(*tail)=(*node);
(*head)->ptr=NULL;
}
else if((*head)->ptr==NULL){
next=(*node);
(*head)->ptr=(struct ednode *)((unsigned int)(NULL)^(unsigned int)(next));
next->ptr=(struct ednode *)((unsigned int)(*head)^(unsigned int)(NULL)); 
(*tail)=(*node); 
}
else {
prev=(*tail);
next=(*node);
tmp=(struct ednode *)((unsigned int)(NULL)^(unsigned int)(prev));
prev->ptr=(struct ednode *)((unsigned int)(tmp)^(unsigned int)(next));
next->ptr=(struct ednode *)((unsigned int)(NULL)^(unsigned int)(prev));
(*tail)=next; 
}

}
void print_ednode(struct ednode **head,struct ednode **tail){
struct ednode *tmp,*prev,*next;
if((*head)==NULL) return;
tmp=(*head);
prev=NULL;
while(tmp!=(*tail)){
printf(" %d ",tmp->val);
tmp=(struct ednode *)((unsigned int)(tmp->ptr)^(unsigned int)(prev));
prev=tmp;
}
printf(" %d ",tmp->val);
}
void printrev_ednode(struct ednode **head,struct ednode **tail){
struct ednode *tmp,*prev,*next;
if((*head)==NULL) return;
tmp=(*tail);
prev=NULL;
while(tmp!=(*head)){
printf(" %d ",tmp->val);
tmp=(struct ednode *)((unsigned int)(tmp->ptr)^(unsigned int)(prev)); 
prev=tmp; 
}
printf(" %d ",tmp->val);
}
int main(){
printf("\n Efficient Doubly Linked List ");
struct ednode *head=NULL,*node=NULL,*tail=NULL,*prev=NULL,*tmp;
int key,ival;
do{
printf("\n************* Efficient Doubly Linked List Menu *************");
printf("\n************* Coded by Codingstreet.com *************");
printf("\n[1] Insert Node : ");
printf("\n[2] Print List : ");
printf("\n[3] print rev list : ");
printf("\n[4] (Exit) ");
printf("\nEnter the key : ");
scanf("%d",&key);
printf("\n");
switch(key){
case 1:
printf("\nEntet the input value ");
scanf("%d",&ival);
if(create_ednode(ival,&node))
insert_ednode(&head,&node,&tail);
else printf("\n System id out of Memory !! ");
break;
case 2:
print_ednode(&head,&tail);
break;
case 3:
printrev_ednode(&head,&tail);
break;
case 4:
break;
default:
printf("\n Enter the VALID KEY [1,2,3,4] ");
break;}
}while(key!=4);
printf("\n Thanks for using codingstreet.com 's Data structure solution ");
return 0; 
}

/*C Code for Memory Efficient Doubly linked list by Codingstreet.com*/

#include<stdio.h>

#include<stdlib.h>

struct ednode{

int val;

struct ednode *ptr;

};

int create_ednode(int val,struct ednode **node){

struct ednode *tmp;

tmp=malloc(sizeof(struct ednode));

if(tmp==NULL) return 0;

tmp->val=val;

tmp->ptr=NULL;

(*node)=tmp;

return 1;

}

void insert_ednode(struct ednode **head,struct ednode **node,struct ednode **tail){

struct ednode *prev,*next,*tmp;

if((*head)==NULL && (*tail)==NULL){

(*head)=(*tail)=(*node);

(*head)->ptr=NULL;

}

else if((*head)->ptr==NULL){

next=(*node);

(*head)->ptr=(struct ednode *)((unsigned int)(NULL)^(unsigned int)(next));

next->ptr=(struct ednode *)((unsigned int)(*head)^(unsigned int)(NULL));

(*tail)=(*node);

}

else {

prev=(*tail);

next=(*node);

tmp=(struct ednode *)((unsigned int)(NULL)^(unsigned int)(prev));

prev->ptr=(struct ednode *)((unsigned int)(tmp)^(unsigned int)(next));

next->ptr=(struct ednode *)((unsigned int)(NULL)^(unsigned int)(prev));

(*tail)=next;

}

void print_ednode(struct ednode **head,struct ednode **tail){

struct ednode *tmp,*prev,*next;

if((*head)==NULL) return;

tmp=(*head);

prev=NULL;

while(tmp!=(*tail)){

printf(" %d ",tmp->val);

tmp=(struct ednode *)((unsigned int)(tmp->ptr)^(unsigned int)(prev));

prev=tmp;

}

printf(" %d ",tmp->val);

}

void printrev_ednode(struct ednode **head,struct ednode **tail){

struct ednode *tmp,*prev,*next;

if((*head)==NULL) return;

tmp=(*tail);

prev=NULL;

while(tmp!=(*head)){

printf(" %d ",tmp->val);

tmp=(struct ednode *)((unsigned int)(tmp->ptr)^(unsigned int)(prev));

prev=tmp;

}

printf(" %d ",tmp->val);

}

int main(){

printf("\n Efficient Doubly Linked List ");

struct ednode *head=NULL,*node=NULL,*tail=NULL,*prev=NULL,*tmp;

int key,ival;

do{

printf("\n************* Efficient Doubly Linked List Menu *************");

printf("\n************* Coded by Codingstreet.com *************");

printf("\n[1] Insert Node : ");

printf("\n[2] Print List : ");

printf("\n[3] print rev list : ");

printf("\n[4] (Exit) ");

printf("\nEnter the key : ");

scanf("%d",&key);

printf("\n");

switch(key){

case 1:

printf("\nEntet the input value ");

scanf("%d",&ival);

if(create_ednode(ival,&node))

insert_ednode(&head,&node,&tail);

else printf("\n System id out of Memory !! ");

break;

case 2:

print_ednode(&head,&tail);

break;

case 3:

printrev_ednode(&head,&tail);

break;

case 4:

break;

default:

printf("\n Enter the VALID KEY [1,2,3,4] ");

break;}

}while(key!=4);

printf("\n Thanks for using codingstreet.com 's Data structure solution ");

return 0;

}

Linked List

Circular Linked List in C

June 17, 2013 admin

Circular Linked List in C.

Circular linked list is a linked list whose last node points to the head of list.

Structure of Circular linked list

struct clnode{
int val;
struct clnode *next;
};

/*
*********** Circular List Menu ***********
[1] Insert value
[2] Print Circular List
[3] Print Length of list
[4] Insert at Beginning
[5] Delete front node
[6] Delete rear node
[7] Exit
*/

/* C code for Circular Linked list by Codingstreet.com */
#include&lt;stdio.h&gt;
#include&lt;stdlib.h&gt;
struct clnode{
int val;
struct clnode *next;
};
int circular_length(struct clnode **head){
int count=0;
struct clnode *tmp;
tmp=(*head);
if(tmp==NULL) return 0;
do{
tmp=tmp-&gt;next;
count++;
}while(tmp!=(*head));
return count;
}
int create_clnode(int val,struct clnode **node){
struct clnode *tmp;
tmp=malloc(sizeof(struct clnode));
if(tmp==NULL) return 0;
tmp-&gt;val=val;
tmp-&gt;next=NULL;
(*node)=tmp;
return 1;
}
void print_cl(struct clnode **head){
struct clnode *tmp;
tmp=(*head);
if(tmp==NULL) return;
do{
printf(" %d ",tmp-&gt;val);
tmp=tmp-&gt;next;
}while(tmp!=(*head));
}
void insert_clnode(struct clnode **head,struct clnode **node){
if((*head)==NULL) { (*node)-&gt;next=(*node); (*head)=(*node); return;}
else {
struct clnode *tmp;
tmp=(*head);
while(tmp-&gt;next!=(*head)){ 
tmp=tmp-&gt;next; 
}
tmp-&gt;next=(*node);
(*node)-&gt;next=(*head);
} 
}
void insert_atbeginclnode(struct clnode **head,struct clnode **node){
if((*head)==NULL) {(*node)-&gt;next=(*node); (*head)=(*node); return;}
else {
struct clnode *tmp;
tmp=(*head);
while(tmp-&gt;next!=(*head)){ 
tmp=tmp-&gt;next; 
}
tmp-&gt;next=(*node);
(*node)-&gt;next=(*head);
(*head)=(*node); 
}
}
void delete_frontclnode(struct clnode **head){
struct clnode *tmp,*crnt;
if((*head)==NULL) return;
tmp=(*head);
crnt=(*head)-&gt;next;
if(crnt==(*head)){free(tmp); (*head)=NULL; return;}
while(crnt-&gt;next!=(*head)) crnt=crnt-&gt;next;
(*head)=(*head)-&gt;next;
crnt-&gt;next=(*head);
free(tmp);
}
void delete_rearclnode(struct clnode **head){
struct clnode *tmp,*prev;;
if((*head)==NULL) return;
tmp=(*head);
prev=tmp;
while(tmp-&gt;next!=(*head)){
prev=tmp;
tmp=tmp-&gt;next; 
}
if(tmp==(*head)) (*head)=NULL;
tmp-&gt;next=NULL;
free(tmp);
prev-&gt;next=(*head);
}

int main(){
struct clnode *head=NULL,*node=NULL;
int key,ival;
do{
printf("\n*********** Circular List Menu ***********");
printf("\n[1] Insert value");
printf("\n[2] Print Circular List ");
printf("\n[3] Print Length of list ");
printf("\n[4] Insert at Begining ");
printf("\n[5] Delete front node ");
printf("\n[6] Delete rear node ");
printf("\n[7] Exit ");
printf("\nEnter the input key : ");
scanf("%d",&amp;key);
switch(key){
case 1:
printf("\n Enter the value to be inserted :");
scanf("%d",&amp;ival);
if(create_clnode(ival,&amp;node))
insert_clnode(&amp;head,&amp;node);
else printf("\n Memory is Full !! ");
break;
case 2:
printf("\n Circular List contents are :\n");
print_cl(&amp;head);
break;
case 3:
printf("\n Lenght = %d ",circular_length(&amp;head));
break;
case 4 :
printf("\n Enter the value to be inserted :");
scanf("%d",&amp;ival);
if(create_clnode(ival,&amp;node))
insert_atbeginclnode(&amp;head,&amp;node);
else printf("\n Memory is Full !! ");
break;
case 5 :
delete_frontclnode(&amp;head);
break;
case 6 :
delete_rearclnode(&amp;head);
break;
case 7 :
break;

default:
printf("\t Enter the Correct key !!!!! ");
break;
}
}while(key!=7);

return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

/* C code for Circular Linked list by Codingstreet.com */

#include<stdio.h>

#include<stdlib.h>

struct clnode{

int val;

struct clnode *next;

};

int circular_length(struct clnode **head){

int count=0;

struct clnode *tmp;

tmp=(*head);

if(tmp==NULL) return 0;

do{

tmp=tmp->next;

count++;

}while(tmp!=(*head));

return count;

}

int create_clnode(int val,struct clnode **node){

struct clnode *tmp;

tmp=malloc(sizeof(struct clnode));

if(tmp==NULL) return 0;

tmp->val=val;

tmp->next=NULL;

(*node)=tmp;

return 1;

}

void print_cl(struct clnode **head){

struct clnode *tmp;

tmp=(*head);

if(tmp==NULL) return;

do{

printf(" %d ",tmp->val);

tmp=tmp->next;

}while(tmp!=(*head));

}

void insert_clnode(struct clnode **head,struct clnode **node){

if((*head)==NULL) { (*node)->next=(*node); (*head)=(*node); return;}

else {

struct clnode *tmp;

tmp=(*head);

while(tmp->next!=(*head)){

tmp=tmp->next;

}

tmp->next=(*node);

(*node)->next=(*head);

}

void insert_atbeginclnode(struct clnode **head,struct clnode **node){

if((*head)==NULL) {(*node)->next=(*node); (*head)=(*node); return;}

else {

struct clnode *tmp;

tmp=(*head);

while(tmp->next!=(*head)){

tmp=tmp->next;

}

tmp->next=(*node);

(*node)->next=(*head);

(*head)=(*node);

}

void delete_frontclnode(struct clnode **head){

struct clnode *tmp,*crnt;

if((*head)==NULL) return;

tmp=(*head);

crnt=(*head)->next;

if(crnt==(*head)){free(tmp); (*head)=NULL; return;}

while(crnt->next!=(*head)) crnt=crnt->next;

(*head)=(*head)->next;

crnt->next=(*head);

free(tmp);

}

void delete_rearclnode(struct clnode **head){

struct clnode *tmp,*prev;;

if((*head)==NULL) return;

tmp=(*head);

prev=tmp;

while(tmp->next!=(*head)){

prev=tmp;

tmp=tmp->next;

}

if(tmp==(*head)) (*head)=NULL;

tmp->next=NULL;

free(tmp);

prev->next=(*head);

}

int main(){

struct clnode *head=NULL,*node=NULL;

int key,ival;

do{

printf("\n*********** Circular List Menu ***********");

printf("\n[1] Insert value");

printf("\n[2] Print Circular List ");

printf("\n[3] Print Length of list ");

printf("\n[4] Insert at Begining ");

printf("\n[5] Delete front node ");

printf("\n[6] Delete rear node ");

printf("\n[7] Exit ");

printf("\nEnter the input key : ");

scanf("%d",&key);

switch(key){

case 1:

printf("\n Enter the value to be inserted :");

scanf("%d",&ival);

if(create_clnode(ival,&node))

insert_clnode(&head,&node);

else printf("\n Memory is Full !! ");

break;

case 2:

printf("\n Circular List contents are :\n");

print_cl(&head);

break;

case 3:

printf("\n Lenght = %d ",circular_length(&head));

break;

case 4 :

printf("\n Enter the value to be inserted :");

scanf("%d",&ival);

if(create_clnode(ival,&node))

insert_atbeginclnode(&head,&node);

else printf("\n Memory is Full !! ");

break;

case 5 :

delete_frontclnode(&head);

break;

case 6 :

delete_rearclnode(&head);

break;

case 7 :

break;

default:

printf("\t Enter the Correct key !!!!! ");

break;

}

}while(key!=7);

return 0;

}

C Code, Linked List

Doubly Linked List in C

June 17, 2013 admin

Doubly Linked List in C

Structure for doubly linked list

struct dnode{
int val;
struct dnode *next,*prev;
};
/* Doubly linked list Menu
[1] Insert Node:
[2] Delete Node:
[3] Print List:
[4] Print List Reverse :
[5] Find Node :
[6] Exit:
*/

/* C Code for Doubly linked list by Codingstreet.com */
 #include<stdio.h> 
#include<stdlib.h>
 struct dnode{ int val;
 struct dnode *next,*prev;
 };
 int create_dnode(int val,struct dnode **node){ struct dnode *tmp;
tmp=malloc(sizeof(struct dnode));
 if(tmp==NULL) return 0;
 tmp->val=val;
 tmp->next=NULL;
 tmp->prev=NULL;
 *node=tmp;
 return 1;
 }
 int insert_dnode(struct dnode **head,struct dnode **node ){ if((*head)==NULL){ (*head)=(*node);
 (*head)->next=NULL;
 (*head)->prev=NULL;
 } else { struct dnode *root;
 root=(*head);
 struct dnode *next,*prev,*tmp;
 next=root->next;
 prev=tmp=root;
 while(next!=NULL){ prev=tmp;
 tmp=tmp->next;
 next=tmp;
 } prev->next=(*node);
 (*node)->prev=prev;
 next=prev->next;
 next->next=NULL;
 } return 1;
 } void print_dll(struct dnode **head){ struct dnode *tmp;
 tmp=(*head);
 while(tmp!=NULL){ printf(" %d ",tmp->val);
 tmp=tmp->next;
 } printf("\n");
 } void print_dll_reverse(struct dnode **head){ struct dnode *tmp;
 tmp=(*head);
 if(tmp==NULL) return;
 while(tmp->next!=NULL){ tmp=tmp->next;
 } while(tmp!=NULL){ printf(" %d ",tmp->val);
 tmp=tmp->prev;
 } printf("\n");
 } int delete_dnode(struct dnode **head,struct dnode **node){ struct dnode *root,*tmp,*next,*prev,*dlnode;
 root=*head;
 dlnode=*node;
 if(root==NULL){ return 0;
 } else if(root==dlnode && root->next==NULL){ free(root);
 *head=NULL;
 } else if(root==dlnode){ next=root->next;
 root->next=NULL;
 next->prev=NULL;
 free(root);
 root=next;
 *head=root;
 return 1;
 } else { tmp=*head;
 next=tmp->next;
 prev=tmp;
 while(tmp!=NULL){ if(tmp==dlnode){ prev->next=tmp->next;
 tmp->next=prev;
 tmp->next=NULL;
 tmp->prev=NULL;
 free(tmp);
 return 1;
 } prev=tmp;
 tmp=tmp->next;
 } return 0;
 } } struct dnode *find_dnode(struct dnode **head,int val){ struct dnode *root;
 root=*head;
 if(root==NULL){ return NULL;
 } else if(root->val==val){ return root;
} else { struct dnode *tmp;
 tmp=root;
 while(tmp!=NULL){ if(tmp->val==val){ return tmp;
 } tmp=tmp->next;
} return tmp;
 } } int main(){ struct dnode *head=NULL,*node=NULL;
 int val,ival;
 do { printf("\n----------------------------------");
 printf("\n Doubly Linked List Menu : \n");
 printf("[1] Insert Node: \n");
 printf("[2] Delete Node: \n");
 printf("[3] Print List: \n");
 printf("[4] Print List Reverse : \n");
 printf("[5] Find Node :\n");
 printf("[6] Exit: \n");
 printf("Enter the input:");
 scanf("%d",&val);
 printf("----------------------------------\n");
 switch(val){ case 1: printf("\n Enter the Val :");
 scanf("%d",&ival);
 if(create_dnode(ival,&node)){ insert_dnode(&head,&node);
} else printf("!!!@@@ System is outof Memory @@@!!!\n");
 break;
 case 2: printf("\n Delete the Val :");
 scanf("%d",&ival);
 node=find_dnode(&head,ival);
 if(node!=NULL){ delete_dnode(&head,&node);
 } else printf(" The Node Value not found \n");
 break;
 case 3: printf("\n The Doubly List is : \n");
 print_dll(&head);
 break;
 case 4: print_dll_reverse(&head);
 break;
 case 5: printf("\n Enter the Val to Find:");
 scanf("%d",&ival);
 node=find_dnode(&head,ival);
 if(node==NULL) printf("\t *** Value Not Found !! ***\n");
 else printf("\t ** Value Found ***\n");
 break;
 case 6: break;
 default: printf("===> [ Enter the Correct input] <==== \n");
 break;
 } }while(val!=6);
 printf(" \n[Thank you!! for using codingstreet.com 's Data Structure Solutions !!] \n\n");
 return 0;
 }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

/* C Code for Doubly linked list by Codingstreet.com */

#include<stdio.h>

#include<stdlib.h>

struct dnode{ int val;

struct dnode *next,*prev;

};

int create_dnode(int val,struct dnode **node){ struct dnode *tmp;

tmp=malloc(sizeof(struct dnode));

if(tmp==NULL) return 0;

tmp->val=val;

tmp->next=NULL;

tmp->prev=NULL;

*node=tmp;

return 1;

}

int insert_dnode(struct dnode **head,struct dnode **node ){ if((*head)==NULL){ (*head)=(*node);

(*head)->next=NULL;

(*head)->prev=NULL;

} else { struct dnode *root;

root=(*head);

struct dnode *next,*prev,*tmp;

next=root->next;

prev=tmp=root;

while(next!=NULL){ prev=tmp;

tmp=tmp->next;

next=tmp;

} prev->next=(*node);

(*node)->prev=prev;

next=prev->next;

next->next=NULL;

} return 1;

} void print_dll(struct dnode **head){ struct dnode *tmp;

tmp=(*head);

while(tmp!=NULL){ printf(" %d ",tmp->val);

tmp=tmp->next;

} printf("\n");

} void print_dll_reverse(struct dnode **head){ struct dnode *tmp;

tmp=(*head);

if(tmp==NULL) return;

while(tmp->next!=NULL){ tmp=tmp->next;

} while(tmp!=NULL){ printf(" %d ",tmp->val);

tmp=tmp->prev;

} printf("\n");

} int delete_dnode(struct dnode **head,struct dnode **node){ struct dnode *root,*tmp,*next,*prev,*dlnode;

root=*head;

dlnode=*node;

if(root==NULL){ return 0;

} else if(root==dlnode && root->next==NULL){ free(root);

*head=NULL;

} else if(root==dlnode){ next=root->next;

root->next=NULL;

next->prev=NULL;

free(root);

root=next;

*head=root;

return 1;

} else { tmp=*head;

next=tmp->next;

prev=tmp;

while(tmp!=NULL){ if(tmp==dlnode){ prev->next=tmp->next;

tmp->next=prev;

tmp->next=NULL;

tmp->prev=NULL;

free(tmp);

return 1;

} prev=tmp;

tmp=tmp->next;

} return 0;

} } struct dnode *find_dnode(struct dnode **head,int val){ struct dnode *root;

root=*head;

if(root==NULL){ return NULL;

} else if(root->val==val){ return root;

} else { struct dnode *tmp;

tmp=root;

while(tmp!=NULL){ if(tmp->val==val){ return tmp;

} tmp=tmp->next;

} return tmp;

} } int main(){ struct dnode *head=NULL,*node=NULL;

int val,ival;

do { printf("\n----------------------------------");

printf("\n Doubly Linked List Menu : \n");

printf("[1] Insert Node: \n");

printf("[2] Delete Node: \n");

printf("[3] Print List: \n");

printf("[4] Print List Reverse : \n");

printf("[5] Find Node :\n");

printf("[6] Exit: \n");

printf("Enter the input:");

scanf("%d",&val);

printf("----------------------------------\n");

switch(val){ case 1: printf("\n Enter the Val :");

scanf("%d",&ival);

if(create_dnode(ival,&node)){ insert_dnode(&head,&node);

} else printf("!!!@@@ System is outof Memory @@@!!!\n");

break;

case 2: printf("\n Delete the Val :");

scanf("%d",&ival);

node=find_dnode(&head,ival);

if(node!=NULL){ delete_dnode(&head,&node);

} else printf(" The Node Value not found \n");

break;

case 3: printf("\n The Doubly List is : \n");

print_dll(&head);

break;

case 4: print_dll_reverse(&head);

break;

case 5: printf("\n Enter the Val to Find:");

scanf("%d",&ival);

node=find_dnode(&head,ival);

if(node==NULL) printf("\t *** Value Not Found !! ***\n");

else printf("\t ** Value Found ***\n");

break;

case 6: break;

default: printf("===> [ Enter the Correct input] <==== \n");

break;

} }while(val!=6);

printf(" \n[Thank you!! for using codingstreet.com 's Data Structure Solutions !!] \n\n");

return 0;

}

Linked List

Singly Linked List in C

June 17, 2013 admin

Data Structure Problems :

Singly Linked List :

Singly linked list has following features .

It contains int data value and next pointer which points to same kind of linked list node.

It is an extensive use of Dynamic Memory Allocation & structure.

Structure defined in following way :

struct snode{

int val;

struct snode *next;

};

Declaring a snode variable

struct snode node;

node has following variable to access

val and ptr

A C program on singly linked list.

functions used :

int create_snode(int val,struct snode **node); // To create node

int insert_snode(struct snode **head,struct snode **node );// To insert node

struct snode *find_snode(struct snode **head,int val); // To find node

int delete_snode(struct snode **head,struct snode **node); // To delete node from list

void print_sll(struct snode **head); // To print list

void reverse_sll(struct snode **head); // To reverse list

struct snode* findnthnode(struct snode **head,int lpo);// To find nth node from last in list

Code :

/* Singly Linked List Code by Codingstreet.com */

/* Following Features are provided */

Singly Linked List Menu :

[1] Insert Node:

[2] Delete Node:

[3] Print Node:

[4] Reverse List:

[5] Find Nth node from Last :

[6] Exit:

/* Singly Linked List code by Codingstreet.com */ 
#include<stdio.h> 
#include<stdlib.h> 
	struct snode{     int val;
     struct snode *next;
 };
 int create_snode(int val,struct snode **node){     struct snode *tmp;
     tmp=malloc(sizeof(struct snode));
     if(tmp==NULL) return 0;
     tmp->val=val;
     tmp->next=NULL;
     *node=tmp;
 return 1;
 } 
int insert_snode(struct snode **head,struct snode **node ){     
if((*head)==NULL){         (*head)=(*node);
         (*head)->next=NULL;
     }     else {         struct snode *root;
         root=(*head);
         struct snode *next,*prev,*tmp;
         next=root->next;
         prev=tmp=root;
         while(next!=NULL){         prev=tmp;
         tmp=tmp->next;
         next=tmp;
}         prev->next=(*node);
         next=prev->next;
         next->next=NULL;
     } return 1;
 } 
struct snode *find_snode(struct snode **head,int val){     struct snode *root;
     root=*head;
     if(root==NULL){         return NULL;
     }     else if(root->val==val){         return root;
}     else {         struct snode *tmp;
         tmp=root;
         while(tmp!=NULL){         if(tmp->val==val){             return tmp;
                 }         tmp=tmp->next;
}         return tmp;
                 } } 
int delete_snode(struct snode **head,struct snode **node){     struct snode *root,*tmp,*next,*prev,*dlnode;
     root=*head;
     dlnode=*node;
     if(root==NULL){             return 0;
     }     else if(root==dlnode){             next=root->next;
             root->next=NULL;
                         free(root);
             root=next;
             *head=root;
             return 1;
     }     else {         tmp=*head;
         next=tmp->next;
         prev=tmp;
         while(tmp!=NULL){         if(tmp==dlnode){             prev->next=tmp->next;
             tmp->next=NULL;
             free(tmp);
             return 1;
                     }             prev=tmp;
             tmp=tmp->next;
         }         return 0;
         } }             
void print_sll(struct snode **head){     struct snode *tmp;
     tmp=(*head);
     while(tmp!=NULL){         printf(" %d ",tmp->val);
         tmp=tmp->next;
         } }                
 void reverse_sll(struct snode **head){     if((*head)==NULL) return;
     if((*head)->next==NULL) return;
     struct snode *next,*prev,*curnt;
     curnt=(*head)->next;
     prev=*head;
     prev->next=NULL;
     next=curnt->next;
     while(next!=NULL){     curnt->next=prev;
     prev=curnt;
     curnt=next;
     next=next->next;
     }     curnt->next=prev;
     (*head)=curnt;
 } 
struct snode* findnthnode(struct snode **head,int lpo){     struct snode *tmp=(*head),*ptmp;
     ptmp=(*head);
     int i=0;
     while(tmp!=NULL){     i++;
         tmp=tmp->next;
     if(i>lpo)             ptmp=ptmp->next;
     }     if(lpo>i) return NULL;
     return ptmp;
 } 
int main(){ struct snode *head=NULL,*node=NULL;
 int val,ival;
 do { printf("\n Singly Linked List Menu : \n");
 printf("[1] Insert Node: \n");
 printf("[2] Delete Node: \n");
 printf("[3] Print Node: \n");
 printf("[4] Reverse List:\n");
 printf("[5] Find Nth node from Last : \n");
 printf("[6] Exit: \n");
 printf("Enter the input:");
 scanf("%d",&val);
 switch(val){ case 1:     printf("\n Enter the Val :");
     scanf("%d",&ival);
     if(create_snode(ival,&node)){         insert_snode(&head,&node);
}     else printf("!!!@@@ System is outof Memory @@@!!!\n");
 break;
 case 2:     printf("\n Delete the Val :");
     scanf("%d",&ival);
     node=find_snode(&head,ival);
     if(node!=NULL){         delete_snode(&head,&node);
     }     else printf(" The Node Value not found \n");
 break;
 case 3:     printf("\n The Singly List is : \n");
     print_sll(&head);
 break;
 case 4:     reverse_sll(&head);
 break;
 case 5:     node=NULL;
     printf("\n Enter the position fro last : ");
     scanf("%d",&ival);
     node=findnthnode(&head,ival);
     if(node==NULL) printf("\n Wrong Input position ");
     else printf("\n %d ",node->val);
 break;
 case 6: break;
 default:     printf("===> [ Enter the Correct input] <==== \n");
 break;
 } }while(val!=6);
 printf(" \n[Thank you!! for using codingstreet.com 's Data Structure Solutions !!] \n\n");
 return 0;
 }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

/* Singly Linked List code by Codingstreet.com */

#include<stdio.h>

#include<stdlib.h>

struct snode{ int val;

struct snode *next;

};

int create_snode(int val,struct snode **node){ struct snode *tmp;

tmp=malloc(sizeof(struct snode));

if(tmp==NULL) return 0;

tmp->val=val;

tmp->next=NULL;

*node=tmp;

return 1;

}

int insert_snode(struct snode **head,struct snode **node ){

if((*head)==NULL){ (*head)=(*node);

(*head)->next=NULL;

} else { struct snode *root;

root=(*head);

struct snode *next,*prev,*tmp;

next=root->next;

prev=tmp=root;

while(next!=NULL){ prev=tmp;

tmp=tmp->next;

next=tmp;

} prev->next=(*node);

next=prev->next;

next->next=NULL;

} return 1;

}

struct snode *find_snode(struct snode **head,int val){ struct snode *root;

root=*head;

if(root==NULL){ return NULL;

} else if(root->val==val){ return root;

} else { struct snode *tmp;

tmp=root;

while(tmp!=NULL){ if(tmp->val==val){ return tmp;

} tmp=tmp->next;

} return tmp;

} }

int delete_snode(struct snode **head,struct snode **node){ struct snode *root,*tmp,*next,*prev,*dlnode;

root=*head;

dlnode=*node;

if(root==NULL){ return 0;

} else if(root==dlnode){ next=root->next;

root->next=NULL;

free(root);

root=next;

*head=root;

return 1;

} else { tmp=*head;

next=tmp->next;

prev=tmp;

while(tmp!=NULL){ if(tmp==dlnode){ prev->next=tmp->next;

tmp->next=NULL;

free(tmp);

return 1;

} prev=tmp;

tmp=tmp->next;

} return 0;

} }

void print_sll(struct snode **head){ struct snode *tmp;

tmp=(*head);

while(tmp!=NULL){ printf(" %d ",tmp->val);

tmp=tmp->next;

} }

void reverse_sll(struct snode **head){ if((*head)==NULL) return;

if((*head)->next==NULL) return;

struct snode *next,*prev,*curnt;

curnt=(*head)->next;

prev=*head;

prev->next=NULL;

next=curnt->next;

while(next!=NULL){ curnt->next=prev;

prev=curnt;

curnt=next;

next=next->next;

} curnt->next=prev;

(*head)=curnt;

}

struct snode* findnthnode(struct snode **head,int lpo){ struct snode *tmp=(*head),*ptmp;

ptmp=(*head);

int i=0;

while(tmp!=NULL){ i++;

tmp=tmp->next;

if(i>lpo) ptmp=ptmp->next;

} if(lpo>i) return NULL;

return ptmp;

}

int main(){ struct snode *head=NULL,*node=NULL;

int val,ival;

do { printf("\n Singly Linked List Menu : \n");

printf("[1] Insert Node: \n");

printf("[2] Delete Node: \n");

printf("[3] Print Node: \n");

printf("[4] Reverse List:\n");

printf("[5] Find Nth node from Last : \n");

printf("[6] Exit: \n");

printf("Enter the input:");

scanf("%d",&val);

switch(val){ case 1: printf("\n Enter the Val :");

scanf("%d",&ival);

if(create_snode(ival,&node)){ insert_snode(&head,&node);

} else printf("!!!@@@ System is outof Memory @@@!!!\n");

break;

case 2: printf("\n Delete the Val :");

scanf("%d",&ival);

node=find_snode(&head,ival);

if(node!=NULL){ delete_snode(&head,&node);

} else printf(" The Node Value not found \n");

break;

case 3: printf("\n The Singly List is : \n");

print_sll(&head);

break;

case 4: reverse_sll(&head);

break;

case 5: node=NULL;

printf("\n Enter the position fro last : ");

scanf("%d",&ival);

node=findnthnode(&head,ival);

if(node==NULL) printf("\n Wrong Input position ");

else printf("\n %d ",node->val);

break;

case 6: break;

default: printf("===> [ Enter the Correct input] <==== \n");

break;

} }while(val!=6);

printf(" \n[Thank you!! for using codingstreet.com 's Data Structure Solutions !!] \n\n");

return 0;

}

A place to brush your coding skills