C语言实现链表逆序

        写在前面的是，对于C语言链表逆序的看法：第一感觉是，我擦，这玩意什么时候能用到啊。。。。。。。残念。。。不过在面试中是会经常用到的，如果有需要的小伙伴，可以看看我总结到的一些心得体会吧。

        嗯，在做链表逆序的时候先做一个简单的链表出来：

#include #include

typedef int Item;//定义数据项类型 typedef struct node * PNode;//定义节点指针 //节点的定义 typedef struct node {  Item item;//数据域  PNode next;//链域   }Node,* SList;

/* int SL_Creat(SList *p_list,int size) 参数 p_list：指向一个链表指针，此处传入表头地址 size：要创建的链表分配的数据元素空间个数，不包含头节点 返回值 若成功返回1，否则返回0。 功能 该函数的功能是创建一个大小为size的链表并把链表的头指针赋给p_lsit所指的链表指针。

*/ int SL_Creat(SList *p_list,int size) {  PNode p=NULL;  int i;

 *p_list = (SList)malloc(sizeof(Node));  if(*p_list==NULL)   return -1;  (*p_list)->next = NULL;  for(i=size;i>0;i--)  {   p = (PNode)malloc(sizeof(Node));   if(p==NULL)    return -1;   p->item = 0;   p->next = (*p_list)->next;   (*p_list)->next = p;  }  return 1; } /* int SL_Insert(SList list,int pos,Item item) 参数 list：要插入数据的单链表 int：指定要插入元素的位置，从1开始计数 item:要插入的数据项 返回值 若成功返回1，否则返回-1。 功能 该函数的功能是在链表list的pos位置插入新元素，其值为item。

*/ int SL_Insert(SList list,int pos,Item item) {  PNode p,q;  int i;

 p = list;  i = 0;  while(p!=NULL && inext;   i++;//i记录p指向的是第几个位置  }  if(p==NULL || i > pos-1)   return -1;  q = (Node *)malloc(sizeof(Node));//未插入节点分配内存  if(q!=NULL)//若内存分配成功，将节点插入指定位置  {   q->item = item;   q->next = p->next;   p->next = q;   return 1;  }  else  {   return -1;  } } /* int SL_GetItem(SList list,int pos,Item *p_item) 参数 list：要获取数据项所在的单链表 int：指定要获取元素在单链表中的位置 p_item:指向要接收数据项的变量 返回值 若成功返回1，否则返回-1。 功能 该函数的功能是获取在链表list的pos位置的元素的数据项，其值赋给p_item所指的变量。

*/ int SL_GetItem(SList list,int pos,Item *p_item) {  PNode p;  int i; 

 p = list;  i = 0;  while(p!=NULL && inext;   i++;//i记录p指向的是第几个位置  }  if((p==NULL)||(i>pos))  {   return -1;  }  *p_item = p->item;  return 1; } /* int SL_Delete(SList list,int pos,Item * p_item) 参数 list：要删除元素所在的单链表 int：指定要删除元素在单链表中的位置 p_item:指向接收删除元素的数据项的变量 返回值 若成功返回1，否则返回-1。 功能 该函数的功能是删除在链表list的pos位置的元素，其值赋给p_item所指的变量。

*/ int SL_Delete(SList list,int pos,Item * p_item) {  PNode p,q;  int i;  p = list;  i = 0;  while(p!=NULL && inext;   i++;//i记录p指向的是第几个位置  }  if(p->next==NULL || i > pos-1)   return -1;  q = p->next;  p->next = q->next;  if(p_item != NULL)   *p_item = q->item;  free(q);  return 1; } /* int SL_SetItem(SList list,int pos,Item item) 参数 list：要设置元素所在的单链表 int：指定要设置元素在单链表中的位置 p_item:要设置元素的数据项的值 返回值 若成功返回1，否则返回-1。 功能 该函数的功能是将链表list的pos位置的元素的数据项设置为item。

*/ int SL_SetItem(SList list,int pos,Item item) {  PNode p=NULL;  int i;  p = list;  i = 0;  while(p!=NULL && inext;   i++;//i记录p指向的是第几个位置  }  if(p==NULL || i > pos)   return -1;  p->item = item;  return 1;

} /* int SL_Find(SList list,int *pos,Item item) 参数 list：要查找元素所在的单链表 int：指向要存储的查得的元素的位置的变量 p_item:要查找元素的数据项的值 返回值 若成功返回1，否则返回-1。 功能 该函数的功能是在链表list中查找数据项为item的元素，将其位置值赋给pos所指的变量。

*/ int SL_Find(SList list,int *pos,Item item) {  PNode p;  int i;  p = list;  i = 0;  while(p!=NULL && p->item!=item)//将指针p移动到要插入元素位置之前  {   p = p->next;   i++;//i记录p指向的是第几个位置   if(p->item == item)   {    *pos = i; //返回查询到的位置    return 1;   }  }  return -1;  } /* int SL_Empty(SList list) 参数 list：要判断的单链表 返回值 若为空则返回1，否则返回 0。 功能 该函数的功能是判断链表list是否为空表。

*/ int SL_Empty(SList list) {  PNode p;  p = list;  if(p->next == NULL)   return 1;  return 0; } /* int SL_Size(SList list) 参数 list：要查找的单链表 返回值 返回包含节点的个数。 功能 该函数的功能是返回链表list中节点的个数，包含头节点。

*/ int SL_Size(SList list) {  PNode p;  int i;

 p = list;  i = 0;  while(p!=NULL)  {   p = p->next;   i++;     }  return i; } /* int SL_Clear(SList *p_list) 参数 p_list：指向要清除的单链表 返回值 成功返回值为1。 功能 该函数的功能是清除链表的所有节点，包含头节点。

*/ int SL_Clear(SList *p_list) {  PNode p,q;  int i;

 p = *p_list;  i = 0;  while(p!=NULL)  {   q = p->next;//借助于q存储p的链域，否则释放p后无法引用   free(p);   p = q;  }  *p_list = NULL;//将所指的链表指针设为NULL    return 1; }

        这个玩意就是链表了，那么主要问题来了，在做逆序的时候，首先要知道什么逆序~  这不是简单的文字游戏啊，举个例子：如果只是逆序输出的话，那么完全没有必要对链表同学进行什么惨无人道的操作，简单的做一个递归实现栈的思想就可以实现这个事情了，或者是直接做一个栈，把所有的元素放进去，然后再进行一个逆序输出。

        如果是对链表进行逆序的话，这个东西还得情况，是把指针逆序，还是把内容逆序？如果我们不说面试中遇到得问题得话，就企业中使用到得链表，一般都是节点在一个结构体中包含着，所以如果是排内容，就好像是没什么用，所以我这里还是讲一下怎么排指针吧。

        先放一个简答版本得上来：


#include 
#include 

typedef struct tagListNode{
    int data;
    struct tagListNode* next;
}ListNode, *List;

void PrintList(List head);
List ReverseList(List head);

int main()
{
    //分配链表头结点
    ListNode *head;
    head = (ListNode*)malloc(sizeof(ListNode));
    head->next = NULL;
    head->data = -1;

    //将[1,10]加入链表
    int i;
    ListNode *p, *q;
    p = head;
    for(int i = 1; i <= 10; i++)
    {
        q = (ListNode *)malloc(sizeof(ListNode));
        q->data = i;
        q->next = NULL;
        p->next = q;
        p = q;        
    }

    PrintList(head);           /*输出原始链表*/
    head = ReverseList(head);  /*逆序链表*/
    PrintList(head);           /*输出逆序后的链表*/
    return 0;
}

List ReverseList(List head)
{
    if(head->next == NULL || head->next->next == NULL)  
    {
       return head;   /*链表为空或只有一个元素则直接返回*/
    }

    ListNode *t = NULL,
             *p = head->next,
             *q = head->next->next;
    while(q != NULL)
    {        
      t = q->next;
      q->next = p;
      p = q;
      q = t;
    }

    /*此时q指向原始链表最后一个元素，也是逆转后的链表的表头元素*/
    head->next->next = NULL;  /*设置链表尾*/
    head->next = p;           /*调整链表头*/
    return head;
}

void PrintList(List head)
{
    ListNode* p = head->next;
    while(p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("/n");
}

        在这个版本中，实现逆序得方法就是使用三个辅助指针去对链表进行操作，这种方法就是速度也比较好，当然，如果这种方法不好理解得话，你也可以自己做一个栈，然后把所有得节点都放进去，pop一个连一个，这样也可以，然后其实可以用递归来实现栈得思想，可以让你得代码写得更少一点，我这里就不写了，递归还是少用比较好。。。。

        总而言之，这个东西我目前只是在面试题中见过，而且还是比较简单得面试题中见过，所以我真得不知道有什么应用场景，如果有见过的童鞋，可以留言，我研究一下子。