静态链表与动态链表

转载自 https://blog.csdn.net/zhengqijun_/article/details/78192888
https://blog.csdn.net/hhhhhyyyyy8/article/details/81027728

静态链表和动态链表的区别：

静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。

1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。

2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表因为是动态申请内存的，所以每个节点的物理地址不连续，要通过指针来顺序访问。

一、静态链表

结构体中的成员可以是各种类型的指针变量，当一个结构体中有一个或多个成员的基类型是本结构体类型时，则称这种结构体为“引用自身的结构体”。如：

struct node
{
　　char ch;
    int num;
　　struct node *p;
};
 
struct node a;	//声明一个结构体变量

p是一个可以指向struct node类型变量的指针成员。因此，a.p = &a 是合法的表达式，由此构成的存储结构如下图所示：

参考程序如下所示：

/*****************************************************
Copyright (C) 2017-2018 All rights reserved.
File name    ： static_link.c
Version      ： v1.0       
Author       ： Zhengqijun
Date         ： 2017年10月10日 星期二 15时12分30秒
Description  ： 
Funcion List ： 
*****************************************************/
 
#include <stdio.h>
 
/* 静态链表 */
struct node
{
    int num;
    struct node *next;
};
 
int main()
{
    struct node stu[3];
    struct node *head, *p;
 
    stu[0].num = 10;		//对结点的num成员赋值
    stu[1].num = 20;
    stu[2].num = 30;
 
    head = &stu[0];		//头指针指向第1个结点stu[0]
    stu[0].next = &stu[1];	//将结点stu[1]的地址赋值给stu[0]结点的next成员
    stu[1].next = &stu[2];	//将结点stu[2]的地址赋值给stu[1]结点的next成员
    stu[2].next = NULL;		//stu[2]是最后一个结点，其next成员不存放任何结点的地址，置为NULL
 
    //遍历静态链表
    p = head;			//使p指针也指向第1个结点
    
    do{
        printf("%d\n", p->num);	//输出p所指向结点的数据
        p = p->next;		//然后让p指向下一个结点
    } while (p != NULL);	//直到p的next成员为NULL，即完成遍历
 
    return 0;
}

二、动态链表

到目前为止，凡是遇到处理“批量”数据时，我们都是利用数组来存储。定义数组必须（显式的或隐含的）指明元素的个数，从而也就限定了一个数组中存放的数据量。在实际应用中，一个程序在每次运行时要处理的数据的数目通常并不确定。如果数组定义的小了，就没有足够的空间存放数据，定义大了又浪费存储空间。
对于这种情况，如果能在程序执行过程中，根据需要随时开辟存储空间，不需要时再随时释放，就能比较合理的使用存储空间。C 语言的动态存储分配提供了这种可能性。每次动态分配的存储单元，其地址不一定是连续的，而所需处理的批量数据往往是一个整体，各数据之间存在着接序关系。链表的每个节点中，除了要有存放数据本身的数据域外，至少还需要有一个指针域，用它来存放下一个节点元素的地址，以便通过这些指针把各节点连接起来。由于链表每个存储单元都由动态存储分配获得，故称这样的链表为“动态链表”。

参考程序如下所示：

/*****************************************************
Copyright (C) 2017-2018 All rights reserved.
File name    ： dynamic_link.c
Version      ： v1.0       
Author       ： Zhengqijun
Date         ： 2017年10月10日 星期二 15时31分59秒
Description  ： 
Funcion List ： 
*****************************************************/
 
#include <stdio.h>
#include <stdlib.h>
 
/*所谓动态链表，是指在程序执行过程中从无到有地建立起一个链表，即一个一个地开辟结点和输入各结点数据，并建立起前后相链的关系。*/
struct Student
{
    int No;		//学号
    struct Student *next;
};
 
int main()
{
    struct Student *p1, *p2;
	struct Student *head, *p;
 
    int n = 0; //结点个数
 
    head = NULL;
    p1 = (struct Student *)malloc(sizeof(struct Student));
    printf("请输入第1个学号\n");
    scanf("%d", &p1->No);
 
    p2 = p1; //开始时，p1和p2均指向第1个结点
    while (p1->No != 0)
    {
        n++;
        if (n == 1)
        {
            head = p1;
        }
        else
        {
            p2->next = p1;
        }
 
        p2 = p1;//p2是最后一个结点
        printf("请输入学号，输入0终止：\n");
        p1 = (struct Student *)malloc(sizeof(struct Student));
        scanf("%d", &p1->No);
    };
 
    p2->next = NULL;//输入完毕后，p2->next为NULL
 
    //遍历动态链表
	p = head;
    printf("\n学号为：\n");
 
    while (p != NULL)
    {
        printf("%d\n", p->No);
        p = p->next;
    }
 
    return 0;
}

输出结果为：

root@ubuntu:~/2017/1010$ ./dynamic_link 

请输入第1个学号1请输入学号，输入0终止：2请输入学号，输入0终止：3请输入学号，输入0终止：4请输入学号，输入0终止：0学号为：1234

注意：动态链表中，每个节点没有自己的名字，只能靠指针维系节点之间的关系。一旦某个节点的指针“断开”，后续节点就再也无法找寻！

文字部分转载自：https://www.cnblogs.com/zhaoxy/p/7754906.html

静态链表

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

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

静态链表的插入操作

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

静态链表的删除操作

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

#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("\n");
}
 
int main(void)
{
	StaticLinkList L;
	printf("初始化链表:\n");
	InitStaticLinkList(L);
	printf("初始化链表之后，链表的长度为:%d\n", StaticLinkListLength(L));
	printf("插入1,2,3,4,5\n");
	StaticLinkListInsert(L, 1, 1);
	StaticLinkListInsert(L, 1, 2);
	StaticLinkListInsert(L, 1, 3);
	StaticLinkListInsert(L, 1, 4);
	StaticLinkListInsert(L, 1, 5);
	printf("遍历链表:\n");
	StaticLinkListTraverse(L);
	printf("链表长度为:%d\n", StaticLinkListLength(L));
	printf("删除第二个元素:\n");
	int key;
	StaticLinkListDelete(L, 2, &key);
	printf("删除的元素值为:%d\n", key);
	printf("遍历链表:\n");
	StaticLinkListTraverse(L);
 
}

静态链表的优缺点：

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

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