第2章 : 线性表
1 顺序表的实现–静态分配
1.1 顺序表的实现–静态分配
#define MaxSize 10 //定义最大长度
typedef struct{
ElemType data[MaxSize]; //用静态的“数组”存放数据元素
int length; //顺序表的当前长度
}Sqlist; //数据表的类型定义(静态分配方式)
初始化一个顺序表
#include<stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct{
int data[MaxSize]; //用静态的“数组”存放数据元素
int length; //顺序表的当前长度
}Sqlist; //数据表的类型定义(静态分配方式)
//基本操作
void Initlist(Sqlist &L){
for (int i = 0;i < MaxSize;i++){
L.data[i] = 0;
L.length = 0;
}
}
int main(){
Sqlist L; //声明一个顺序表
Initlist(L); //初始化顺序表
for(int i = 0;i < MaxSize;i++){
printf("data[%d]=%d\n",i,L.data[i]);
}
return 0;
}
1.2 顺序表的实现–动态分配
先让p和data指向同一片存储空间,然后用L.data开辟一块新空间,最后把p的数据复制到新区域,最后释放p指针
#include<stdio.h>
#include<stdlib.h>
#define InitSize 10 //定义最大长度
typedef struct{
int *data; //指示动态分配数组的指针
int MaxSize; //顺序表的最大容量
int length; //顺序表的当前长度
}Seqlist; //数据表的类型定义(动态分配方式)
//基本操作
void Initlist(Seqlist &L){
L.data = (int *)malloc(InitSize*sizeof(int));
L.length = 0;
L.MaxSize = InitSize;
}
//增加动态数组的长度
void IncreaseSize(Seqlist &L,int len){
int *p = L.data;
L.data = (int *)malloc((L.MaxSize+len)*sizeof(int));
for(int i= 0 ;i <L.length;i++){
L.data[i] = p[i]; //将数据复制到新区域
}
L.MaxSize = L.MaxSize + len;
free(p);
}
int main(){
Seqlist L; //声明一个顺序表
Initlist(L); //初始化顺序表
IncreaseSize(L,5);
return 0;
}
1.3 顺序表的基本操作–插入
#include<stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct{
int data[MaxSize]; //用静态的“数组”存放数据元素
int length; //顺序表的当前长度
}Sqlist; //数据表的类型定义(静态分配方式)
//基本操作
void Listinit(Sqlist &L.int i,int e){
for (int j = L.length;j>=i;j--){ //将第i个元素及之后的元素后移
L.data[j] = L.data[j-1];
}
L.data[i-1] = e; //在位置i处放e
L.length++; //长度加1
}
int main(){
Sqlist L; //声明一个顺序表
Initlist(L); //初始化顺序表
ListInsert(L,3,3);
return 0;
}
1.4 顺序表的基本操作–删除
bool ListDelete(SqList &L,int i,int &e){
if(i<1||i>L.length)
return false;
e = L.data[i-1];
for(int j = i;j < L.length;j++)
L.data[j-1] = L.data[j];
L.length--;
return true;
}
int main(void){
Sqlist L;
InitList(L);
int e = -1;
if(ListDelete(L,3,e))
printf("已删除第三个元素,删除元素值为=%d\n",e);
else
printf("位序i不合法,删除失败\n");
return 0;
}
1.5 顺序表的按值查找
#include<stdio.h>
#include<stdlib.h>
#define InitSize 10 //定义最大长度
typedef struct{
int *data; //指示动态分配数组的指针
int MaxSize; //顺序表的最大容量
int length; //顺序表的当前长度
}Seqlist; //数据表的类型定义(动态分配方式)
int LocateElem(Seqlist L,int e){
for(int i = 0;i <L.length;i++)
if(L.data[i] == e)
return i+1; //数组下标为i的元素值为e,返回其位序i+1
return 0;
}
注意,在c语言中不能直接用==
来直接判断两个结构体是否相等,要分别比较其元素
2 链表
2.1 单链表的定义
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode,*LinkList; //*LinkList是指向struct LNode的指针
要声明单链表时,只需声明一个头指针L,指向单链表的第一个节点
LNode *L;
或者 LinkList L;
struct LNode *p = (struct LNode*)malloc(sizeof(struct LNode));
LNode *强调返回的是一个结点,LinkList强调这是一个单链表
LNode * GetElem(LinkList L,int i){
int j = 1;
if(i == 0)
return L;
if(i < 1)
return NULL;
while(p!=NULL && j < i){
p = p->next;
j++;
}
return p;
}
2.1.1 不带头结点的单链表
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode ,*LinkList; //*LinkList是指向struct LNode的指针
bool InitList(LinkList &L){
L = NULL;
return true;
}
void test(){
LinkList L;
InitList(L);
}
2.1.2 带头结点的单链表
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode ,*LinkList; //*LinkList是指向struct LNode的指针
bool InitList(LinkList &L){
L = (LNode *) malloc(sizeof(LNode)); //分配一个头结点
if(L == NULL)
return false;
L->next = NULL;
return true;
}
void test(){
LinkList L;
InitList(L);
}
2.2 单链表的插入删除
2.2.1 按位序插入
在第i个位置插入元素e(带头结点)
#include <stdlib.h>
typedef int ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L,int i,ElemType e){
if(i < 1)
return false;
LNode *p; //指针p指向当前扫描到的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点,头结点是第0个结点(不存数据)
while(p != NULL && j < i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
if(p == NULL)
return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
return true; //插入成功
}
不带头结点
#include <stdlib.h>
typedef int ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L,int i,ElemType e){
if(i < 1)
return false;
if(i == 1){
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = L;
L = s;
return true;
}
LNode *p; //指针p指向当前扫描到的结点
int j = 1; //当前p指向的是第几个结点
p = L; //L指向头结点,头结点是第0个结点(不存数据)
while(p != NULL && j < i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
return InsertNextNode(p,e);
}
bool InsertNextNode(LNode *p,ElemType e){
if(p == NULL)
return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
return true; //插入成功
}
2.2.2 后插操作
bool InsertNextNode(LNode *p,ElemType e){
if(i < 1)
return false;
LNode *p; //指针p指向当前扫描到的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点,头结点是第0个结点(不存数据)
while(p != NULL && j < i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
if(p == NULL)
return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
if(s == NULL)
return false;
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
2.2.3 前插操作
在p结点之前插入元素e,可通过将p结点的后插操作,并把p结点的值赋给后继结点s,将e的值赋给p结点,即可实现前插操作
bool InsertPriorNode(LNode *p,ElemType e){
if(p == NULL)
return false;
LNode *s = (LNode *)malloc(sizeof(LNode));
if(s == NULL)
return false;
s->next = p->next;
p->next = s;
s->data = p->data;
p->data = e;
return true;
}
2.2.4 按位序删除(带头结点)
bool ListDelete(LinkList &L,int i,ElemType &e){
if(i < 1)
return false;
LNode *p; //指针p指向当前扫描到的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点,头结点是第0个结点(不存数据)
while(p != NULL && j < i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
if(p == NULL)
return false;
if(p->next == NULL)
return false;
LNode *q = p->next;
e = q->data;
p->next = q->next;
free(q);
return true;
}
2.2.5 删除指定结点
但是这段代码在处理链表最后一个结点时,由于最后一个结点指向的是NULL
,因此,没有data
域,所以还是从头找到尾稳妥
bool DeleteNode(LNode *p){
if(p == NULL)
return false;
LNode *q = p->next;
p->data = p->next->data;
p->next = q->next;
free(q);
return false;
}
2.2.6 单链表查找
按位查找
LNode * GetElem(LinkLisk L,int i){
if(i<0)
return NULL;
LNode *p;
int j = 0;
p = L;
while(p!=NULL && j = i){
p = p->next;
j++;
}
return p;
}
按值查找
LNode * LocateElem(LinkLisk L,int e){
LNode *p = L->next;
while(p != NULL && p->data != e){
p = p->next;
}
return p;
}
求表的长度
int Length(LinkList L){
int len = 0;
LNode *p = L;
while(p->next != NULL){
p = p->next;
len++;
}
return len;
}
2.3 建立单链表
2.3.1 尾插法建立单链表:
注意,此处函数类型为LinkList
,且刚开始链表无内容,r
指向的就是L
的头结点,然后每次申请一个新的结点s
,将其插在r
的后面,最后修改指针,让r
等于s
即实现了尾插操作,最后让r
指向NULL
,就是要保证r
永远指向最后一个结点
LinkList List_TailInsert(LinkList &L){ //正向建立单链表
int x;
L = (LinkList) malloc(sizeof(LNode));
LNode *s,*r = L;
scanf("%d",&x);
while(x != 9999){
s = (LNode*) malloc(sizeof(LNode));
s->data = x;
r->next = s;
r = s;
scanf("%d",&x);
}
r->next = NULL;
return L;
}
2.3.2 头插法建立单链表:
LinkList List_HeadInsert(LinkList &L){ //逆向建立单链表
LNode *s;
int x;
L = (LinkList) malloc(sizeof(LNode)); //创建头结点
L->next = NULL; //初始为空链表,为了防止头结点指向其他数据域
scanf("%d",&x);
while(x != 9999){
s = (LNode*) malloc(sizeof(LNode)); //创建新结点
s->data = x;
s->next = L->next;
L->next = s;
scanf("%d",&x);
}
return L;
}
2.4 双链表
2.4.1 结点类型描述:
typedef struct DNode //定义双链表结点类型
{
ElemType data; //数据域
struct DNode *prior,*next; //前驱和后继指针
}DNode , *DLinkList;
2.4.2 双链表的初始化
typedef struct DNode //定义双链表结点类型
{
ElemType data; //数据域
struct DNode *prior,*next; //前驱和后继指针
}DNode , *DLinkList;
bool InitDLinkList(DLinkList &L){
L = (DNode *) malloc(sizeof(DNode));
if(L == NULL)
return false;
L->prior = NULL;
L->next = NULL;
return true;
}
void testDLinkList(){
DLinkList L;
InitDLinkList(L);
}
//判断双链表是否为空
bool Empty(DLinkList L){
if(L->next == NULL)
return true;
else
return false;
}
2.4.3 双链表的插入
bool InsertNextDNode(DNode *p,DNode *s){
if(p == NULL || s ==NULL)
return false;
s->next = p->next; //将结点*s插入到结点*p之后
if(p->next != NULL) //如果p有后继结点
p->next->prior = s;
s->prior = p;
p->next = s;
}
2.4.4 双链表的删除
bool DeleteNextDNode(DNode *p){ //删除p的后继结点
if(p == NULL)
return false;
DNode *q = p->next;
if(q == NULL)
return false;
p->next = q->next;
if(q->next != NULL) //为了防止q结点后为空,导致指向前向指针出错
q->next->prior = p;
free(q);
return true;
}
void DestroyList(DLinkList &L){
//循环释放各个数据结点
while(L->next != NULL)
DeleteNextDNode(L);
free(L);
L = NULL;
}
2.4.5 双链表的遍历
2.4.5.1 后向遍历
while(p != NULL){
p = p->next;
}
2.4.5.2 前向遍历
while(p != NULL){
p = p->prior
}
2.4.5.3 前向遍历(跳过头结点)
while(p->prior != NULL){
p = p->prior;
}
2.5 循环链表
2.5.1 循环单链表
初始化循环单链表:
bool InitList(LinkList &L){
L = (LNode *) malloc(sizeof(LNode));
if(L == NULL)
return false;
L->next = L;
return true;
}
判断循环链表是否为空:
bool Empty(LinkList L){
if(L->next ==L)
return true;
else
return false
}
2.5.2 循环双链表
表头结点的prior
指向表尾结点
表尾结点的next
指向头结点
bool InitDLinkList1(DLinkList &L){
L = (DNode *) malloc(sizeof(DNode));
if(L == NULL)
return false;
L->prior = L;
L->next = L;
return true;
}
void testDLinkList1(){
DLinkList L;
InitDLinkList1(L);
}
插入:
bool InsertNextDNode(DNode *p,DNode *s){
s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;
}
删除:
p->next = q->next;
q->next->prior = p;
free(q);
2.6 静态链表
分配一整片连续的内存空间,各个结点集中安置
0号结点充当”头结点“,游标充当”指针“,指向下一个结点的数组下标,游标为-1
表示已经达到表尾
2.6.1 定义静态链表:
#define MaxSize 10 //静态链表的最大长度
struct Node{ //静态链表结构类型的定义
ElemType data; //存储数据元素
int next; //下一个元素的数组下标
};
void testSLinkList(){
struct Node a[MaxSize]; //数组a作为静态链表
}
#define MaxSize 10 //静态链表的最大长度
typedef struct{ //静态链表结构类型的定义
ElemType data; //存储数据元素
int next; //下一个元素的数组下标
}SLinkList[MaxSize];
等价于
#define MaxSize 10 //静态链表的最大长度
struct Node{ //静态链表结构类型的定义
ElemType data; //存储数据元素
int next; //下一个元素的数组下标
};
typedef struct Node SLinkList[MaxSize];
void testSLinkList(){
SLinkList a;
}
2.6.2 基本操作实现
-
初始化静态链表:把
a[0]
的next
设为-1,把其他结点的next
设为-2来表示结点空闲 -
查找:从头结点出发挨个往后遍历结点
-
插入位序为i的结点:
- 找到一个空的结点,存入数据元素
- 从头结点出发找到位序为i-1的结点
- 修改新结点的next
- 修改i-1号结点的next
-
删除某个结点:
- 从头结点出发找到前驱结点
- 修改前驱结点的游标
- 被删除结点next设为-2