C数据结构 : 线性表 与 链表

一、线性表

　　一般表现为数组，使用一组地址连续的存储单元依次存储数据元素，如图：

　　它具有如下特点：

• 长度固定，必须在分配内存之前确定数组的长度。
• 存储空间连续，即允许元素的随机访问。
• 存储密度大，内存中存储的全部是数据元素。
• 要访问特定元素，可以使用索引访问，时间复杂度为 。
• 要想在顺序表中插入或删除一个元素，都涉及到之后所有元素的移动，因此时间复杂度为O(n) 。

代码示例：

seqlist.c

#include <stdio.h>
#include <malloc.h>
#include "seqlist.h"

typedef unsigned int TSeqListNode; //数据元素类型用

typedef struct _tag_SeqList
{
    int capacity; //最大长度 
    int length;   //当前长度 
    TSeqListNode* node; //指针->数组 
}TSeqList;

SeqList* SeqList_Create(int capacity) // O(1)
{
   TSeqList* ret = NULL; //真实线性表指针 
   
   if( capacity >= 0)
   {
     ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity);
   }
   
   if(ret != NULL)
   {
      ret->capacity =  capacity; 
      ret->length = 0;
      ret->node = (TSeqListNode*)(ret+1); //指向头后数据段 
   }   
  return ret; 
}

void SeqList_Destroy(SeqList* list) // O(1)
{
    free(list);
}

void SeqList_Clear(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    
    if( sList != NULL)
    {
        sList->length = 0;
    }
}

int SeqList_Length(SeqList* list) // O(1)
{
  TSeqList* sList = (TSeqList*)list;
  int ret = -1;
    
    if( sList != NULL)
    {
        ret = sList->length;
    }
    
   return ret;
}

int SeqList_Capacity(SeqList* list) // O(1)  获取最大容量 
{
   TSeqList* sList = (TSeqList*)list;
   int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->capacity;
    }  
    
   return ret;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n) 
{
    TSeqList* sList = (TSeqList*)list;
    int ret = (sList != NULL);
    int i = 0;
    
    ret = ret && (sList->length + 1 <= sList->capacity);
    ret = ret && (0 <= pos);
    
    if( ret ) 
    {
      if( pos >= sList->length ) //要插入的位置是否大于已存数据的长度 
      {
        pos = sList->length;
      }
      
       for(i = sList->length; i>pos; i--) //数据后移 
       {
         sList->node[i] = sList->node[i-1];   
       }
        sList->node[i] = (TSeqListNode)node;
        
        sList->length++;
    }
    
   return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1) 
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = NULL;
    
    if((sList != NULL) && (0 <= pos) && (pos < sList->length))
    {
        ret = (SeqListNode*)(sList->node[pos]);
    }
   return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = SeqList_Get(list,pos);
    int i = 0;
    
    if( ret != NULL)
    {
       for(i = pos+1; i<sList->length; i++)
       {
         sList->node[i-1] = sList->node[i];   //数据前移 
       }
    }
    
    sList->length--;
    
    return ret; 
}

seqlist.h

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

typedef void SeqList;      //定义void 数据封装 
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity); //创建线性表

void SeqList_Destroy(SeqList* list); //销毁线性表 
 
void SeqList_Clear(SeqList* list); //清空线性表

int SeqList_Length(SeqList* list); //读取线性表长度

int SeqList_Capacity(SeqList* list); //读取线性表最大长度

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos); //插入新元素node

SeqListNode* SeqList_Get(SeqList* list, int pos); //获取pos位置处的元素

SeqListNode* SeqList_Delete(SeqList* list, int pos);//删除pos位置处的元素

#endif

Smain.c

