数据结构第二章-线性表

第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表示已经达到表尾

Alt

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;
}
可用SLinkList定义“一个长度为MaxSize的Node型数组”
2.6.2 基本操作实现
  • 初始化静态链表:把a[0]next设为-1,把其他结点的next设为-2来表示结点空闲

  • 查找:从头结点出发挨个往后遍历结点

  • 插入位序为i的结点:

    • 找到一个空的结点,存入数据元素
    • 从头结点出发找到位序为i-1的结点
    • 修改新结点的next
    • 修改i-1号结点的next
  • 删除某个结点:

    • 从头结点出发找到前驱结点
    • 修改前驱结点的游标
    • 被删除结点next设为-2
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值