chandan

• Jul 18th, 2006

 

Code
************************** 


typedef struct nd {


    int info;


    struct nd *link;


} node;


/* AFTER CREATING LINK LIST */


node *reverse(node * h)


{


    node *H = NULL, *p;


    while (h != NULL) {


        p = h;                  /* insert value of 1st node  into p */


        h = h->next;


        p->next = H;            /* insert p->next =NULL ,because H is equals to NULL (1st time) */


        H = p;                  /* insert address of p into H */


    }


    return H;


}


 

pranjal5215

 Profile Answers by pranjal5215 

• Aug 3rd, 2008

 

This is a complete program to reverse a linked list in C.
first node is allocated memory but doesn't contain any data.

Code
#include<stdio.h>


#include<stdlib.h>


struct list {


    int month;


    struct list *next;


};


typedef struct list node;


 


void init(node * record)


{


    record->next = NULL;


}


 


void addnode(node * record, int d)


{


    node *fresh;


    fresh = (node *) malloc(sizeof(node));


    fresh->month = d;


    fresh->next = record->next;


    record->next = fresh;


}


 


void print(node * record)


{


    node *temp;


    temp = (node *) malloc(sizeof(node));


    for (temp = record->next; temp; temp = temp->next)


        printf(" %d", temp->month);


}


 


void reverse(node * record)


{


    node *temp;


    node *temp1;


    node *temp2;


    temp = (node *) malloc(sizeof(node));


    temp1 = (node *) malloc(sizeof(node));


    temp2 = (node *) malloc(sizeof(node));


    temp = record;


    temp1 = temp->next;


    temp2 = temp1->next;


    temp->next->next = NULL;


    while (temp2 != NULL) {


        temp = temp1;


        temp1 = temp2;


        temp2 = temp1->next;


        temp1->next = temp;


    }


    record->next = temp1;


}


 


int main(void)


{


    node *start;


    node *start1;


    start = (node *) malloc(sizeof(node));


    init(start);


    int i = 0;


    for (i = 10; i >= 0; i--)


        addnode(start, i);


    print(start);


    reverse(start);


    printf("n");


    print(start);


    return 0;


}


 

pranjal5215

 Profile Answers by pranjal5215 

• Jul 10th, 2009

 

This is the recursive version of the program.

Code
#include<stdio.h>


#include<stdlib.h>


struct list {


    int month;


    struct list *next;


};


typedef struct list node;


void init(node * record)


{


    record->next = NULL;


}


 


void addnode(node * record, int d)


{


    node *fresh;


    fresh = (node *) malloc(sizeof(node));


    fresh->month = d;


    fresh->next = record->next;


    record->next = fresh;


}


 


void print(node * record)


{


    node *temp;


    temp = (node *) malloc(sizeof(node));


    for (temp = record->next; temp; temp = temp->next)


        printf(" %d", temp->month);


}


 


node *reverse_recurse(node * cur, node * start)


{                               /*reverse linked list recursively */


    if (cur->next == NULL) {


        start->next = cur;


        return cur;


    } else {


        reverse_recurse(cur->next, start)->next = cur;


    }


    return cur;


}


 


int main(void)


{


    node *start;


    start = (node *) malloc(sizeof(node));


    init(start);


    int i = 0;


    for (i = 20; i >= 0; i--)


        addnode(start, i);


    print(start);


    reverse_recurse(start->next, start)->next = NULL;


    print(start);


    printf("n");


    return 0;


}


 

cleonjoys

 Profile Answers by cleonjoys 

• Oct 21st, 2010

 

This is dummy program I have written concentrating mainly on reversing the List rather than implementing efficient way in adding to list and displaying it :)

I have written Algo for the reverse also please check it for easier understanding.

Code
#include <stdio.h>


#include <stdlib.h>


 


typedef struct Node {


    int info;


    struct Node *next;


} Node_t;


 


Node_t *headp = NULL;


 


/* Design flow


.


1    rev(2) -> store NULL


    2    rev(3) -> store 1


        3    NULL -> store 2


            ..continues after the recursive calls, so here it needs to store the previous


            value


   


call is


    reverse(start, NULL)


 


1->2->3


call reverse(1, NULL)


        nptr = 1


        prevPtr = NULL


        1->next != NULL


            call reverse(2, 1)


            nptr = 2


            prevPtr = 1


            2->next != NULL


                call reverse(3, 2)


                nptr = 3


                prevPtr = 2


                3->next == NULL; so return from here


   


                3->next = 2


            2->next = 1


        1->next = NULL


*/


 


/* Its O(n-1) in space complexity */


void reverse(Node_t * nPtr, Node_t * prevPtr)


