(一)循环链表

存储类型

typedef struct LNode
{
ElemType data;
struct LNode *next;
};
typedef struct LNode *LinkList; /* 另一种定义

和单链表的不同是:最后一个节点的next域指向头节点:

void InitList(LinkList &L)
{ // 操作结果:构造一个空的线性表L
L=(LinkList)malloc(sizeof(LNode)); // 产生头结点,并使L指向此头结点
if(!L) // 存储分配失败
exit(OVERFLOW);
L->next=L; // 指针域指向头结点
} void DestroyList(LinkList &L)
{ // 操作结果:销毁线性表L
LinkList q,p=L->next; // p指向头结点
while(p!=L) // 没到表尾
{
q=p->next;
free(p);
p=q;
}
free(L);
L=NULL;
} void ClearList(LinkList &L) // 改变L
{ // 初始条件:线性表L已存在。操作结果:将L重置为空表
LinkList p,q;
L=L->next; // L指向头结点
p=L->next; // p指向第一个结点
while(p!=L) // 没到表尾
{
q=p->next;
free(p);
p=q;
}
L->next=L; // 头结点指针域指向自身
} Status ListEmpty(LinkList L)
{ // 初始条件:线性表L已存在。操作结果:若L为空表,则返回TRUE,否则返回FALSE
if(L->next==L) // 空
return TRUE;
else
return FALSE;
} int ListLength(LinkList L)
{ // 初始条件:L已存在。操作结果:返回L中数据元素个数
int i=0;
LinkList p=L->next; // p指向头结点
while(p!=L) // 没到表尾
{
i++;
p=p->next;
}
return i;
} Status GetElem(LinkList L,int i,ElemType &e)
{ // 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR
int j=1; // 初始化,j为计数器
LinkList p=L->next->next; // p指向第一个结点
if(i<=0||i>ListLength(L)) // 第i个元素不存在
return ERROR;
while(j<i)
{ // 顺指针向后查找,直到p指向第i个元素
p=p->next;
j++;
}
e=p->data; // 取第i个元素
return OK;
} int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件:线性表L已存在,compare()是数据元素判定函数
// 操作结果:返回L中第1个与e满足关系compare()的数据元素的位序。
// 若这样的数据元素不存在,则返回值为0
int i=0;
LinkList p=L->next->next; // p指向第一个结点
while(p!=L->next)
{
i++;
if(compare(p->data,e)) // 满足关系
return i;
p=p->next;
}
return 0;
}
Status ListInsert(LinkList &L,int i,ElemType e) // 改变L
{ // 在L的第i个位置之前插入元素e
LinkList p=L->next,s; // p指向头结点
int j=0;
if(i<=0||i>ListLength(L)+1) // 无法在第i个元素之前插入
return ERROR;
while(j<i-1) // 寻找第i-1个结点
{
p=p->next;
j++;
}
s=(LinkList)malloc(sizeof(LNode)); // 生成新结点
s->data=e; // 插入L中
s->next=p->next;
p->next=s;
if(p==L) // 改变尾结点
L=s;
return OK;
} Status ListDelete(LinkList &L,int i,ElemType &e) // 改变L
{ // 删除L的第i个元素,并由e返回其值
LinkList p=L->next,q; // p指向头结点
int j=0;
if(i<=0||i>ListLength(L)) // 第i个元素不存在
return ERROR;
while(j<i-1) // 寻找第i-1个结点
{
p=p->next;
j++;
}
q=p->next; // q指向待删除结点
p->next=q->next;
e=q->data;
if(L==q) // 删除的是表尾元素
L=p;
free(q); // 释放待删除结点
return OK;
} void ListTraverse(LinkList L,void(*vi)(ElemType))
{ // 初始条件:L已存在。操作结果:依次对L的每个数据元素调用函数vi()
LinkList p=L->next->next; // p指向首元结点
while(p!=L->next) // p不指向头结点
{
vi(p->data);
p=p->next;
}
printf("\n");
}

双向链表

存储结构

 typedef struct DuLNode
{
ElemType data;
DuLNode *prior,*next;
}DuLNode,*DuLinkList;

基本操作

void InitList(DuLinkList &L)
{ // 产生空的双向循环链表L
L=(DuLinkList)malloc(sizeof(DuLNode));
if(L)
L->next=L->prior=L;
else
exit(OVERFLOW);
} void DestroyList(DuLinkList &L)
{ // 操作结果:销毁双向循环链表L
DuLinkList q,p=L->next; // p指向第一个结点
while(p!=L) // p没到表头
{
q=p->next;
free(p);
p=q;
}
free(L);
L=NULL;
} void ClearList(DuLinkList L) // 不改变L
{ // 初始条件:L已存在。操作结果:将L重置为空表
DuLinkList q,p=L->next; // p指向第一个结点
while(p!=L) // p没到表头
{
q=p->next;
free(p);
p=q;
}
L->next=L->prior=L; // 头结点的两个指针域均指向自身
} Status ListEmpty(DuLinkList L)
{ // 初始条件:线性表L已存在。操作结果:若L为空表,则返回TRUE,否则返回FALSE
if(L->next==L&&L->prior==L)
return TRUE;
else
return FALSE;
} int ListLength(DuLinkList L)
{ // 初始条件:L已存在。操作结果:返回L中数据元素个数
int i=0;
DuLinkList p=L->next; // p指向第一个结点
while(p!=L) // p没到表头
{
i++;
p=p->next;
}
return i;
} Status GetElem(DuLinkList L,int i,ElemType &e)
{ // 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR
int j=1; // j为计数器
DuLinkList p=L->next; // p指向第一个结点
while(p!=L&&j<i) // 顺指针向后查找,直到p指向第i个元素或p指向头结点
{
p=p->next;
j++;
}
if(p==L||j>i) // 第i个元素不存在
return ERROR;
e=p->data; // 取第i个元素
return OK;
} int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件:L已存在,compare()是数据元素判定函数
// 操作结果:返回L中第1个与e满足关系compare()的数据元素的位序。
// 若这样的数据元素不存在,则返回值为0
int i=0;
DuLinkList p=L->next; // p指向第1个元素
while(p!=L)
{
i++;
if(compare(p->data,e)) // 找到这样的数据元素
return i;
p=p->next;
}
return 0;
} DuLinkList GetElemP(DuLinkList L,int i) // 另加
{ // 在双向链表L中返回第i个元素的地址。i为0,返回头结点的地址。若第i个元素不存在,
// 返回NULL(算法2.18、2.19要调用的函数)
int j;
DuLinkList p=L; // p指向头结点
if(i<0||i>ListLength(L)) // i值不合法
return NULL;
for(j=1;j<=i;j++)
p=p->next;
return p;
} Status ListInsert(DuLinkList L,int i,ElemType e)
{ // 在带头结点的双链循环线性表L中第i个位置之前插入元素e,i的合法值为1≤i≤表长+1
// 改进算法2.18,否则无法在第表长+1个结点之前插入元素
DuLinkList p,s;
if(i<1||i>ListLength(L)+1) // i值不合法
return ERROR;
p=GetElemP(L,i-1); // 在L中确定第i个元素前驱的位置指针p
if(!p) // p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱)
return ERROR;
s=(DuLinkList)malloc(sizeof(DuLNode));
if(!s)
return OVERFLOW;
s->data=e;
s->prior=p; // 在第i-1个元素之后插入
s->next=p->next;
p->next->prior=s;
p->next=s;
return OK;
} Status ListDelete(DuLinkList L,int i,ElemType &e) // 算法2.19
{ // 删除带头结点的双链循环线性表L的第i个元素,i的合法值为1≤i≤表长
DuLinkList p;
if(i<1) // i值不合法
return ERROR;
p=GetElemP(L,i); // 在L中确定第i个元素的位置指针p
if(!p) // p=NULL,即第i个元素不存在
return ERROR;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
free(p);
return OK;
} void ListTraverse(DuLinkList L,void(*visit)(ElemType))
{ // 由双链循环线性表L的头结点出发,正序对每个数据元素调用函数visit()
DuLinkList p=L->next; // p指向头结点
while(p!=L)
{
visit(p->data);
p=p->next;
}
printf("\n");
} void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))
{ // 由双链循环线性表L的头结点出发,逆序对每个数据元素调用函数visit()。另加
DuLinkList p=L->prior; // p指向尾结点
while(p!=L)
{
visit(p->data);
p=p->prior;
}
printf("\n");
}

带头节点的线性链表

存储结构

 typedef struct LNode // 结点类型
{
ElemType data;
LNode *next;
}*Link,*Position; struct LinkList // 链表类型
{
Link head,tail; // 分别指向线性链表中的头结点和最后一个结点
int len; // 指示线性链表中数据元素的个数
};

基本操作

void MakeNode(Link &p,ElemType e)
{ // 分配由p指向的值为e的结点。若分配失败,则退出
p=(Link)malloc(sizeof(LNode));
if(!p)
exit(ERROR);
p->data=e;
} void FreeNode(Link &p)
{ // 释放p所指结点
free(p);
p=NULL;
} void InitList(LinkList &L)
{ // 构造一个空的线性链表L
Link p;
p=(Link)malloc(sizeof(LNode)); // 生成头结点
if(p)
{
p->next=NULL;
L.head=L.tail=p;
L.len=0;
}
else
exit(ERROR);
} void ClearList(LinkList &L)
{ // 将线性链表L重置为空表,并释放原链表的结点空间
Link p,q;
if(L.head!=L.tail) // 不是空表
{
p=q=L.head->next;
L.head->next=NULL;
while(p!=L.tail)
{
p=q->next;
free(q);
q=p;
}
free(q);
L.tail=L.head;
L.len=0;
}
} void DestroyList(LinkList &L)
{ // 销毁线性链表L,L不再存在
ClearList(L); // 清空链表
FreeNode(L.head);
L.tail=NULL;
L.len=0;
} void InsFirst(LinkList &L,Link h,Link s) // 形参增加L,因为需修改L
{ // h指向L的一个结点,把h当做头结点,将s所指结点插入在第一个结点之前
s->next=h->next;
h->next=s;
if(h==L.tail) // h指向尾结点
L.tail=h->next; // 修改尾指针
L.len++;
} Status DelFirst(LinkList &L,Link h,Link &q) // 形参增加L,因为需修改L
{ // h指向L的一个结点,把h当做头结点,删除链表中的第一个结点并以q返回。
// 若链表为空(h指向尾结点),q=NULL,返回FALSE
q=h->next;
if(q) // 链表非空
{
h->next=q->next;
if(!h->next) // 删除尾结点
L.tail=h; // 修改尾指针
L.len--;
return OK;
}
else
return FALSE; // 链表空
} void Append(LinkList &L,Link s)
{ // 将指针s(s->data为第一个数据元素)所指(彼此以指针相链,以NULL结尾)的
// 一串结点链接在线性链表L的最后一个结点之后,并改变链表L的尾指针指向新的尾结点
int i=1;
L.tail->next=s;
while(s->next)
{
s=s->next;
i++;
}
L.tail=s;
L.len+=i;
} Position PriorPos(LinkList L,Link p)
{ // 已知p指向线性链表L中的一个结点,返回p所指结点的直接前驱的位置。若无前驱,则返回NULL
Link q;
q=L.head->next;
if(q==p) // 无前驱
return NULL;
else
{
while(q->next!=p) // q不是p的直接前驱
q=q->next;
return q;
}
} Status Remove(LinkList &L,Link &q)
{ // 删除线性链表L中的尾结点并以q返回,改变链表L的尾指针指向新的尾结点
Link p=L.head;
if(L.len==0) // 空表
{
q=NULL;
return FALSE;
}
while(p->next!=L.tail)
p=p->next;
q=L.tail;
p->next=NULL;
L.tail=p;
L.len--;
return OK;
} void InsBefore(LinkList &L,Link &p,Link s)
{ // 已知p指向线性链表L中的一个结点,将s所指结点插入在p所指结点之前,
// 并修改指针p指向新插入的结点
Link q;
q=PriorPos(L,p); // q是p的前驱
if(!q) // p无前驱
q=L.head;
s->next=p;
q->next=s;
p=s;
L.len++;
} void InsAfter(LinkList &L,Link &p,Link s)
{ // 已知p指向线性链表L中的一个结点,将s所指结点插入在p所指结点之后,
// 并修改指针p指向新插入的结点
if(p==L.tail) // 修改尾指针
L.tail=s;
s->next=p->next;
p->next=s;
p=s;
L.len++;
} void SetCurElem(Link p,ElemType e)
{ // 已知p指向线性链表中的一个结点,用e更新p所指结点中数据元素的值
p->data=e;
} ElemType GetCurElem(Link p)
{ // 已知p指向线性链表中的一个结点,返回p所指结点中数据元素的值
return p->data;
} Status ListEmpty(LinkList L)
{ // 若线性链表L为空表,则返回TRUE,否则返回FALSE
if(L.len)
return FALSE;
else
return TRUE;
} int ListLength(LinkList L)
{ // 返回线性链表L中元素个数
return L.len;
} Position GetHead(LinkList L)
{ // 返回线性链表L中头结点的位置
return L.head;
} Position GetLast(LinkList L)
{ // 返回线性链表L中最后一个结点的位置
return L.tail;
} Position NextPos(Link p)
{ // 已知p指向线性链表L中的一个结点,返回p所指结点的直接后继的位置。若无后继,则返回NULL
return p->next;
} Status LocatePos(LinkList L,int i,Link &p)
{ // 返回p指示线性链表L中第i个结点的位置,并返回OK,i值不合法时返回ERROR。i=0为头结点
int j;
if(i<0||i>L.len)
return ERROR;
else
{
p=L.head;
for(j=1;j<=i;j++)
p=p->next;
return OK;
}
} Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
{ // 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置,
// 若不存在这样的元素,则返回NULL
Link p=L.head;
do
p=p->next;
while(p&&!(compare(p->data,e))); // 没到表尾且没找到满足关系的元素
return p;
} void ListTraverse(LinkList L,void(*visit)(ElemType))
{ // 依次对L的每个数据元素调用函数visit()
Link p=L.head->next;
int j;
for(j=1;j<=L.len;j++)
{
visit(p->data);
p=p->next;
}
printf("\n");
} void OrderInsert(LinkList &L,ElemType e,int (*comp)(ElemType,ElemType))
{ // 已知L为有序线性链表,将元素e按非降序插入在L中。(用于一元多项式)
Link o,p,q;
q=L.head;
p=q->next;
while(p!=NULL&&comp(p->data,e)<0) // p不是表尾且元素值小于e
{
q=p;
p=p->next;
}
o=(Link)malloc(sizeof(LNode)); // 生成结点
o->data=e; // 赋值
q->next=o; // 插入
o->next=p;
L.len++; // 表长加1
if(!p) // 插在表尾
L.tail=o; // 修改尾结点
} Status LocateElem(LinkList L,ElemType e,Position &q,int(*compare)(ElemType,ElemType))
{ // 若升序链表L中存在与e满足判定函数compare()取值为0的元素,则q指示L中
// 第一个值为e的结点的位置,并返回TRUE;否则q指示第一个与e满足判定函数
// compare()取值>0的元素的前驱的位置。并返回FALSE。(用于一元多项式)
Link p=L.head,pp;
do
{
pp=p;
p=p->next;
}while(p&&(compare(p->data,e)<0)); // 没到表尾且p->data.expn<e.expn
if(!p||compare(p->data,e)>0) // 到表尾或compare(p->data,e)>0
{
q=pp;
return FALSE;
}
else // 找到
{
q=p;
return TRUE;
}
}

数据结构读书笔记(二)(C语言)的更多相关文章

  1. 《Go并发编程实战》读书笔记-初识Go语言

    <Go并发编程实战>读书笔记-初识Go语言 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 在讲解怎样用Go语言之前,我们先介绍Go语言的特性,基础概念和标准命令. 一. ...

  2. ES6读书笔记(二)

    前言 前段时间整理了ES6的读书笔记:<ES6读书笔记(一)>,现在为第二篇,本篇内容包括: 一.数组扩展 二.对象扩展 三.函数扩展 四.Set和Map数据结构 五.Reflect 本文 ...

  3. 【记】《.net之美》之读书笔记(一) C#语言基础

    前言 工作之中,我们习惯了碰到任务就直接去实现其业务逻辑,但是C#真正的一些基础知识,在我们久而久之不去了解巩固的情况下,就会忽视掉.我深知自己正一步步走向只知用法却不知原理的深渊,所以工作之余,一直 ...

  4. 《你必须知道的.NET》读书笔记二:小OO有大原则

    此篇已收录至<你必须知道的.Net>读书笔记目录贴,点击访问该目录可以获取更多内容. 一.单一职责原则 (1)核心思想:一个类最好只做一件事,只有一个引起它变化的原因 (2)常用模式:Fa ...

  5. spring揭秘 读书笔记 二 BeanFactory的对象注册与依赖绑定

    本文是王福强所著<<spring揭秘>>一书的读书笔记 我们前面就说过,Spring的IoC容器时一个IoC Service Provider,而且IoC Service Pr ...

  6. java读书笔记二

    这是我的一些读书笔记: 我研究了一下面向对象: 面向对象符合人类看待事物的一般规律,对象的方法的实现细节是包装的,只有对象方法的实现者了解细节 我觉得面向过程是由过程.步骤.函数组成,过程是核心,面向 ...

  7. spring揭秘 读书笔记 二 BeanFactory的对象注冊与依赖绑定

    本文是王福强所著<<spring揭秘>>一书的读书笔记 我们前面就说过,Spring的IoC容器时一个IoC Service Provider,并且IoC Service Pr ...

  8. 【记】《.net之美》之读书笔记(二) C#中的泛型

    前言 上一篇读书笔记,很多小伙伴说这本书很不错,所以趁着国庆假期,继续我的读书之旅,来跟随书中作者一起温习并掌握第二章的内容吧. 一.理解泛型 1.为什么要使用泛型?-----通过使用泛型,可以极大地 ...

  9. Mastering Web Application Development with AngularJS 读书笔记(二)

    第一章笔记 (二) 一.scopes的层级和事件系统(the eventing system) 在层级中管理的scopes可以被用做事件总线.AngularJS 允许我们去传播已经命名的事件用一种有效 ...

  10. how tomcat works 读书笔记(二)----------一个简单的servlet容器

    app1 (建议读者在看本章之前,先看how tomcat works 读书笔记(一)----------一个简单的web服务器 http://blog.csdn.net/dlf123321/arti ...

随机推荐

  1. SqlSever基础 right函数 从右边开始,截取字符串

    镇场诗:---大梦谁觉,水月中建博客.百千磨难,才知世事无常.---今持佛语,技术无量愿学.愿尽所学,铸一良心博客.------------------------------------------ ...

  2. (原+转)C++中的const修饰符

    const int a; int const a; 这两个写法是等同的,表示a是一个int常量. 简记:const后面是什么就限定什么(因为C++标准规定,const关键字放在类型或变量名之前等价的) ...

  3. [WPF]使用Pack URI路径訪问二进制资源

    一.路径格式定义 完整的URI定义为: pack://application,,,[/可选程序集名称;][可选版本;][目录名称/]文件名 缩略后的写法是: [目录名称/]文件名 二.在XAML代码中 ...

  4. linux 下搭建php环境

    linux 下搭建php环境 1.下载apache (http://httpd.apache.org/download.cgi) 下载php组件 ( http://cn2.php.net/get/ph ...

  5. LVS负载均衡集群

    回顾-Nginx反向代理型负载 负载均衡(load balance)集群,提供了一种廉价.有效.透明的方法,来扩展网络设备和服务器的负载.带宽.增加吞吐量.加强网络数据处理能力.提高网络的灵活性和可用 ...

  6. TensorFlow与caffe中卷积层feature map大小计算

    刚刚接触Tensorflow,由于是做图像处理,因此接触比较多的还是卷及神经网络,其中会涉及到在经过卷积层或者pooling层之后,图像Feature map的大小计算,之前一直以为是与caffe相同 ...

  7. win10下解压版mysql-8.0.12安装教程

    内容转载于:https://blog.csdn.net/hust_hqq/article/details/80572133 在他之上添加了一个:服务名无效的解决方法 1.官网下载安装包 网址:http ...

  8. vijos 1128 N个数选K个数 (DFS )

    从 n 个整数中任选 k 个整数相加,可分别得到一系列的和 要求你计算出和为素数共有多少种 IN4 33 7 12 19 OUT1 # include <iostream> # inclu ...

  9. 算法进阶面试题02——BFPRT算法、找出最大/小的K个数、双向队列、生成窗口最大值数组、最大值减最小值小于或等于num的子数组数量、介绍单调栈结构(找出临近的最大数)

    第二课主要介绍第一课余下的BFPRT算法和第二课部分内容 1.BFPRT算法详解与应用 找到第K小或者第K大的数. 普通做法:先通过堆排序然后取,是n*logn的代价. // O(N*logK) pu ...

  10. 001- CreateProcess failed with error 216 (no message available)错误详解

    问题详解 runnerw.exe: CreateProcess failed with error 216 (no message available) 看描述,创建进程失败,应该是main这个入口文 ...