单链表
1、单链表的定义:
与顺序表相同,链表也是一种线性表。它的数据的逻辑组织是一维的,而与顺序表不同的是,链表的物理存储结构是用一组地址任意的存储单元存储数据的,可以连续也可以不连续(但只是逻辑上,物理上不一定来连续结点)。
也就是说,它不像顺序表那样占据一段连续的内存空间,而是将存储单元分散在内存的任意地址上,为了正确表示逻辑关系,存储每个节点的同时,还必须存储指示其后继的地址信息,这个信息为指针或者链。
单链表结点(Node):数据域+指针域
数据域存放用户需要的实际数据,指针域存放下一个结点的地址
typedef int DataType;
/*简单链表的定义*/
typedef struct node
{
DataType data; /*数据域*/
struct node *next; /*指针域*/
}SingleLinkList, SingleLinkNode;
结点空间开辟和结点空间释放
生成结点变量的标准函数
p = (struct Lnode *)malloc(sizeof(struct Lnode));
结点空间开辟:
例如:执行ListNode*p 后,该指针变量指向的结点变量并未开辟空间程序执行过程中,当需要时才产生,需要执行 p=(ListNode *)malloc(sizeof(ListNode)后配一个类型为ListNode的结点变量的空间。
结点空间释放:
当p 指向的结点变量不再需要的时候,可以通过执行 free(p)释放
单链表特点:
- 只要获得链表的头结点,就可以通过指针遍历整条链表
- 每个结点的类型是LNode,*LinkList是指向LNode类型数据的指针类型定义。所以 LNode *L 与 LinkList L; 是等价的。
- 有一个head指针变量,存放头结点地址,称为头指针
- 链表的使用,可以使程序的内存利用率和时间效率大大提高。
- 链表各结点间顺序由指针域next来确定
2、运算(概述)
初始化、查找、(头尾)插入、删除,输出
3、代码的实现
初始化的代码与运行情况
/*1. 初始化*/
int init(SingleLinkList **Head)
{
if(1)
{
/*申请内存*/
(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
/*判断内存申请是否成功*/
if(*Head == NULL)
{
printf("申请内存错误, 初始化失败![100001]\n");
return 100001;
}
(*Head)->next = NULL;
/*循环链表*/
/*
(*Head)->next = *Head;
*/
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;
}
查找
/*5. 查找值为x的元素,返回位置i */
int find(SingleLinkList *Head, DataType x)
{
int i;
SingleLinkNode *p;
i = 1;
p = Head->next;
while(p && p->data != x) /*while( p!= Head && p->data != x) */
{
i++;
p = p->next;
}
if(!p) /* if(p->next == Head) */
{
return 0;
}
else
{
return i;
}
}
链表长度
/*4. 链表长度*/
int length(SingleLinkList *Head)
{
int len=0;
SingleLinkNode *p;
p = Head->next;
while(p) /* while(p!=Head) */
{
len++;
p = p->next;
}
return len;
}
输出链表
/*6.输出链表*/
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i=0;
p = Head->next;
if(!p) /* if(p!=Head) */
{
printf("链表为空!\n");
return;
}
while(p) /* while(p!=Head) */
{
printf("Node[%d]. = %d\n", ++i, p->data);
p = p->next;
}
}
删除链表
/*3. 删除元素, 删除值为x的元素*/
int delete(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;
}
4、完整的Demo
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 < 1000; 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~6,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 (!delete (&Head, x))
{
printf("元素x【%d】已删除!\n", x);
}
break;
case 10:
printf(" 本程序为链表的演示程序,由邓徳权设计开发,程序完成了。。。。功能!。。。\n");
break;
}
} while (cmd != 0);
system("pause");
return 0;
}
SingleLinkList.c
/*
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;
/*循环链表*/
/*
(*Head)->next = *Head;
*/
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;
/*
循环链表
newNode->next = *Head;
*/
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 delete(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) /*while( p!= Head && p->data != x) */
{
i++;
p = p->next;
}
if(!p) /* if(p->next == Head) */
{
return 0;
}
else
{
return i;
}
}
/*4. 链表长度*/
int length(SingleLinkList *Head)
{
int len=0;
SingleLinkNode *p;
p = Head->next;
while(p) /* while(p!=Head) */
{
len++;
p = p->next;
}
return len;
}
/*6.输出链表*/
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i=0;
p = Head->next;
if(!p) /* if(p!=Head) */
{
printf("链表为空!\n");
return;
}
while(p) /* while(p!=Head) */
{
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 delete(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[] = "DDQ乱写代码之传奇\n\n"
"DDQ乱写代码之传奇\n\n "
"DDQ乱写代码之传奇\n\n"
"(======----0---=======)\n";
循环链表
循环链表的定义
- 循环链表的任意元素都有一个前驱和一个后继,所有数据元素在关系上构成逻辑上的环。
- 循环链表是一种特殊的单链表,尾结点的指针指向首结点的地址。
- 每个结点只存储了向后的指针,到了尾标志就停止了向后链的操作,这样知道某个结点却无法找到它的前驱结点
- 将单链表中的终端点的指针由空指针改为指向头结点,是循环链表
特点:
优点:链表的插入操作更快 ,无需预先分配内存空间 缺点:失去了随机读取的优点(需要从头节点开始依次遍历,直到找到目标节点。),内存消耗较大(每个节点都需要存储指向下一个节点的指针
代码的实现
初始化。
与单链表一样。如果频繁使用删除与插入,适合用链表作为存储结构
/*1. 初始化*/
int init(SingleLinkList **Head)
{
if(1)
{
/*申请内存*/
(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
/*判断内存申请是否成功*/
if(*Head == NULL)
{
printf("申请内存错误, 初始化失败![100001]\n");
return 100001;
}
// (*Head)->next = NULL;
/*循环链表*/
(*Head)->next = *Head;
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;
}
删除
/*3. 删除元素, 删除值为x的元素*/
int delete(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;
}
运行结果
初始化
插入
删除
完整代码
整体与上面单链表几乎一样,唯一不一样的是在SingleLinkList.c中54行-57行,讲述了终端结点的指针域改为指向表结头点
扩展:一元多项式设计加法运算
#include <stdio.h>
#include<stdlib.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("==================一元多项式演示程序(由DDQ完成)==================\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");
}
运行结果:
5、小结
写完终于知道CSDN为什么这么多的垃圾参考资料,全都是因为有像鄙人这样的学生在疯狂输出,
面向百度和广大网友的编写,真是庆幸现在有大佬在网上输出一些像诗篇的文章,救人于水火之中
6、参考文献
李刚的数据结构C语言版本