目录
前言
在学习前我们先了解几个问题。
1.什么是线性表？
线性表是由n（n≥0）个数据元素a，a，a,...，a[n]组成的有限序列，其中a[i-1]是a[i]的直接前驱，a[i+1]是a[i]的直接后继，除第一个元素外，每个元素都有唯一的前驱;除最后一个元素外，每个元素都有唯一的后继。
2.线性表有哪些基本操作？
线性表的基本操作包括：插入、删除、查找、遍历、获取长度等。
2.1插入操作：向线性表中插入一个元素，需要指定插入位置和插入元素的值。
2.2删除操作：从线性表中删除一个元素，需要指定删除位置。
2.3查找操作：在线性表中查找一个元素，可以根据元素值或者位置进行查找。
2.4遍历操作：依次访问线性表中的每个元素。
2.5获取长度操作：获取线性表中元素的个数。
3.线性表的实现方式有哪些？
线性表的实现方式有两种：顺序存储和链式存储。
3.1顺序存储：使用数组来存储线性表中的元素，通过下标来访问元素。优点是随机访问速度快，缺点是插入和删除操作需要移动大量元素。
3.2链式存储：使用指针来连接线性表中的元素，每个元素包含一个数据域和一个指针域。优点是插入和删除操作方便，缺点是访问元素需要遍历整个链表。
4.线性表的逻辑机构
4.1线性表的逻辑定义
线性表是由n（n≥0）个数据元素（结点）a1，a2，....an组成的有限序列。
线性表的逻辑结构特征（对于非空的线性表）如下:
4.1.1仅有一个开始结点a1，没有直接前趋，仅有一个直接后继a2；
4.1.2仅有一个终端结点 an，没有直接后继，仅有一个直接前趋 an-1;
4.1.3其余的内部结点a，都有且仅有一个直接前趋和一个直接后继。
4.22.常见的线性表的基本运算
- InitList（L )：构造一个空的线性表L，即表的初始化。
- ListLength（L）：求线性表L中的结点个数，即求表长。
- GetNode（L，i)：取线性表L中的第i个结点，1≤i≤ListLength(L）。
- LocateNode（L，x)：在L中查找值为x的结点，并返回x在L中的位置。若L中没结点的值为x，则返回一个特殊值表示查找失败。
- InsertList（L，x，i)：在表L的第i个位置上插入一个值x的结点。
- DeleteList（L，i)：删除线性表L的第i个结点。
顺序存储参见我之前的文章《详解顺序表 第三次！！》，今天我们学习的是链式存储。
正文
1.简单链表
单链表是用任意一组的存储单元来存放线性表的节点，这组存储单元既可以是连续的，也可以是不连续的。甚至可以零散分布在内存中的任意位置。为了能正确表示节点间的逻辑关系，在存储每个节点值的同时，还必须存储指示其后继的地址信息，这个信息叫做指针或者链。
1.1链表节点的定义：
/*简单链表的定义*/
typedef struct node
{
DataType data; /*数据域，DataType为数据类型*/
struct node *next; /*指针域*/
}SingleLinkList, SingleLinkNode;1.2节点空间开辟（申请空间）
当执行SingleLinkNode*p后该指针变量指向的节点变量并未开辟空间，在执行程序过程中当需要时才产生，需要执行
p= (SingleLinkList*)malloc(sizeof(SingleLinkList))才能分配一个类型为SingleLinkList的节点变量空间。
1.3节点空间释放：
当P指向的节点变量不在需要后通过执行free(p)来释放。
结合之前内容我们来做一个演示程序
实现
1.单链表的建立：
首先创建一个初始化链表
/*1. 初始化*/
int init(SingleLinkList **Head)//**改变指针原来的值，*指针指向的值
{
if(1)
{
/*申请内存*/
(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
/*判断内存申请是否成功*/
if(*Head == NULL)
{
printf("申请内存错误， 初始化失败！[100001]\n");
return 100001;
}
(*Head)->next = NULL;
return 0;
}
else
{
printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
return 100002;
}
}
2.插入算法（头插法）
我们用直观的图解法来解释
插入过程如图所示：
代码如下：
int insert_head(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
newNode->next = (*Head)->next;
(*Head)->next = newNode;
return 0;
}
实现如下：
补充：输出代码如下（参见上一篇输出内容这里不做详细讲解）：
/*6.输出链表*/
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i=0;
p = Head->next;
if(!p)
{
printf("链表为空！\n");
return;
}
while(p)
{
printf("Node[%d]. = %d\n", ++i, p->data);
p = p->next;
}
}3.插入算法（尾插法）
我们用直观的图解法来解释
插入过程如图所示：
代码如下：
int insert_tail(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
SingleLinkNode *p;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
newNode->next = NULL;
p = (*Head);
while(p->next)
{
p = p->next;
}
p->next = newNode;
return 0;
}让我们来看一下具体实现：
由上述我们可以直观的感受到头尾插法的实现 下面我们讲第三种也就是在任意位置的插入
4.插入算法（插入元素，在位置i处插入元素x）
将值为x的新结点插入到表的第i个结点的位置上，即插入到ar1与a；之间。
步骤：①找到ai1存储位置po
②生成一个数据域为x的新结点s。
③新结点的指针域指向结点 aio
④ 令结点p的指针域指向新结点。
插入过程如图所示。
注意：为了保持链表的完整性我们要先执行第3步在执行第4步
代码如下：
int insert(SingleLinkList **Head, int i, DataType x)
{
int j;
SingleLinkNode *p;
SingleLinkNode *newNode;
/*对i进行判断，0<i<=length+1*/
if(i<1 || i>length(*Head)+1)
{
printf("位置i不是链表有效位置！[100005]\n");
return 100005;
}
p = (*Head);
j = 1;
while(j<i)
{
j++;
p = p->next;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
newNode->data = x;
newNode->next = p->next;
p->next = newNode;
return 0;
}效果如下：
5.查找元素 （查找值为x的元素，返回位置i）
下面我们实现一个查找元素
int find(SingleLinkList *Head, DataType x)
{
int i;
SingleLinkNode *p;
i = 1;
p = Head->next;
while(p && p->data != x)
{
i++;
p = p->next;
}
if(!p)
{
return 0;
}
else
{
return i;
}
}效果如下：
6. 链表的长度：
这个可以参见之前内容我们直接上效果图
int length(SingleLinkList *Head)
{
int len=0;
SingleLinkNode *p;
p = Head->next;
while(p)
{
len++;
p = p->next;
}
return len;
}
7.删除元素：
删除运算：
删除运算是将表的第i个结点删去。步骤：
①找到a(i-1)的存储位置p.
②让r指向ai，方便释放。
③令p->next 指向ai的直接后继结点，跨过ai结点。
④通过执行 free(r)释放节点ai的空间，节省内存空间。
删除过程如图所示。
代码如下：
int delete1(SingleLinkList **Head, DataType x)
{
int i;
int j;
SingleLinkNode *p;
SingleLinkNode *q; /*要删除的元素x*/
i = find(*Head,x);
if(!i)
{
printf("元素x【%d】不存在！100006\n", x);
return 100006;
}
p = (*Head);
j=1;
while(j<i)
{
j++;
p = p->next;
}
q = p->next;
p->next = q->next;
free(q); /*释放内存*/
return 0;
}
实现如下：
总代码:
到这里我们一个完整的单链表的演示程序就做出来了下面是完整的代码文件！
main.c
#include <stdio.h>
#include <string.h>
#include "SingleLinkList.c"
#include "welcome.h"
#include <stdlib.h>
int main(int argc, char *argv[])
{
SingleLinkList *Head;
DataType x;
int i, m, n, cmd;
for(i=0;i<strlen(welcome);i++)
{
printf("%c",welcome[i]);
for(m=0;m<10000;m++)
for(n=0;n<1000;n++)
{
;
}
}
printf("-----------简单链表演示程序----------\n");
do
{
printf("1. 初始化链表表\n");
printf("2. 插入元素（头插法）\n");
printf("3. 插入元素（尾插法）\n");
printf("4. 插入元素（在位置i插入）\n");
printf("5. 查找元素x\n");
printf("6. 求链表长度\n");
printf("7. 输出链表\n");
printf("8. 删除元素\n");
printf("10. 帮助\n");
printf("0. 退出\n");
printf("请输入您要进行的操作（1~10,0退出）：");
scanf("%d", &cmd);
switch (cmd)
{
case 1:
if (!init(&Head))
{
printf("链表已初始化！\n");
}
break;
case 2:
printf("请输入插入元素x：x=");
scanf("%d", &x);
if (!insert_head(&Head, x))
{
printf("元素（%d）已插入\n", x);
}
break;
case 3:
printf("请输入插入元素x：x=");
scanf("%d", &x);
if (!insert_tail(&Head, x))
{
printf("元素（%d）已插入\n", x);
}
break;
case 4:
printf("请输入插入元素位置i和元素x（i，x）：");
scanf("%d,%d", &i, &x);
if (!insert(&Head, i, x))
{
printf("已在位置（%d）插入元素（%d）！\n", i, x);
}
break;
case 5:
printf("请输入要查找的元素x：");
scanf("%d", &x);
if (i = find(Head, x))
{
printf("元素%d存在，在链表位置%d.\n", x, i);
}
else
{
printf("在链表中未找到元素x。\n");
}
break;
case 6:
printf("链表的长度为：%d\n", length(Head));
break;
case 7:
print(Head);
break;
case 8:
printf("请输入要删除的元素x：");
scanf("%d", &x);
if (!delete1(&Head, x))
{
printf("元素x【%d】已删除!\n", x);
}
break;
case 10:
printf(" 本程序为链表的演示程序，由scd（老师非让写名字）设计开发，程序完成了单链表程序功能！。。。\n");
break;
}
} while (cmd != 0);
system("pause");
return 0;
}SingleLinkList.c
#include "SingleLinkList.h"
#include <stdlib.h>
#include <stdio.h>
/*1. 初始化*/
int init(SingleLinkList **Head)
{
if(1)
{
/*申请内存*/
(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
/*判断内存申请是否成功*/
if(*Head == NULL)
{
printf("申请内存错误， 初始化失败！[100001]\n");
return 100001;
}
(*Head)->next = NULL;
return 0;
}
else
{
printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
return 100002;
}
}
/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
newNode->next = (*Head)->next;
(*Head)->next = newNode;
return 0;
}
/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
SingleLinkNode *p;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
newNode->next = NULL;
p = (*Head);
while(p->next)
{
p = p->next;
}
p->next = newNode;
return 0;
}
/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
int j;
SingleLinkNode *p;
SingleLinkNode *newNode;
/*对i进行判断，0<i<=length+1*/
if(i<1 || i>length(*Head)+1)
{
printf("位置i不是链表有效位置！[100005]\n");
return 100005;
}
p = (*Head);
j = 1;
while(j<i)
{
j++;
p = p->next;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
/*此处省略检测newNode是否申请成功*/
newNode->data = x;
newNode->next = p->next;
p->next = newNode;
return 0;
}
/*3. 删除元素, 删除值为x的元素*/
int delete1(SingleLinkList **Head, DataType x)
{
int i;
int j;
SingleLinkNode *p;
SingleLinkNode *q; /*要删除的元素x*/
i = find(*Head,x);
if(!i)
{
printf("元素x【%d】不存在！100006\n", x);
return 100006;
}
p = (*Head);
j=1;
while(j<i)
{
j++;
p = p->next;
}
q = p->next;
p->next = q->next;
free(q); /*释放内存*/
return 0;
}
/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
int i;
SingleLinkNode *p;
i = 1;
p = Head->next;
while(p && p->data != x)
{
i++;
p = p->next;
}
if(!p)
{
return 0;
}
else
{
return i;
}
}
/*4. 链表长度*/
int length(SingleLinkList *Head)
{
int len=0;
SingleLinkNode *p;
p = Head->next;
while(p)
{
len++;
p = p->next;
}
return len;
}
/*6.输出链表*/
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i=0;
p = Head->next;
if(!p)
{
printf("链表为空！\n");
return;
}
while(p)
{
printf("Node[%d]. = %d\n", ++i, p->data);
p = p->next;
}
}SingleLinkList.h
/*
SingleLinkList.h
*/
typedef int DataType;
/*简单链表的定义*/
typedef struct node
{
DataType data; /*数据域*/
struct node *next; /*指针域*/
}SingleLinkList, SingleLinkNode;
/*1. 初始化*/
int init(SingleLinkList **Head);
/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x);
/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x);
/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x);
/*3. 删除元素, 删除值为x的元素*/
int delete1(SingleLinkList **Head, DataType x);
/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x);
/*6. 求链表的长度 */
int length(SingleLinkList *Head);
/*7.输出链表*/
void print(SingleLinkList *Head);welcome.h
char welcome[] = "( ╯-_-)╯┴—┴ (ノ—_—)ノ~┴————┴ （╯－＿－）╯╧╧ （ノ*-_-*)ノ┴—┴\n\n(╯￣Д￣)╯╘═╛ (ノ=Д=)ノ┻━┻ （╯#-皿-)╯~~╧═╧ (╯’ – ‘)╯︵ ┻━┻ \n\n欢迎您浏览我的程序\n\n";总实现如下：
拓展
循环链表
1.基本概念（定义）：
循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。
循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址。
循环链表的逻辑关系图如下：
循环单链表的表尾结点的next指针总是指向头结点。
2.初始化
所以在初始化循环单链表的时候，需要记得将头结点的next指针指向头结点自己：
/*1. 初始化*/
int init(SingleLinkList **Head)
{
if(1)
{
/*申请内存*/
(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
/*判断内存申请是否成功*/
if(*Head == NULL)
{
printf("申请内存错误， 初始化失败！[100001]\n");
return 100001;
}
/*循环链表*/
(*Head)->next = *Head;//指向头位置
return 0;
}
else
{
printf("该循环链表已经初始化！请删除后再执行此操作！[100002]\n");
return 100002;
}
}同理只要我们将之前的内容尾节点的next指向head的便可以得出循环链表
3.插入：
/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
SingleLinkNode *p;
if (0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode *)malloc(sizeof(SingleLinkNode));
if (!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
newNode->next = *Head;//这里我们将尾指针指向头指针//
p = (*Head);
while (p->next)
{
p = p->next;
}
p->next = newNode;
return 0;
}输出代码：
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i = 0;
p = Head->next;
if (p == Head)
{
printf("链表为空！\n");
return;
}
while (p != Head)//循环体//
{
printf("Node[%d]. = %d\n", ++i, p->data);
p = p->next;
}
}最后我们输出结果：
4.循环链表查找值为x的元素，返回位置i
int find(SingleLinkList *Head, DataType x)
{
int i;
SingleLinkNode *p;
i = 1;
p = Head->next;
while (p!= Head && p->data != x)
{
i++;
p = p->next;
}
if (p->next == Head)
{
return 0;
}
else
{
return i;
}
}结果如下：
5.输出循环表长度：
int length(SingleLinkList *Head)
{
int len = 0;
SingleLinkNode *p;
p = Head->next;
while(p!=Head)
{
len++;
p = p->next;
}
return len;
}结果如下：
2.实践例题 （一元多项式加法运算）
代码如下：
#include <stdio.h>
typedef struct node//一元多项式定义
{
float coef; // 系数
int expn; // 指数
struct node *next; // 后继
} pnode, *polynomial; // 一元多项式的创建
polynomial createpolyn(polynomial p, int m)
{
int i;
polynomial q, pre, s; // 节点 q，pre，s
p = (polynomial)malloc(sizeof(pnode)); // 生成新节点
p->next = 0; // 先建立一个头节点的单链表
p->expn = -1; // 头节点指数值设为-1
for (i = 0; i < m; i++) // 依次输入m个非零值
{
s = (polynomial)malloc(sizeof(pnode)); // 生成新节点
printf("输入系数和指数：");
scanf("%f%d", &s->coef, &s->expn); // 输入系数和指数
pre = p; // pre来保存q的前驱
q = p->next; // q初值为首节点
while (q && q->expn <= s->expn) // 找到第一个大于输入项指数的项q
{
pre = q;
q = q->next;
}
s->next = q;pre->next = s; // 将输入项s，插入到q和pre之间
}
printf("--创建成功--\n");
return p;
}// 一元多项式打印
void pri(polynomial p)
{
polynomial q;
int id = 1;
q = p->next; // 第一项（首结点）
printf("加法运算后结果为:\n");
while (q)
{
printf("第%d个结点：系数%f,指数%d\n", id, q->coef, q->expn); // 结点后移
q = q->next;
id++;
} // 一元多项式相加
return ;
}
polynomial addpolyn(polynomial pa, polynomial pb)
{
polynomial p1, p2, p3, q;
int sum; // 系数和 sum
p1 = pa->next;p2 = pb->next;
p3 = pa; // p3 指向和多项式的当前结点
while (p1 && p2) // p1和p2均非空
{
if (p1->expn == p2->expn) // 指数相同
{
sum = p1->coef + p2->coef; // sum 保存两项的系数和
if (sum) // 系数和不为0
{
p1->coef = sum; // 修改结点p1的系数值
p3->next = p1;
p3 = p1; // 将修改后的结点p1链在p3之后
p1 = p1->next; // p1 指向后一项
q = p2;
p2 = p2->next;free(q); // 删除pb当前结点q
}
else // 系数和为0
{
q = p1;
p1 = p1->next;free(q); // 删除pa当前结点pl
q = p2;
p2 = p2->next;
free(q); // 删除pb当前结点p2
}
}
else
{
if (p1->expn <= p2->expn) // pa当前结点p1的指数值小
{
p3->next = p1; // 将p1链在p3之后
p3 = p1; // p3 指向pl
p1 = p1->next; // p1 指向后一场
}
else
{
p3->next = p2; // pb当前结点p2的指数值小
p3 = p2; // 将p2链接在p3之后
p2 = p2->next; // p2指向后一项
}
}
}
p3->next = p1 ? p1 : p2; // 插入非空多项式的剩余段
free(pb); // 释放pb的头结点
return pa; // 返回和多项式
}
main()
{
printf("==================一元多项式演示程序（由scd完成）==================\n\n\n\n");
int m;
polynomial pa, pb, pc; // 声明一元多项式
printf("==================创建一元多项式==================\n");
printf("创建 A 项数:\n");
scanf("%d", &m); // 创建pa项数
pa = createpolyn(pa, m); // 创建一元多项式pa
printf("创建 B 项数:\n");
scanf("%d", &m); // 创建pb项数
pb = createpolyn(pb, m); // 创建一元多项式pb
printf("==================一元多项式相加==================\n");
pc = addpolyn(pa, pb); // 一元多项式相加
pri(pc); // 打印一元多项式
printf("=======================END=======================\n");
}
807
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
