一、逻辑结构与存储结构
1.逻辑结构（对人友好）
- 集合结构-无关系
- 线性结构-一对一
- 树形结构-一对多
- 图形结构-多对多
2.存储结构（对计算机友好）
- 顺序存储
- 链式存储
- 索引存储
- 散列存储
2.1优缺点
2.1.1.顺序存储
优点：
- 可以实现随机存取
- 每个元素占用最少的空间
缺点：
- 只能使用整块的存储单元，会产生较多的碎片
2.1.2链式存储
优点：
- 充分利用所有的存储单元，不会出现碎片现象
缺点：
- 需要额外的存储空间用来存放下一结点的指针
- 只能实现顺序存取
二、顺序表的初始化及插入操作
代码
#include<stdio.h>
//顺序表的初始化及插入实战
#define MaxSize 50
typedef int ElemType;//让顺序表存储其他类型元素时，可以快速完成修改
typedef struct{
ElemType data[MaxSize];
int length;//顺序表长度
}SqList;
//顺序表的插入，因为L会改变，因此我们这里要用引用，i是插入的位置
bool ListInsert(SqList &L,int i, ElemType element)
{
//判断i是否合法
if(i<1 || i>L.length+1)
{
return false;
}
//如果存储空间满了，不能插入
if(L.length==MaxSize)
{
return false;//没有插入成功
}
//把后面的元素依次往后移动，空出位置，用来放入要插入的元素
for(int j=L.length;j>=i;j--)
{
L.data[j]=L.data[j-1];
}
L.data[i-1]=element;//放入要插入的元素
L.length++;//顺序表长度加一
return true;//插入成功
}
//打印顺序表
void PrintList(SqList L)
{
int i;
for (i = 0; i < L.length; i++)
{
printf("%3d",L.data[i]);//为了打印到同一行
}
printf("\n");
}
int main()
{
SqList L;//定义一个顺序表，顺序表名称L
bool ret;//ret用来装入查看返回值
//手动在顺序表中赋值
L.data[0]=1;
L.data[1]=2;
L.data[2]=3;
L.length=3;//总计三个元素
ret=ListInsert(L,2,60);
if(ret)
{
printf("insert sqlist success\n");
PrintList(L);
}
else
{
printf("insert sqlist failed\n");
}
return 0;
}
输出结果
insert sqlist success
1 60 2 3
三、顺序表的删除及查询操作
在顺序表的初始化及插入操作的基础上完成删除和查询操作
代码
#include<stdio.h>
//顺序表的初始化及插入实战
#define MaxSize 50
typedef int ElemType;//让顺序表存储其他类型元素时，可以快速完成修改
typedef struct{
ElemType data[MaxSize];
int length;//顺序表长度
}SqList;
//顺序表的插入，因为L会改变，因此我们这里要用引用，i是插入的位置
bool ListInsert(SqList &L,int i, ElemType element)
{
//判断i是否合法
if(i<1 || i>L.length+1)
{
return false;
}
//如果存储空间满了，不能插入
if(L.length==MaxSize)
{
return false;//没有插入成功
}
//把后面的元素依次往后移动，空出位置，用来放入要插入的元素
for(int j=L.length;j>=i;j--)
{
L.data[j]=L.data[j-1];
}
L.data[i-1]=element;//放入要插入的元素
L.length++;//顺序表长度加一
return true;//插入成功
}
//打印顺序表
void PrintList(SqList L)
{
int i;
for (i = 0; i < L.length; i++)
{
printf("%3d",L.data[i]);//为了打印到同一行
}
printf("\n");
}
//删除顺序表中的元素，i是要删除的元素的位置，e是为了获取被删除的元素的值
bool ListDelete(SqList &L,int i, ElemType &e)
{
//判断删除的元素的位置是否合法
if(i<1 || i>L.length)
{
return false;//一旦走到return函数就提前结束
}
e=L.data[i-1];//保存要删除的值
int j;
/*方法一：
for(j=i-1;j<L.length-1;j++)
{
L.data[j]=L.data[j+1];
}*/
//方法二：
for(j=i;j<L.length;j++)//往前移动元素
{
L.data[j-1]=L.data[j];
}
L.length--;//顺序表长度减一
return true;
}
//查找某个元素的位置，找到了就会对应位置，没找到就返回0
int LocateElem(SqList L,ElemType element)
{
int i;
for(i=0;i<L.length;i++)
{
if(element==L.data[i])
{
return i+1;//因为i是数组的下标，加一才是顺序表的位置下标
}//若相同元素有多个，修改代码继续查找，本代码只找第一个
}
return 0;//循环结束没找到
}
int main()
{
SqList L;//定义一个顺序表，顺序表名称L
bool ret;//ret用来装入查看返回值
//手动在顺序表中赋值
L.data[0]=1;
L.data[1]=2;
L.data[2]=3;
L.length=3;//总计三个元素
ret=ListInsert(L,2,60);
if(ret)
{
printf("insert sqlist success\n");
PrintList(L);
}
else
{
printf("insert sqlist failed\n");
}
printf("----------------------------\n");
ElemType del;//删除的元素存入del中
ret=ListDelete(L, 1, del);
if(ret)
{
printf("delete sqlist success\n");
printf("del element=%d\n",del);
PrintList(L);//顺序表打印
}
else
{
printf("delete sqlist failed\n");
}
printf("----------------------------\n");
int pos;//存储元素位置
pos=LocateElem(L,60);
if(pos)
{
printf("find this element\n");
printf("element pos=%d\n",pos);
}
else
{
printf("don't find this element\n");
}
return 0;
}
输出结果
insert sqlist success
1 60 2 3
----------------------------
delete sqlist success
del element=1
60 2 3
----------------------------
find this element
element pos=1
四、新建链表
1. 头插法新建链表代码实战流程图
graph LR
A[定义链表头指针]
A-->C[头节点申请空间]
C-->D[scanf读取第一个元素值]
D-->E[开启while循环建立链表]
E-->F[打印链表]
根据流程图来写代码
-
头插法
#include <stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*LinkList;
//LNode*是结构体指针，和LinkList完全等价的
void list_head_insert(LNode* &L)
{
L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
L->next=NULL;
ElemType x;
scanf("%d",&x);
LNode *s;//用来指向申请的新结点
while(x != 9999)
{
s=(LinkList)malloc(sizeof(LNode));
s->data=x;
s->next=L->next;//s的next指向原本链表的第一个结点
L->next=s;//头结点的next，指向新结点
scanf("%d",&x);
}
}
void print_list(LinkList L)
{
L=L->next;
while(L !=NULL )
{
printf("%3d",L->data);
L=L->next;
}
printf("\n");
}
//头插法新建链表
int main() {
LinkList L;//链表头指针，是结构体指针类型
list_head_insert(L);//输入数据可以为3 4 5 7 9999，头插法新建链表
print_list(L);
return 0;
}
测试结果
3 4 5 6 7 9999
7 6 5 4 3
2. 尾插法新建链表代码实战流程图
graph LR
A[定义链表头指针]
A-->C[头节点申请空间]
A-->H[定义尾指针r执行头结点L]
H-->D
C-->D[scanf读取第一个元素值]
D-->E[开启while循环建立链表]
E-->F[打印链表]
根据流程图写代码
尾插法特点是我们始终让尾指针r指向链表的尾部。
-
尾插法
#include <stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*LinkList;
//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
L->next=NULL;
ElemType x;
scanf("%d",&x);
LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
while(x!=9999)
{
s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
s->data=x;
r->next=s;//新结点给尾结点的next指针
r=s;//r要指向新的尾部
scanf("%d",&x);
}
r->next=NULL;//让尾结点的next为null
}
void print_list(LinkList L)
{
L=L->next;
while(L !=NULL )
{
printf("%3d",L->data);
L=L->next;
}
printf("\n");
}
//尾插法新建链表
int main() {
LinkList L;//链表头指针，是结构体指针类型
//list_head_insert(L);//输入数据可以为3 4 5 7 9999，头插法新建链表
list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
print_list(L);
return 0;
}
测试结果
3 4 5 6 7 9999
3 4 5 6 7
五、链表查找
流程图
graph LR
A[定义头指针]-->C[尾插法新建链表]
C-->D[查找某元素位置]
C-->G[判断某元素位置是否合法]
C-->F[L是位置0]
D-->E[遍历链表查找值]
G-->E[遍历链表查找值]
F-->E[遍历链表查找值]
1. 基于尾插法的按位置查找
#include <stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*LinkList;
//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
L->next=NULL;
ElemType x;
scanf("%d",&x);
LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
while(x!=9999)
{
s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
s->data=x;
r->next=s;//新结点给尾结点的next指针
r=s;//r要指向新的尾部
scanf("%d",&x);
}
r->next=NULL;//让尾结点的next为null
}
void print_list(LinkList L)
{
L=L->next;
while(L !=NULL )
{
printf("%3d",L->data);
L=L->next;
}
printf("\n");
}
//按照位置查找
LinkList GetElem(LinkList L,int search_pos)
{
int i=0;//从0开始遍历
if(search_pos<0)
{
return NULL;
}
while(L&&i<search_pos)
{
L=L->next;
i++;
}
return L;
}
//尾插法新建链表
int main() {
LinkList L,search;//链表头指针，是结构体指针类型
list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
print_list(L);//链表打印
//按照位置查找
search=GetElem(L,2);
if(search != NULL)
{
printf("succeeded in searching by serial number\n");
printf("%d\n",search->data);
}
return 0;
}
测试结果
3 4 5 6 7 9999
3 4 5 6 7
succeeded in searching by serial number
4
2. 基于尾插法的按值查找
#include <stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*LinkList;
//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
L->next=NULL;
ElemType x;
scanf("%d",&x);
LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
while(x!=9999)
{
s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
s->data=x;
r->next=s;//新结点给尾结点的next指针
r=s;//r要指向新的尾部
scanf("%d",&x);
}
r->next=NULL;//让尾结点的next为null
}
void print_list(LinkList L)
{
L=L->next;
while(L !=NULL )
{
printf("%3d",L->data);
L=L->next;
}
printf("\n");
}
//按值查找
LinkList LocateElem(LinkList L,ElemType search_value)
{
while(L)
{
if (L->data==search_value)//如果找到对应的值，就返回那个结点的地址
{
return L;
}
L=L->next;
}
return NULL;//遍历到最后没有找到就返回null
}
//尾插法新建链表
int main() {
LinkList L,search;//链表头指针，是结构体指针类型
list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
print_list(L);//链表打印
//按值查找
search=LocateElem(L,6);
if(search != NULL)
{
printf("search by value succeeded\n");
printf("%d\n",search->data);
}
return 0;
}
测试结果
3 4 5 6 7 9999
3 4 5 6 7
search by value succeeded
6
六、插入操作
把新结点插入到第i个位置，策略是调用GetElem函数，拿到i-1元素位置地址
流程图
graph LR
A[定义头指针]-->C[尾插法新建链表]
C-->D[要插入第i个位置]
C-->G[通过GetElem按位置查找]
C-->F[拿到第i-1个元素位置地址]
D-->E[把新结点放在i-1元素后面]
G-->E[把新结点放在i-1元素后面]
F-->E[把新结点放在i-1元素后面]
插入位置
创建新结点代码
q=(LNode*)malloc(sizeof(LNode));
q->data=x;
- 表头插入元素
- 中间插入元素
表头、中间插入元素代码
q->next=p->next;
p->next=q;
- 表尾插入元素
表尾插入元素代码
p->next=q;
q->next=NULL;
往第i个位置插入元素
#include <stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*LinkList;
//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
L->next=NULL;
ElemType x;
scanf("%d",&x);
LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
while(x!=9999)
{
s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
s->data=x;
r->next=s;//新结点给尾结点的next指针
r=s;//r要指向新的尾部
scanf("%d",&x);
}
r->next=NULL;//让尾结点的next为null
}
void print_list(LinkList L)
{
L=L->next;
while(L !=NULL )
{
printf("%3d",L->data);
L=L->next;
}
printf("\n");
}
//按照位置查找
LinkList GetElem(LinkList L,int search_pos)
{
int i=0;//从0开始遍历
if(search_pos<0)
{
return NULL;
}
while(L&&i<search_pos)
{
L=L->next;
i++;
}
return L;
}
//插入函数
bool list_front_insert(LinkList L,int insert_pos,ElemType insert_value)
{
LinkList p= GetElem(L,insert_pos-1);
if(p==NULL)
{
return false;
}
LinkList q;
q=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
q->data=insert_value;
q->next=p->next;
p->next=q;
//表头、中、尾插入这个均适用
return true;
}
//尾插法新建链表
int main() {
LinkList L,search;//链表头指针，是结构体指针类型
list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
print_list(L);//链表打印
list_front_insert(L,2,99);//新结点插入第i个位置
print_list(L);//链表打印
return 0;
}
测试结果
3 4 5 6 7 9999
3 4 5 6 7
3 99 4 5 6 7
七、单链表的删除操作
删除链表的第i个结点
graph LR
A[定义头指针]-->C[尾插法新建链表]
C-->D[要删除第i个位置]
C-->G[通过GetElem按位置查找]
C-->F[拿到第i-1个元素位置地址]
D-->E[删除i结点并释放空间]
G-->E[删除i结点并释放空间]
F-->E[删除i结点并释放空间]
删除结点代码
p->next=q->next;//p指向i-1，q指向要删除的结点i
free(q);//释放删除的结点i的空间
删除第i个结点
#include <stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*LinkList;
//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
L->next=NULL;
ElemType x;
scanf("%d",&x);
LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
while(x!=9999)
{
s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
s->data=x;
r->next=s;//新结点给尾结点的next指针
r=s;//r要指向新的尾部
scanf("%d",&x);
}
r->next=NULL;//让尾结点的next为null
}
void print_list(LinkList L)
{
L=L->next;
while(L !=NULL )
{
printf("%3d",L->data);
L=L->next;
}
printf("\n");
}
//按照位置查找
LinkList GetElem(LinkList L,int search_pos)
{
int i=0;//从0开始遍历
if(search_pos<0)
{
return NULL;
}
while(L&&i<search_pos)
{
L=L->next;
i++;
}
return L;
}
//删除第i个位置的元素
//删除时L是不会变的，所以不需要加引用
bool list_delete(LinkList L,int i)
{
LinkList p= GetElem(L,i-1);
if(p==NULL)
{
return false;
}
LinkList q=p->next;//拿到要删除的结点指针
p->next=q->next;//断链
free(q);//释放被删除结点的空间
return true;
}
//尾插法新建链表
int main() {
LinkList L,search;//链表头指针，是结构体指针类型
list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
print_list(L);//链表打印
printf("set up succeeded!\n");
list_delete(L,4);//删除第4个元素
print_list(L);//链表打印
printf("delete succeeded!\n");
return 0;
}
测试结果
3 4 5 6 7 9999
3 4 5 6 7
set up succeeded!
3 4 5 7
delete succeeded!