int main(int argc, char *argv[])
{
  SeqList* list = SeqList_Create(10);
  
  int i = 0;
  int j = 1;
  int k = 2;
  int x = 3;
  int y = 4;
  int z = 5;
  int index = 0;
  
  SeqList_Insert(list, &i, 0);
  SeqList_Insert(list, &j, 0);
  SeqList_Insert(list, &k, 0);
  SeqList_Insert(list, &x, 0);
  SeqList_Insert(list, &y, 0);
  SeqList_Insert(list, &z, 0);
  
  printf(" Length is :%d
", SeqList_Length(list));
    
  SeqList_Delete(list,5);
  
  printf("%d
", SeqList_Get(list,0));
  
  SeqList_Destroy(list);
  
    printf("Press enter to continue ...");
    getchar(); 
    return 0;
}

二、静态链表
 　　在某些语言中指针是不被支持的,只能使用数组来模拟线性链表的结构.在数组中每个元素不但保存了当前元素的值,还保存了一个”伪指针域”,一般是int类型,用于指向下一个元素的内存地址.这种链表在初始时必须分配足够的空间, 也就是空间大小是静态的, 在进行插入和删除时则不需要移动元素, 修改指针域即可,所以仍然具有链表的主要优点(快速插入和删除).

代码示例：

StaticList.c

#include <stdio.h>
#include <malloc.h>
#include "StaticList.h"

#define AVAILABLE -1

typedef struct _tag_StaticListNode
{
    unsigned int data; //数据 复用length 
    int next;          //数据元素下标，next是表示下一个节点在数组中存放的位置
} TStaticListNode;

typedef struct _tag_StaticList  //线性表结构体 
{
    int capacity;
    TStaticListNode header; //头结点 
    TStaticListNode node[]; //数据结点 
} TStaticList;

StaticList* StaticList_Create(int capacity) // O(n)
{
    TStaticList* ret = NULL;
    int i = 0;
    
    if( capacity >= 0 )
    {
        ret = (TStaticList*)malloc(sizeof(TStaticList) + sizeof(TStaticListNode) * (capacity + 1));
    }
    
    if( ret != NULL )
    {
        ret->capacity = capacity;
        ret->header.data = 0;
        ret->header.next = NULL;
        
        for(i=1; i<=capacity; i++)
        {
            ret->node[i].next = AVAILABLE;
        }
    }
    
    return ret;
}

void StaticList_Destroy(StaticList* list) // O(1)
{
    free(list);
}

void StaticList_Clear(StaticList* list) // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    int i = 0;
    
    if( sList != NULL )
    {
        sList->header.data = 0; //->长度为零 
        sList->header.next = 0; //->头结点next指针为零 
        
        for(i=1; i<=sList->capacity; i++)  //初始化为空闲状态 
        {
           sList->node[i].next = AVAILABLE;
        } 
    }
}

int StaticList_Length(StaticList* list) // O(1)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->header.data;
    }
    
    return ret;
}

int StaticList_Capacity(StaticList* list) // O(1)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->capacity;
    }
    
    return ret;
}

int StaticList_Insert(StaticList* list, StaticListNode* node, int pos)  // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = (sList != NULL);
    int current = 0;
    int index = 0;
    int i = 0;
    
    ret = ret && (sList->header.data + 1 <= sList->capacity);
    ret = ret && (pos >=0) && (node != NULL);
                             
    if( ret ) //插入结点不能为空 
    {
        for(i=1; i<=sList->capacity; i++)
        {
            if( sList->node[i].next == AVAILABLE )
            {
                index = i; //未被使用节点的下标 
                break;
            }
        }
        
        sList->node[index].data = *((unsigned int*)node); //保存数据 
        
        sList->node[0] = sList->header; 
        
        for(i=0; (i<pos) && (sList->node[current].next != 0); i++)
        {
            current = sList->node[current].next; //若插入位置超过已存数据量，则放在后一位 
        }
        
        sList->node[index].next = sList->node[current].next;
        sList->node[current].next = index;
        
        sList->node[0].data++;  //队列头的data表示链表长度，后面则存储节点的数据 
        
        sList->header = sList->node[0];
    }
    
    return ret;
}