{


 


    if (nPtr->next != NULL) {


        reverse(nPtr->next, nPtr);


    } else {


        headp = nPtr;


    }


    nPtr->next = prevPtr;


}


 


void create(int info)


{


 


    Node_t *tPtr = NULL;


    Node_t *newPtr = NULL;


 


    tPtr = headp;


 


    if ((newPtr = (Node_t *) malloc(sizeof(Node_t))) == NULL) {


        printf("System OOOn");


        exit(-1);


    }


    newPtr->info = info;


    newPtr->next = NULL;


 


    if (headp == NULL) {


        headp = newPtr;


        return;


    }


    if (tPtr != NULL) {


        while (tPtr->next != NULL)


            tPtr = tPtr->next;


 


        tPtr->next = newPtr;


    }


}


 


void display()


{


    Node_t *tmpPtr = headp;


 


    while (tmpPtr->next != NULL) {


        printf("%d ", tmpPtr->info);


        tmpPtr = tmpPtr->next;


    }


    printf("%dn", tmpPtr->info);


}


 


int main()


{


    printf("Starting creation of the List!!n");


    create(1);


    create(2);


    create(3);


    create(4);


    create(5);


    create(6);


    create(7);


 


    printf("Contents of the list as follows:-n");


    display();


 


    reverse(headp, NULL);


    printf("After reverse the list has: n");


    display();


 


    return 0;


 


}


 

ss0101782

 Profile Answers by ss0101782 

• Dec 31st, 2010

 

Code
#include"stdio.h"


#include"stdlib.h"


#include"conio.h"


#include"string.h"


#include"alloc.h"


struct stud {


    int roll, mtot;


    char name[25];


    struct stud *next;


} *head, *tail;


void creat();


void display();


void addbeg();


void addend();


void addany();


void delet();


void rev();


void main()


{


    clrscr();


    creat();


    display();


    printf("n ********** Add node at begining of the list **********");


    addbeg();


    display();


    printf("n ********** Add node at end of the list **********");


    addend();


    display();


    printf("n ********** Add node at any position of the list **********");


    addany();


    display();


    printf("n ********** Deletion of node from the list **********");


    delet();


    display();


    getch();


    printf("n ********** Revers the list **********");


    rev();


    display();


    getch();


}


 


void creat()


{


    int i, n, k = 0, rl, mt;


    char nm[25];


    struct stud *p;


 


    printf("n Enter the number of nodes::");


    scanf("%d", &n);


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


        printf("n the node number::%d", i + 1);


        printf("n Enter student roll number::");


        scanf("%d", &rl);


        fflush(stdin);


        printf("n Enter student name::");


        gets(nm);


        printf("n Enter student total marks::");


        scanf("%d", &mt);


        fflush(stdin);


        p = (struct stud *) malloc(sizeof(struct stud));


        if (k == 0) {


            head = p;


            head->roll = rl;


            strcpy(head->name, nm);


            head->mtot = mt;


            head->next = NULL;


            k = 1;


            tail = head;


        } else {


            head->next = p;


            head = head->next;


            head->roll = rl;


            strcpy(head->name, nm);


            head->mtot = mt;


            head->next = NULL;


        }


    }


}


 


void display()


{


    struct stud *p1;


    p1 = tail;


    while (p1 != NULL) {


        printf("n student roll number::%4d", p1->roll);


        printf("n student name ::%s", p1->name);


        printf("n student total marks::%4d", p1->mtot);


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


        p1 = p1->next;


    }


}


 


void addbeg()


{


    char nm[25];


    struct stud *p;


    int mt, rl;


    printf("n Enter student roll number::");


    scanf("%d", &rl);


    fflush(stdin);


    printf("n Enter student name::");


    gets(nm);


    printf("n Enter student total marks::");


    scanf("%d", &mt);


    fflush(stdin);


    p = (struct stud *) malloc(sizeof(struct stud));


    p->roll = rl;


    strcpy(p->name, nm);


    p->mtot = mt;


    p->next = tail;


    tail = p;


}


 


void addend()


{


    char nm[25];


    struct stud *p;


    int mt, rl;


    printf("n Enter student roll number::");


    scanf("%d", &rl);


    fflush(stdin);


    printf("n Enter student name::");


    gets(nm);


    printf("n Enter student total marks::");


    scanf("%d", &mt);


    fflush(stdin);


    p = (struct stud *) malloc(sizeof(struct stud));


    p->roll = rl;


    strcpy(p->name, nm);


    p->mtot = mt;


    p->next = NULL;


    head->next = p;


    head = p;


}


 


void addany()


