可复用单链表的实现

/******************LinkList.h**********************/ 
#ifndef LINKLIST_H_
#define LINKLIST_H_
typedef void LinkList;
//定义结点指针域 
typedef struct _tag_LinkListNode  LinkListNode ;
struct _tag_LinkListNode
{
    LinkListNode* next;    //指针域内含有指向自身的指针，故需先声明 
};
//定义头结点
typedef struct  _tag_LinkList
{
    LinkListNode header;
    int length;
}TLinkList;

//创建空链表 
LinkList* LinkList_Create();
//销毁链表 
void LinkList_Destroy(LinkList* list);
//清空链表 
void LinkList_Clear(LinkList* list);
//向链表的第pos个元素处插入node元素 注：POS=为第一个元素 
int LinkList_Insert(LinkList* list, LinkListNode* node,int pos);
//删除链表第pos个元素 
LinkListNode* LinkListDelete(LinkList* list, int pos);
//获取链表第pos个元素 
LinkListNode* LinkList_Get(LinkList* list, int pos);
//获取链表的元素 
int LinkList_Length(LinkList* list);
//反转单链表 
int LinkList_Reverse(LinkList* list);
#endif

/******************LinkList.c**********************/ 
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"

LinkList* LinkList_Create()
{
    TLinkList *ret = (TLinkList*)malloc(sizeof(TLinkList));
    if(ret != NULL)
    {
        ret->header.next = NULL;
        ret->length = 0;
    }
    return ret;
}
void LinkList_Destroy(LinkList* list)
{
    free(list);
}
void LinkList_Clear(LinkList* list)
{
    TLinkList *slist = (TLinkList*)list;
    if(slist!=NULL)
    {
        slist->length=0;
        slist->header.next = NULL;
    }
}

int LinkList_Insert(LinkList* list, LinkListNode* node,int pos)
{
    TLinkList* slist = (TLinkList *)list;
    int ret = (slist!=NULL)&&(pos>=0)&&(node!=NULL);
    int i=0;
    
    if(ret)
    {
        LinkListNode* current = (LinkListNode*)slist;
        
        for(i=0;(i<pos)&&(current->next!=NULL);i++)
        {
            current = current->next;
        }
        
        node->next = current->next;
        current->next = node;
        slist->length++;
    } 
    return ret;
}

LinkListNode* LinkListDelete(LinkList* list, int pos)    //pos=0为第一个元素 
{
    TLinkList* slist = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i=0;
    if((slist!=NULL) && (pos>=0) &&(pos<slist->length))
    {
        LinkListNode* current = (LinkListNode*)slist;
        for(i=0;i<pos;i++)
        {
            current=current->next;
        }
        ret = current->next;
        current->next = ret->next;
        slist->length--;
    }          
    return ret;
}

LinkListNode* LinkList_Get(LinkList* list, int pos)
{
    TLinkList* slist = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i=0;
    if((slist!=NULL) && (pos>=0) &&(pos<slist->length))
    {
        LinkListNode* current = (LinkListNode*)slist;
        for(i=0;i<pos;i++)
        {
            current=current->next;
        }
        ret = current->next;
    }          
    return ret;
}

int LinkList_Length(LinkList* list)
{
    TLinkList* slist = (TLinkList*)list;
    int ret=-1;
    if(slist!=NULL)
    {
        ret = slist->length;
    }
    return ret;
}
int LinkList_Reverse(LinkList* list)
{
    TLinkList* slist = (TLinkList*)list;
    LinkListNode* prev = NULL;
    LinkListNode* tmp = NULL;
    int ret = (slist!=NULL);
    if(ret)
    {
        LinkListNode* head = slist->header.next;  //第一个元素指针域 
        while(head!=NULL)
        {
            tmp = head;
            head = head->next;
            tmp->next = prev;
            prev = tmp; 
        }
        slist->header.next =  tmp; 
    }
    return ret;
}

/*
  Name:    链表的实现 
  Author:  LXB 
  Date: 16/05/14 16:40
  Description:     包括链表创立、删除、添加、销毁、反转等基本操作  
*/
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"
//定义数据元素(指针域及数据域) 
struct Value
{
    LinkListNode header;
    int v;
};

int main(int argc, char *argv[])
{
  int i=0;
  LinkList* list = LinkList_Create(); 
  
  struct Value v1;
  struct Value v2;
  struct Value v3;
  struct Value v4;
  struct Value v5;
  struct Value v6;
  
  v1.v=1;
  v2.v=2;
  v3.v=3;
  v4.v=4;
  v5.v=5;
  v6.v=6;
  
  LinkList_Insert(list,(LinkListNode*)&v1,LinkList_Length(list));
  LinkList_Insert(list,(LinkListNode*)&v2,LinkList_Length(list));
  LinkList_Insert(list,(LinkListNode*)&v3,LinkList_Length(list));
  LinkList_Insert(list,(LinkListNode*)&v4,LinkList_Length(list));
  LinkList_Insert(list,(LinkListNode*)&v5,LinkList_Length(list));
  LinkList_Insert(list,(LinkListNode*)&v6,LinkList_Length(list));
  
  for(i=0;i<LinkList_Length(list);i++)                 /*正常输出链表*/
  {
      struct Value* pv = (struct Value*)LinkList_Get(list,i);
      printf("%d\n",pv->v);
  }

  while(LinkList_Length(list)>0)                       /*倒序输出*/
  {
      struct Value* pv = (struct Value*)LinkListDelete(list,LinkList_Length(list)-1);
      printf("%d\n",pv->v);
  }
  LinkList_Reverse(list);                       
  for(i=0;i<LinkList_Length(list);i++)
  {
      struct Value* pv = (struct Value*)LinkList_Get(list,i);
      printf("%d\n",pv->v);
  }
  LinkList_Destroy(list);
  system("PAUSE");	
  return 0;
}