StaticListNode* StaticList_Get(StaticList* list, int pos)  // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    StaticListNode* ret = NULL; //判断是否插入成功 
    int current = 0;
    int object = 0;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->header.data) )
    {
       sList->node[0] = sList->header;
        
        for(i=0; i<pos; i++)
        {
            current = sList->node[current].next;
        }
        
        object = sList->node[current].next;
        
        ret = (StaticListNode*)(&sList->node[object].data);
    }
    
    return ret;
}

StaticListNode* StaticList_Delete(StaticList* list, int pos) // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    StaticListNode* ret = NULL;
    int current = 0;
    int object = 0;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->header.data) )
    {
        sList->node[0] = sList->header;
        
        for(i=0; i<pos; i++)
        {
            current = sList->node[current].next;
        }
        
        object = sList->node[current].next; //找到要删除元素的下标 :object 
        
        sList->node[current].next = sList->node[object].next;
        
        sList->node[0].data--;
        
        sList->header = sList->node[0];
        
        sList->node[object].next = AVAILABLE;
        
        ret = (StaticListNode*)(&sList->node[object].data);
    }
    
    return ret;
}

StaticList.h

#ifndef _STATICLIST_H_
#define _STATICLIST_H_

typedef void StaticList;
typedef void StaticListNode;

StaticList* StaticList_Create(int capacity);

void StaticList_Destroy(StaticList* list);

void StaticList_Clear(StaticList* list);

int StaticList_Length(StaticList* list);

int StaticList_Capacity(StaticList* list);

int StaticList_Insert(StaticList* list, StaticListNode* node, int pos);

StaticListNode* StaticList_Get(StaticList* list, int pos);

StaticListNode* StaticList_Delete(StaticList* list, int pos);

#endif

main

#include <stdio.h>
#include <stdlib.h>
#include "StaticList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[])
{
    StaticList* list = StaticList_Create(10);
    
    int index = 0;
    
    int i = 0;
    int j = 1;
    int k = 2;
    int x = 3;
    int y = 4;
    int z = 5;
    
    StaticList_Insert(list, &i, 0);
    StaticList_Insert(list, &j, 0);
    StaticList_Insert(list, &k, 0);
    
    for(index = 0; index<StaticList_Length(list); index++)
    {
        int* p = (int*)StaticList_Get(list, index);
　　　　 printf("Get:%d
", *p);
    }

    getchar();
    return 0;
}

三、动态链表

　　 如果程序支持指针,则可按照我们的一般形式实现链表, 需要时分配,不需要时回收即可.

代码示例：

LinkList.c

#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"

typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
} TLinkList;

LinkList* LinkList_Create() // O(1)
{
    TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
    }
    
    return ret;
}

void LinkList_Destroy(LinkList* list) // O(1)
{
    free(list);
}

void LinkList_Clear(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
    }
}

int LinkList_Length(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

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

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

LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (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;
}

LinkList.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
    LinkListNode* next;
};

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif

lmain.c

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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Value
{
    LinkListNode header;
    int v;
};

