Cómo implementar un código C para la eliminación de un nodo de una lista vinculada considerando todos los casos de prueba

Eliminar el primer nodo
Haga que el puntero de la cabeza apunte al siguiente nodo

Eliminar el enésimo nodo
Atraviese el nodo que debe eliminarse mientras mantiene un puntero al nodo anterior y luego haga que el nodo anterior apunte al nodo después del nodo que debe eliminarse

Eliminar el nodo final
Atraviese el final del nodo manteniendo un puntero al nodo anterior y haga que el último segundo puntero apunte a NULL

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

#include
#include
using namespace std; struct node
{
int data;
struct node *next;
}; void display(struct node *head)
{
while((head)!=0)
{
printf("%d->",(head)->data);
(head)=(head)->next;
}
printf("\n");
} void insert(struct node **head,int x)
{
struct node *newnode=new node[sizeof(struct node)];
newnode->data=x;
newnode->next=0; if(*head==0)
{
*head=newnode;
}
else
{
newnode->next=*head;
*head=newnode;
}
} void remove_head(struct node **head)
{
if(*head == 0)
printf("Empty list\n"); struct node *temp = *head;
*head = (*head) -> next;
delete temp; } void remove_end(struct node **head)
{
struct node *itr=(*head)->next;
struct node *prev=*head; while(itr->next != 0)
{
prev = itr;
itr = itr -> next;
} prev->next = 0;
delete itr;
} void remove(struct node **head, int x)
{
if(x == 1)
{
struct node *temp = *head;
*head = (*head) -> next;
delete temp;
return;
} struct node *itr = (*head)->next;
int pos=2;
struct node* prev = *head; while(pos < x && itr != 0)
{
prev=itr;
itr=itr->next;
pos++;
}
if(pos!=x)
{
printf("Invalid Index\n");
return;
}
prev->next = itr->next;
delete itr;
} int main()
{
struct node *head=0;
for(int i=0;i<5;i++)
{
insert(&head,i);
} display(head); remove_head(&head);
display(head); remove(&head,2);
display(head); remove_end(&head);
display(head);
return 0;
}

Related Content

¿Cuál es la diferencia entre recursividad e iteraciones brevemente?

¿Cómo es posible que algún algoritmo sea más rápido que cualquier otro algoritmo similar para algunos valores de la variable de entrada y más lento para otros valores?

¿Cómo debo codificar el algoritmo en Python?

¿Qué es el DP?

Cómo determinar la eficiencia de un programa de retroceso

Lea esto: dado solo un puntero a un nodo que se eliminará en una lista vinculada individualmente, ¿cómo lo elimina? – GeeksforGeeks

Akashdeep Das

More Interesting

¿Cuál es el curso / certificación mejor pagado disponible para estructuras de datos y algoritmo?

¿Por qué el algoritmo transversal de Morris tiene una complejidad de tiempo O (n)?

¿Cuáles son las ventajas de las pilas en la estructura de datos?

Si creció en una familia alcohólica, ¿cuál fue su historia y los desafíos que enfrenta personal y profesionalmente debido a la educación?

¿Qué es el algoritmo em, cómo se hace paso a paso?

Si la compresión sin pérdida es completamente reversible, ¿por qué no omitimos un paso y solo usamos los archivos en su estado comprimido?

Tengo la cadena de entrada, también tengo la cadena encriptada. ¿Cómo averiguo qué algoritmo de cifrado se utilizó?

Cómo contar inversiones divididas con el algoritmo de clasificación de fusión

¿Hay disponible una implementación de Python del algoritmo de descomposición LDL ('ldl' en Matlab)?

¿Cuál es la complejidad temporal del algoritmo babilónico para encontrar la raíz cuadrada?

¿La comprensión humana sigue un algoritmo de compresión de datos?

¿Las personas aprenden algoritmos antes de aprender JavaScript?

¿Existe algún enlace de los algoritmos o técnicas más utilizados en la programación competitiva?

¿Qué estructuras de datos y algoritmos deben conocer todos los estudiantes de ciencias de la computación / ingeniería?

¿Cuál es una manera simple de implementar la paginación en una matriz en Javascript?