静态链表、循环链表、双向链表(C代码实现)

静态链表

对于没有指针的编程语言，可以用数组替代指针，来描述链表。让数组的每个元素由data和cur两部分组成，其中cur相当于链表的next指针，这种用数组描述的链表叫做静态链表，这种描述方法叫做游标实现法。我们对数组的第一个和最后一个元素做特殊处理，不存数据。让数组的第一个元素cur存放第一个备用元素（第一个未被占用的元素）下标，而数组的最后一个元素cur存放第一个有值的元素下标，相当于头结点作用。空的静态链表如下图

当存放入一些数据时（"甲""乙""丁""戊""己""庚"），静态链表为：

静态链表的插入操作

在静态链表第三个位置插入"丙"后，结果如下：

静态链表中要解决的是：如何用静态模拟动态链表结构的存储空间的分配，需要时申请，无用时释放。

其主要的思想：

 我们自己定义一个内存分配函数，如Malloc_SLL(StaticLinkList space)

//插入元素时，分配空间的下标（从备用链表中去取出）
int Malloc(StaticLinkList L)
{
    int i = L[0].cur;               //获取备用链表的下标
    if (i)                           //链表不为空
        L[0].cur = L[i].cur;       //将第一位的游标改成备用链表的下表+1
    return i;
}

然后再修改游标表示，如上图

代码附上：

//静态链表中i位置插入一个元素
bool StaticLinkListInsert(StaticLinkList L, int i, int key)
{
    //判断插入点是否合理
    if (i<1 || i>StaticLinkListLength(L)+1)
    {
        return false;
    }
    int j = Malloc(L);
    int k = MAXSIZE - 1;
    if (j)
    {
        for (int l = 1; l <= j - 1; l++)
        {
            k = L[k].cur;
        }
        L[j].data = key;
        L[j].cur = L[k].cur;
        L[k].cur = j;
        return true;
    }
    return false;
    
}

静态链表的删除操作

删除操作其实就是插入操作的逆操作

我们同样要自己定义一个Free函数

void Free(StaticLinkList L, int k)
{
    L[k].cur = L[0].cur;
    L[0].cur = k;
}

获取要删除的元素下标后，开始修改游标

bool StaticLinkListDelete(StaticLinkList L,int i, int *key)
{
    if (i < 1 || i >= StaticLinkListLength(L))
    {
        return false;
    }
    int k = MAXSIZE - 1;
    for (int l = 1; l <= i-1; l++)
    {
        k = L[k].cur;
    }
    int j = L[k].cur;
    *key = L[j].data;
    L[k].cur = L[j].cur;
    Free(L, j);
    return true;
}

删除"甲"后，静态链表如下：

 总结一下静态链表的优缺点：

优点：在插入和删除时，只需要修改游标，不需要移动元素。从而改进了在顺序存储结构中的插入和删除需要移动大量元素的特点。

缺点：没有解决连续存储分配带来的表长难以确定的问题；失去了顺序存储结构随机存储的特性。

Copy 了大佬一些些文字和图片:

https://www.cnblogs.com/zhaoxy/p/7754906.html

静态链表实现的一些基本操作：(附上代码)

#include<stdio.h>
 
#define MAXSIZE 7
#define true 1
#define false 0
 
typedef int bool;
 
typedef struct
{
    int data;
    int cur;
}StaticLinkList[MAXSIZE];
 
//初始化静态链表,0位置cur指向1位置，1位置cur指向2位置...MAXSIZE-1位置指向0位置
void InitStaticLinkList(StaticLinkList L)//本来想用小写l的，但是小写l看起来太怪了
{
    for (int i = 0; i < MAXSIZE - 2; i++)
    {
        L[i].cur = i + 1;//最后一个元素指向的是尾节点
    }
    L[MAXSIZE - 2].cur = 0;//备用链表的最后一个空元素的cur指向0，这一行不能省。
    L[MAXSIZE - 1].cur = 0;
}
 
 
//求静态链表中元素个数，不包括头尾节点
int StaticLinkListLength(StaticLinkList L)
{
    int i = L[MAXSIZE - 1].cur;
    int j = 0;
    while (i)
    {
        j++;
        i = L[i].cur;
    }
    return j;
}
 