int main(int argc, char *argv[]) 
{
    LinkList* list = LinkList_Create();
    
    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    
    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;
    
    LinkList_Insert(list, (LinkListNode*)&v1, 0); //头插法
    LinkList_Insert(list, (LinkListNode*)&v2, 0);
    LinkList_Insert(list, (LinkListNode*)&v3, LinkList_Length(list));//尾插法 
    LinkList_Insert(list, (LinkListNode*)&v4, LinkList_Length(list));
    LinkList_Insert(list, (LinkListNode*)&v5, LinkList_Length(list));
    
    for(int i=0; i<LinkList_Length(list); i++)
    {
        struct Value* pv = (struct Value*)LinkList_Get(list, i);
        
        printf("%d
", pv->v);
    }
    
    while( LinkList_Length(list) > 0 )
    {
        struct Value* pv = (struct Value*)LinkList_Delete(list, 0);
        
        printf("%d
", pv->v);
    }
    
    /*for(int i=0; i<LinkList_Length(list); i++)
    {
        struct Value* pv = (struct Value*)LinkList_Get(list, i);
        
        printf("%d
", pv->v);
    }*/
    
    LinkList_Destroy(list);
    
    getchar(); 
    return 0;
}

四、双向链表

　　相比单向链表有以下优势：

　　　　插入删除不需要移动元素外，可以原地插入删除。

　　　　可以双向遍历。

          

 删除单个图示：

           

代码示例：

 DLinkList.c

#include <stdio.h>
#include <malloc.h>
#include "DLinkList.h"

typedef struct _tag_DLinkList
{
    DLinkListNode header;  //链表头 
    DLinkListNode* slider; //游标记录当前节点位置 
    int length;
} TDLinkList;

DLinkList* DLinkList_Create() // O(1)
{
    TDLinkList* ret = (TDLinkList*)malloc(sizeof(TDLinkList));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->header.pre = NULL;
        ret->slider = NULL;
    }
    
    return ret;
}

void DLinkList_Destroy(DLinkList* list) // O(1)
{
    free(list);
}

void DLinkList_Clear(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
        sList->header.pre = NULL;
        sList->slider = NULL;
    }
}

int DLinkList_Length(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos) // O(n)
{ 
    TDLinkList* sList = (TDLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        DLinkListNode* next = NULL;
        
        for(i=0; (i<pos) && (current->next != NULL); i++) //指针移到要插入位置 
        {
            current = current->next;
        }
        
        next = current->next; //保存原节点 
        
        current->next = node; //插入节点 
        node->next = next;      //插入节点指向原节点 
       if( next != NULL)
       {
         next->pre = node;   //如果原节点不为空，则原节点的pre指向刚插入节点 
       } 
        node->pre = current; //插入节点的pre指向原节点的pre 
        
       if( sList->length == 0)
       {
         sList->slider = node;  //node为第一个元素  
       }
       
       if( current == (DLinkListNode*)sList)  //current指向表头 
       {
              node->pre = NULL;
       }
      sList->length++;   //节点数加一 
    } 
    return ret;
}

DLinkListNode* DLinkList_Get(DLinkList* list, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos) // O(n)  根据位置删除节点 
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        DLinkListNode* next = NULL;
        
        for(i=0; i<pos; i++)
        {
           current = current->next; 
        }
        
        ret = current->next; //移到要删除节点 
        next = ret->next;     //保存删除节点的下一个节点地址 
        
        current->next = next; //被删除节点的上一个节点的next,指向被删除节点的下一个节点地址 
        
        if( next != NULL)
        {
            next->pre = current;  //如果删除节点的下一个节点地址不为空，则pre指向被删除节点的上一个节点地址
            
            if( current == (DLinkListNode*)sList)
            {
                next->pre = NULL; //如被删除节点是第一个节点，则pre=NULL,即current指向表头  
            }
        }
        
        if( sList->slider = ret)
        {
            sList->slider = next; //如当前游标指向要被删除的节点，则游标前移一位 
        }
        
        sList->length--;  //节点数减一 
    }
    
    return ret;
}

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node) //根据指定节点找到位置 
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if(sList != NULL)
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        
        for(i=0; i<sList->length; i++)
        {
            if(current->next == node)
            {
                ret = current->next;
                break;
            }
            
            current = current->next;
        }
        
        if( ret != NULL)
        {
            DLinkList_Delete(sList, i); //删除节点 
        }
    }
    
}

DLinkListNode* DLinkList_Reset(DLinkList* list) //游标复位指向第一个节点 
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( sList != NULL)
    {
        sList->slider = sList->header.next; 
        ret = sList->slider;
    }
    
    return ret;
} 

