linked list reverse

given a list as: Header->1->2->3->4->5

reverse it, the idea should be like:

Step1:Header->2->1->3->4->5

Step2:Header->3->2->1->4->5

Step3:Header->4->3->2->1->5

Step4:Header->5->4->3->2->1

running time of such solution is obvious O(n)

coding:

need a variable to trace the node to be brought forward(tobebroughtforward);(line 5)

need reserve the node before the tobebroughtforward(position); (the variable p is it.)

we can easily see the first position value should be the first node (Header->1), the second position value should be the original second node (Header->1->2)

each iteration, connect the position and the node after tobebroughtforward,so position->next should be tobebroughtforward->next ;(line 9)

each iteration, tobebroughtforward shouldbe brought front as the first node;(line 10-11)

void reverse(pnode list)
{
    pnode p=list->next;
    pnode tobebroughtforward=NULL;
    while(p->next!=NULL)
    {
        tobebroughtforward=p->next;
        p->next=tobebroughtforward->next;
        tobebroughtforward->next=list->next;
        list->next=tobebroughtforward;
    }
}

#include <stdio.h>
#include <stdlib.h>

struct node;
typedef struct node *ptrtonode;
typedef ptrtonode pnode;
struct node
{
    int value;
    pnode next;
};
pnode create_newnode();
void append(pnode list,pnode p);
pnode find_previous(pnode list,pnode boy);
void insert_before(pnode list,pnode position,pnode newboy);
void reverse(pnode list);
void print_list(pnode list);

pnode create_newnode()
{
    pnode p=malloc(sizeof(struct node));
    p->value=0;
    p->next=NULL;
    return p;
}

void append(pnode list,pnode p)
{
    pnode c=list;
    while(c->next!=NULL)
    {
        c=c->next;
    }
    c->next=p;
}

/*
if not found the previous, then return the last one
*/
pnode find_previous(pnode list,pnode boy)
{
    pnode p=list;
    while(p->next!=NULL && p->next->value!=boy->value)
    {
        p=p->next;
    }

    return p;
}

void insert_before(pnode list,pnode position,pnode newboy)
{
    pnode previous=find_previous(list,position);
    if(previous==NULL)
    {
        printf("can not find the previous node");
        exit(-1);
    }
    previous->next=newboy;
    newboy->next=position;
}

void reverse(pnode list)
{
    pnode p=list->next;
    pnode tobebroughtforward=NULL;
    while(p->next!=NULL)
    {
        tobebroughtforward=p->next;
        p->next=tobebroughtforward->next;
        tobebroughtforward->next=list->next;
        list->next=tobebroughtforward;
    }
}

void print_list(pnode list)
{
    pnode c=list->next;
    while(c!=NULL && c->next!=NULL)
    {
        printf("%d,",c->value);
        c=c->next;
    }
    printf("%d\n",c->value);
}

int main()
{
    int i=0;
    pnode list=create_newnode();
    pnode p;
    for(i=0;i<100;i++)
    {
        p=create_newnode();
        p->value=i;
        append(list,p);
    }

    print_list(list);
    reverse(list);

    print_list(list);
    return 0;
}

at last, give a solution/codes sample from baidu,with compare i think mine is more easy to understand:

void reverse2(pnode list)
{
    pnode current=list->next;
    pnode next=NULL;
    pnode pre=NULL;
    while(current!=NULL)
    {
        next=current->next;
        current->next=pre;
        pre=current;
        current=next;
    }
    list->next=pre;
}