{


    char nm[25];


    struct stud *p, *p1;


    int mt, rl, n, k = 0, c = 0;


    printf("n Enter the position where you want to add the node::");


    scanf("%d", &n);


    fflush(stdin);


    if (n <= 0) {


        printf("n wrong entry::");


        getch();


        exit(1);


    }


    p = (struct stud *) malloc(sizeof(struct stud));


    printf("n Enter student roll number::");


    scanf("%d", &rl);


    fflush(stdin);


    printf("n Enter student name::");


    gets(nm);


    printf("n Enter student total marks::");


    scanf("%d", &mt);


    fflush(stdin);


    p->roll = rl;


    strcpy(p->name, nm);


    p->mtot = mt;


    p1 = tail;


    n = n - 1;


    while (p1 != NULL) {


        c++;


        if (c == n) {


            p->next = p1->next;


            p1->next = p;


            k = 1;


            break;


        }


        p1 = p1->next;


    }


    if (k == 0)


        printf("n sorry position not found::");


}


void delet()


{


    char nm[25];


    struct stud *p, *p1;


    int mt, rl, k = 0;


    printf("n Enter student's roll number which is to be deleted::");


    scanf("%d", &rl);


    fflush(stdin);


    p1 = tail;


    // p=head1;


    while (p1 != NULL) {


        k++;


        if (p1->roll == rl) {


            if (k == 1)


                tail = p1->next;


            else


                p->next = p1->next;


            free(p1);


            break;


        }


        p = p1;


        p1 = p1->next;


    }


    if (k == 0)


        printf("n node position not found::");


}


void rev()


{


    char nm[25];


    struct stud *p, *p1, *temp = NULL;


    int mt, rl;


    p1 = tail;


    while (p1 != NULL) {


        p = (struct stud *) malloc(sizeof(struct stud));


        p->roll = p1->roll;


        strcpy(p->name, p1->name);


        p->mtot = p1->mtot;


        p->next = temp;


        temp = p;


        p1 = p1->next;


        free(tail);


        tail = p1;


    }


    tail = temp;


}


 

ankit srivastava

• Oct 17th, 2011

 

public void ReverseLinkedList (LinkedList linkedList)
{
// ------------------------------------------------------------
// Create a new linked list and add all items of given
// linked list to the copy linked list in reverse order
// ------------------------------------------------------------

LinkedList copyList = new LinkedList();

// ------------------------------------------------------------
// Start from the latest node
// ------------------------------------------------------------

LinkedListNode start = linkedList.Tail;

// ------------------------------------------------------------
// Traverse until the first node is found
// ------------------------------------------------------------

while (start != null)
{
// ------------------------------------------------------------
// Add item to the new link list
// ------------------------------------------------------------

copyList.Add (start.Item);

start = start.Previous;
}

linkedList = copyList;

// ------------------------------------------------------------
// That's it!
// ------------------------------------------------------------
}

samCPP

 Profile Answers by samCPP 

• Dec 4th, 2011

 

Reversing a Linked list using temporary pointer

Code
#include<iostream.h>


#include<conio.h>


using namespace std;


template < class T > struct node {


    int element;


     node < T > *next;


     node() {


    } node(const T element) {


        this->element = element;


        this->next = NULL;


    }


    node(const T element, node < T > *next) {


        this->element = element;


        this->next = next;


    }


};


 


template < class T > class linkedlist {


  private:


    node < T > *top;


  public:


    linkedlist() {


        top = NULL;


    }


    ~linkedlist() {


        node < T > *newnode = top->next;


        delete[]top;


        top = newnode;


    }


    void push(const T ele) {


        top = new node < T > (ele, top);


    }


    void display() {


        node < T > *p;


        p = top;


        while (p != NULL) {


            cout << p->element << "   ";


            p = p->next;


        }


    }


    void reverse() {


        node < T > *p, *d;


        p = top;


        d = NULL;


        while (p != NULL) {


            d = new node < T > (p->element, d); //Temporary pointer for reversal


            p = p->next;


        }


        top = d;


        while (d != NULL) {


            cout << d->element << "    ";


            d = d->next;


        }


        cout << endl;


        free(d);


    }


};


 


int main()


{


    linkedlist < int >a;


    int ele, ch;


    while (1) {


        cout << "Enter choice";


        cin >> ch;


        switch (ch) {


 


        case 1:


 


            cout << "enter element ";


            cin >> ele;


            a.push(ele);


            break;


 


        case 2:


 


            cout << " List is " << endl;


            a.display();


            break;


 


        case 3:


 


            cout << " Reverse List is " << endl;


            a.reverse();


            break;


 


        case 4:


 


            return 0;


        }


    }


    getch();


    return 0;


}