DLinkListNode* DLinkList_Current(DLinkList* list) //获取当前链表游标指向的位置 
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( sList != NULL)
    {
        ret = sList->slider;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Next(DLinkList* list) //游标后移一位 
{
   TDLinkList* sList = (TDLinkList*)list;
   DLinkListNode* ret = NULL;
  
  if((sList != NULL) && (sList->slider != NULL))
  { 
        ret = sList->slider;
        sList->slider = ret->next;
  }
  
  return ret;
}

DLinkListNode* DLinkList_Pre(DLinkList* list) //游标前移一位 
{
    TDLinkList* sList = (TDLinkList*)list;
   DLinkListNode* ret = NULL;
  
  if((sList != NULL) && (sList->slider != NULL))
  { 
        ret = sList->slider;
        sList->slider = ret->pre;
  }
  
  return ret;
    
}

 DLinkList.h

#ifndef _DDLinkList_H_
#define _DDLinkList_H_

typedef void DLinkList;
typedef struct _tag_DLinkListNode DLinkListNode;
struct _tag_DLinkListNode
{
    DLinkListNode* next;
    DLinkListNode* pre;
};

DLinkList* DLinkList_Create();

void DLinkList_Destroy(DLinkList* list);

void DLinkList_Clear(DLinkList* list);

int DLinkList_Length(DLinkList* list);

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);

DLinkListNode* DLinkList_Get(DLinkList* list, int pos);

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);

DLinkListNode* DLinkList_Reset(DLinkList* list);  //以下为游标设置 

DLinkListNode* DLinkList_Current(DLinkList* list);

DLinkListNode* DLinkList_Next(DLinkList* list);

DLinkListNode* DLinkList_Pre(DLinkList* list);

#endif

main.c

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

struct value
{
  DLinkListNode header;
  int v;
};

int main(int argc, char *argv[])
{
  int i = 0;
  DLinkList* list = DLinkList_Create();
   struct value* pv = NULL;
  struct value v1;
  struct value v2;
  struct value v3;
  struct value v4;
  struct value v5;
  
  v1.v = 1;
  v2.v = 2;
  v3.v = 3;
  v4.v = 4;
  v5.v = 5;
  
  DLinkList_Insert(list, (DLinkListNode*)&v1, DLinkList_Length(list));
  DLinkList_Insert(list, (DLinkListNode*)&v2, DLinkList_Length(list));
  DLinkList_Insert(list, (DLinkListNode*)&v3, DLinkList_Length(list));
  DLinkList_Insert(list, (DLinkListNode*)&v4, DLinkList_Length(list));
  DLinkList_Insert(list, (DLinkListNode*)&v5, DLinkList_Length(list));
  
  for(i=0; i<DLinkList_Length(list); i++)
  {
      pv = (struct value*)DLinkList_Get(list,i);  
        printf("%d
", pv->v);
  }
  
  printf("
");
  
  DLinkList_Delete(list, DLinkList_Length(list)-1);
  DLinkList_Delete(list, 0);
  
  for(i=0; i<DLinkList_Length(list); i++)
  {
      pv = (struct value*)DLinkList_Next(list);  
      printf("%d
", pv->v);
  }
  
  printf("
");
  
  DLinkList_Reset(list);
  DLinkList_Next(list);
  
  pv = (struct value*)DLinkList_Current(list);  
  printf("%d
", pv->v);
  
  DLinkList_DeleteNode(list, (DLinkListNode*)pv);
  pv = (struct value*)DLinkList_Current(list); //获取游标指示的数据  
  printf("%d
", pv->v);
  
  DLinkList_Pre(list); //游标前移 
  pv = (struct value*)DLinkList_Current(list); //获取游标指示的数据  
  printf("%d
", pv->v);
  
  DLinkList_Destroy(list);
  
  printf("Press enter to continue ...");
  getchar();    
  return 0;

}

五、循环单链表

循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

代码示例：

DLinkList.c

#include <stdio.h>
#include <malloc.h>
#include "CircleList.h"

typedef struct _tag_CircleList
{
    CircleListNode header;
    CircleListNode* slider;
    int length;
} TCircleList;



CircleList* CircleList_Create() // O(1)
{
    TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->slider = NULL;
    }
    
    return ret;
}

void CircleList_Destroy(CircleList* list) // O(1)
{
    free(list);
}

void CircleList_Clear(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
        sList->slider = NULL;
    }
}

int CircleList_Length(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n)
{ 
    TCircleList* sList = (TCircleList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
       CircleListNode* current = (CircleListNode*)sList;
        
        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }
        
        node->next = current->next; //插入节点next指向插入位置的next 
        current->next = node;        //插入位置的next指向插入节点 
        
        if(sList->length == 0)  //如果是第一个插入节点 
        {
           sList->slider = node; //光标指向插入的第一个节点 
           node->next = node;    //插入节点next即指向自己 
        }
        
        sList->length++; //链表长度加一 
    }
    
    return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;  
    int i = 0;
    
    if((sList != NULL) && (0 <= pos))
    {
        CircleListNode* current = (CircleListNode*)sList;
        
        for(i=0; i<pos; i++)
        {
           current = current->next;
        }
        
        ret = current->next;
    }
    
    return ret;
}

CircleListNode* CircleList_Delete(CircleList* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) )
    {
        CircleListNode* current = (CircleListNode*)sList;
        
        CircleListNode* first = sList->header.next;
        CircleListNode* last = (CircleListNode*)CircleList_Get(sList,sList->length-1); 
               
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
        current->next = ret->next;
        
        sList->length--;
        
        if( first == ret )  //还剩头结点和一个数据结点 
        {
           sList->header.next = ret->next;
           last->next = ret->next;   
        }
        
        if( sList->slider == ret )
        {
           sList->slider = ret->next;
        }
        
        if( sList->length == 0 )
        {
           sList->header.next = NULL;
        }
    }
    
    return ret;
}

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( sList != NULL)
    {
       CircleListNode* current = (CircleListNode*)sList;
       
       for(i=0; i<sList->length; i++)
       {
            if( current->next == node)
            {
                ret = current->next;
                break;
            }
            current = current->next;
       } 
       if( ret != NULL)
       {
            CircleList_Delete(sList,i);
       }
    }
    
    return ret;
}

CircleListNode* CircleList_Reset(CircleList* list)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    
    if( sList != NULL)
    {
        sList->slider = sList->header.next;
        ret = sList->slider;
    }
    
    return ret;
}

