recursive reverse(ptr)
  if(ptr->next==NULL)
  return ptr;
  temp=reverse(ptr->next);
  ptr=ptr->next;
  return ptr;
  end

node *reverse(node *first)


{
node *cur,*temp;


cur=NULL;

while(first!=NULL)


{temp=first;

first=first->link;

temp->link=cur;

cur=temp;
}

return cur;

}

/*
the structure is as follows:
struct node
{
   int data;
   struct node *next;
}
*/

struct node * reverse (struct node *home , struct node *rev)
{  
  struct node temp , *p;

  if(home != NULL)
  {
    temp = home;
    while(temp != NULL)
    {
       //this part will create a new node with the name p.
       p = myalloc;
       p -> data = temp -> data;
       p -> next = NULL;
          
       if(rev == NULL)
          rev = p;
       else
       {
              p -> next = rev;
              rev = p;
       }
       temp = temp -> next;
      }
   }
return rev;
}

**Liked list as a stack = linked list in reverse order.

/*
the structure is as follows:
struct node
{
   int data;
   struct node *next;
}
*/

struct node * reverse (struct node *home , struct node *rev)
{  
  struct node temp , *p;

  if(home != NULL)
  {
    temp = home;
    while(temp != NULL)
    {
       //this part will create a new node with the name p.
       p = myalloc;
       p -> data = temp -> data;
       p -> next = NULL;
          
       if(rev == NULL)
          rev = p;
       else
       {
              p -> next = rev;
              rev = p;
       }
       temp = temp -> next;
      }
   }
return rev;
}

write a link list program to insert integer number and then 
display its sum as well. Your program should display the 
address as well as the result
write a program to reverse a link list so that the last 
element becomes the first one and so on
copy one link list to another list

//Go through the code, incase any issues feel free to 
revert.

Copying a link list:

//home is the stationary pointer of the main linked list 
which is to be copied.

//head is the stationary pointer of the new linked list 
which has to be created..

//temp and temp1 are the moving pointers attached to the 
respective linked list...


struct node *copy(struct node *home , struct node *head)
{
  struct node *temp , *temp1 , *p;
  
  temp = home;
  while(temp != NULL)
  {
       p = (struct node *) malloc (sizeof(struct node));
       p -> data = temp -> data;
      
       if(head == NULL)
             head = p;
        
        else
        {
             temp1 = head;
             while(temp1 -> next != NULL)
                   temp1 = temp1 -> next;
               
              temp1 -> next = p;
         }
    temp = temp -> next;
}
return head;
}

#include <stdio.h>

typedef struct list
{
 int data;
 struct list * next;
} LIST;

LIST* reverse(LIST *head)
{
  LIST* temp;
  LIST* temp1;

  if (head == NULL || head->next == NULL)
    return head;
  else
  {
    temp = head->next;
    head->next = NULL;
    while(temp)
    {
      temp1 = temp->next;
      temp->next = head;
      head = temp;
      temp = temp1;
    }

    return head;
  }
}

int main(int argc, char ** argv)
{
 int i=0;
 LIST* head = NULL;
 LIST* node = NULL;
 int count;

 if (argc < 2) printf("usage: a.out <count>");
 else count = atoi(argv[1]);

 for (i=0;i<count;i++)
 {
   node = (LIST*)calloc(sizeof(LIST));
   node->data = i;
   node->next = head;

   head = node;
 }

 node = head;
 while(node)
 {
   printf("before %d\n", node->data);
   node = node->next;
 }

 head = reverse(head);
 printf("after head=%d\n", head->data);
 node = head;
 while(node)
 {
   printf("after %d\n", node->data);
   node = node->next;
 }
}