//插入元素时，分配空间的下标
int Malloc(StaticLinkList L)
{
    int i = L[0].cur;
    if (i)
        L[0].cur = L[i].cur;
    return i;
}
 
 
//静态链表中i位置插入一个元素
bool StaticLinkListInsert(StaticLinkList L, int i, int key)
{
    //判断插入点是否合理
    if (i<1 || i>StaticLinkListLength(L)+1)
    {
        return false;
    }
    int j = Malloc(L);
    int k = MAXSIZE - 1;
    if (j)
    {
        for (int l = 1; l <= j - 1; l++)
        {
            k = L[k].cur;
        }
        L[j].data = key;
        L[j].cur = L[k].cur;
        L[k].cur = j;
        return true;
    }
    return false;
    
}
 
 
void Free(StaticLinkList L, int k)
{
    L[k].cur = L[0].cur;
    L[0].cur = k;
}
 
//删除第i个元素
 
bool StaticLinkListDelete(StaticLinkList L,int i, int *key)
{
    if (i < 1 || i >= StaticLinkListLength(L))
    {
        return false;
    }
    int k = MAXSIZE - 1;
    for (int l = 1; l <= i-1; l++)
    {
        k = L[k].cur;
    }
    int j = L[k].cur;
    *key = L[j].data;
    L[k].cur = L[j].cur;
    Free(L, j);
    return true;
}
 
//遍历
void StaticLinkListTraverse(StaticLinkList L)
{
    int k = MAXSIZE - 1;
    while (L[k].cur)
    {
        k = L[k].cur;
        printf("%d ", L[k].data);
    }
    printf("
");
}
 
int main(void)
{
    StaticLinkList L;
    printf("初始化链表:
");
    InitStaticLinkList(L);
    printf("初始化链表之后，链表的长度为:%d
", StaticLinkListLength(L));
    printf("插入1,2,3,4,5
");
    StaticLinkListInsert(L, 1, 1);
    StaticLinkListInsert(L, 1, 2);
    StaticLinkListInsert(L, 1, 3);
    StaticLinkListInsert(L, 1, 4);
    StaticLinkListInsert(L, 1, 5);
    printf("遍历链表:
");
    StaticLinkListTraverse(L);
    printf("链表长度为:%d
", StaticLinkListLength(L));
    printf("删除第二个元素:
");
    int key;
    StaticLinkListDelete(L, 2, &key);
    printf("删除的元素值为:%d
", key);
    printf("遍历链表:
");
    StaticLinkListTraverse(L);
 
}

并且附上代码来源：

https://blog.csdn.net/hhhhhyyyyy8/article/details/81027728

 循环链表

1、循环链表：

　　　　　　这个就是在单链表的基础上头尾相接了，将最后一个结点的指针指向了L->next;这里我们也不多做赘述，它的大部分操作和单链表是相似的。

　　　　　　还有一点要注意的就是判断一个循环链表是否为空条件是看头结点是否指向其本身。

双向链表

所谓双向就是说有两个方向，其实就是在单链表的基础上，多了一个前驱的指针域，用来指向前驱元素，其解决了单链表单向性这一缺点(只能顺着后继元素遍历)

双向循环链表，与循环链表类似，带头结点的双向循环空链表如下图（左），非空如下图（右边）

 

 

那么入定义一个双向链表呢？

 typedef struct DulNode
{
     struct DulNode *prior;                      //前驱指针
     struct DulNode *next;                       //后继指针
     ElemType e;                                 //数据域
}DulNode,*DuLinkList;

插入操作

 对比单链表学习，复杂并且灵活

 插入关键代码：

 s->prior = p;           //把p赋值给s的前驱，s的前驱指向p
 s->next = p->next;      //把p->next赋值给s的后继 
 p->next->prior = s;     //把s赋值给p-next的前驱
p->next = s;            //把s赋值给p的后继

删除操作

删除操作关键代码：

1 P->prior->next = p->next; //把p->next的值赋给p->prior的后继
2 p->next->prior = P->prior;//把p=>prior赋值给p->next的前驱

复习回顾：

我们对线性表的两大结构进行了学习，先是学习了比较容易的顺序存储结构，，指的是用一段地址连续的存储单元依次存储线性表中的元素，我们通常使用数组来实现。

后面则是学习了链式存储结构。它具有不收存储空间的限制，可以比较快捷的插入和删除的特点被广为使用。然后还学习了动态链表的单链表、双链表、循环链表，以及最后我们还学习了如何不使用指针处理链式结构的数据关系---静态链表。

总的来说，线性表就包含了顺序存储结构和链式存储结构两大结构。