CircleListNode* CircleList_Current(CircleList* list)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( sList != NULL)
    {
        ret = sList->slider;
    }
    
    return ret;
}

CircleListNode* CircleList_Next(CircleList* list)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    
    if( (sList != NULL) && (sList->slider != NULL))
    {
        ret = sList->slider;
        sList->slider = ret->next;
    }
    
    return ret;
}

DLinkList.h

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef void CircleList;
typedef struct _tag_CircleListNode CircleListNode;

struct _tag_CircleListNode
{
    CircleListNode* next;
};

CircleList* CircleList_Create();

void CircleList_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif

main.c

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

struct Value
{
    CircleListNode header; //定义新变量时会被初始化 
    int v;
};

int main(int argc, char *argv[])
{
    int i = 0;
    CircleList* list = CircleList_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;
    
    CircleList_Insert(list, (CircleListNode*)&v1, 0);//CircleList_Length(list)); //pos == 0
    //printf("Length is :%d
",CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v2, 1);//CircleList_Length(list)); 
    //CircleList_DeleteNode(list, );  
    CircleList_Insert(list, (CircleListNode*)&v3, 2);//CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v4, 3);//CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v5, 4);//CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v6, 6);

    
      for(i = 0; i<CircleList_Length(list); i++)
      {
          struct Value* pv = (struct Value*)CircleList_Get(list, i); 
          printf("%d
", pv->v);
      }
      
       printf("
");
       
       while( CircleList_Length(list) > 0)
       {
            struct Value* pv = (struct Value*)CircleList_Delete(list,0);
            
            printf("%d
", pv->v);
       }

  printf("Press enter to continue ...");
  getchar();    
  return 0;

}

-end-