一、新建链表
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!
- 参考自王道
