数据结构day5（2023.7.19）
一、Xmind整理：
双向链表的插入与删除：
二、课上练习：
练习1：单链表任意元素删除
/*
* function: 按元素删除
* @param [ in]
* @param [out]
* @return 返回堆区首地址
*/
Linklist delete_by_data(datatype key,Linklist L)
{
//1,先根据key查找位置
int delete_pos=search_by_data(key,L);
if(delete_pos==-1)
return L;
//2,元素存储
L=delete_by_pos(delete_pos,L);
return L;
/*
int pos=0;
Linklist p=L;
while(L!=NULL)
{
pos++;
if(L->data==key)
{
p=delete_by_pos(pos,p);
pos--;
}
else
{
L=L->next;
}
}
return p;*/
}练习2： 单链表任意元素查找
/*
* function: 元素查找
* @param [ in]
* @param [out]
* @return 返回位置，失败-1
*/
int search_by_data(datatype key,Linklist L)
{
//1,判断是否为空
if(NULL==L)
{
return -1;
}
//2,查找元素key
int pos=0;
while(L!=NULL)
{
pos++;
if(L->data==key)
{
return pos;
}
L=L->next;
}
return -1;
}练习3： 单链表逆置
/*
* function: 逆置
* @param [ in]
* @param [out]
* @return 返回地址
*/
Linklist rev_lInklist(Linklist L)
{
//判断链表是否为空
//判断链表甚至有一个节点
if(NULL == L || L->next==NULL)
{
return L;
}
//链表有多个节点
Linklist p=L->next;
int len=Len_linklist(L)-1;
L->next=NULL;
for(int i=0;inext;
t->next=L;
L=t;
}
return L;
} 练习4：单链表排序（冒泡排序）
/*
* function: 冒泡排序
* @param [ in]
* @param [out]
* @return
*/
void Bubble(Linklist L)
{
//1,判断是否为空
//2，判断如果链表只有一个节点
if(NULL==L || L->next==NULL)
{
return ;
}
//冒泡排序
int len=Len_linklist(L);
Linklist p;
int i,j;
for( i=1;inext)
{
if(p->data>p->next->data)
{
datatype t=p->data;
p->data=p->next->data;
p->next->data=t;
}
}
}
} 练习5： 单链表释放
/*
* function: 释放
* @param [ in]
* @param [out]
* @return 返回堆去首地址
*/
Linklist free_space(Linklist L)
{
if(NULL==L)
{
return NULL;
}
int len=Len_linklist(L);
for(int i=0;i练习6：单向循环链表节点创建
/*
* function: 创建一个节点
* @param [ in]
* @param [out]
* @return
*/
Linklist create_node()
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
if(NULL==node)
return NULL;
node->data=0;
node->next=node;//循环链表的每个节点指针域指向自己
return node;//0x10
}练习7：单向循环链表头插
/*
* function: 头插
* @param [ in]
* @param [out]
* @return 成功返回0 失败返回-1
*/
Linklist loop_insert_head(datatype e,Linklist L)
{
//在堆区创建一个节点
Linklist node=create_node();//在堆区申请一个节点
if(node==NULL)
return L;
if(NULL==L)
{
L=node;
node->data=e;
}
else
{
node->next=L->next;
L->next=node;
node->data=L->data;
L->data=e;
}
return L;//因为自定义的函数指针的改变不影响实参，需要返回
}
练习8：单向循环链表的尾插
/*
* function: 尾部插入
* @param [ in]
* @param [out]
* @return
*/
Linklist loop_insert_rear(datatype e,Linklist L)
{
Linklist s=create_node();
s->data=e;
if(L==NULL)
{
L=s;
}
else
{
Linklist rear=L;
while(rear->next!=L)
{
rear=rear->next;
}
rear->next=s;
s->next=L;
}
return L;
}
练习9：单向循环链表的头删
/*
* function: 头删除
* @param [ in]
* @param [out]
* @return
*/
Linklist loop_delete_head(Linklist L)
{
//判断链表是否为空
if(NULL==L)
{
return L;
}
if(L->next==L)
{
free(L);
L=NULL;
}
else
{
Linklist q=L->next;
L->data=q->data;
L->next=q->next;
free(q);
q=NULL;
}
return L;
}
练习10：单向循环链表的尾删
/*
* function: 尾部删除
* @param [ in]
* @param [out]
* @return
*/
Linklist delete_rear(Linklist L)
{
//1.判断链表是否为空
if(NULL==L)
{
return NULL;
}
//2.判断如果链表只有一个节点
else if(L->next==L)
{
free(L);
L=NULL;
}
else
{
//3.有多个节点
//循环倒数第二个节点
Linklist second=L;
while(second->next->next!=L)
{
second=second->next;
}
free(second->next);
second->next=L;
}
return L;
}
练习11：单向循环链表的遍历
/*
* function: 循环遍历
* @param [ in]
* @param [out]
* @return
*/
int loop_output(Linklist L)
{
//判断是否创建
//判断是否为空
if(NULL==L)
{
return -1;
}
Linklist p=L;
do{
printf("%d\t",p->data);
p=p->next;
}while(p!=L);
puts("");
}
练习12：约瑟夫环
约瑟夫环：用循环链表编程实现约瑟夫问题
n个人围成一圈，从某人开始报数1, 2, …, m，数到m的人出圈，然后从出圈的下一个人(m+1)开始重复此过程，直到全部人出圈，于是得到一个出圈人员的新序列
如当n=8，m=4时，若从第一个位置数起，则所得到的新的序列 为4, 8, 5, 2, 1, 3, 7, 6。
/*
* function: 约瑟夫环
* @param [ in]
* @param [out]
* @return
*/
void Joseph(Linklist L,int n,int m)
{
Linklist p=L;
for(int i=0;inext;
}
Linklist q=p->next;
p->next=q->next;
printf("%d\t",q->data);
free(q);
q=NULL;
p=p->next;
}
printf("\n");
}
单向循环链表目前整体代码：
head.h：
#ifndef __HEAD_H__
#define __HEAD_H__
#include
#include
#include
typedef int datatype;
//定义单链表节点结构体
typedef struct Node
{
//数据域：数据元素
datatype data;
//指针域：存储下一个节点的地址
struct Node *next;
}*Linklist;
Linklist create_node();
Linklist loop_insert_head(datatype e,Linklist L);
int loop_output(Linklist L);
Linklist loop_insert_rear(datatype e,Linklist L);
Linklist loop_delete_head(Linklist L);
Linklist delete_rear(Linklist L);
void Joseph(Linklist L,int n,int m);
#endif
test.c：
#include "head.h"
/*
* function: 创建一个节点
* @param [ in]
* @param [out]
* @return
*/
Linklist create_node()
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
if(NULL==node)
return NULL;
node->data=0;
node->next=node;//循环链表的每个节点指针域指向自己
return node;
}
/*
* function: 头插
* @param [ in]
* @param [out]
* @return 成功返回0 失败返回-1
*/
Linklist loop_insert_head(datatype e,Linklist L)
{
//在堆区创建一个节点
Linklist node=create_node();//在堆区申请一个节点
if(node==NULL)
return L;
if(NULL==L)
{
L=node;
node->data=e;
}
else
{
node->next=L->next;
L->next=node;
node->data=L->data;
L->data=e;
}
return L;//因为自定义的函数指针的改变不影响实参，需要返回
}
/*
* function: 循环遍历
* @param [ in]
* @param [out]
* @return
*/
int loop_output(Linklist L)
{
//判断是否创建
//判断是否为空
if(NULL==L)
{
return -1;
}
Linklist p=L;
do{
printf("%d\t",p->data);
p=p->next;
}while(p!=L);
puts("");
}
/*
* function: 尾部插入
* @param [ in]
* @param [out]
* @return
*/
Linklist loop_insert_rear(datatype e,Linklist L)
{
Linklist s=create_node();
s->data=e;
if(L==NULL)
{
L=s;
}
else
{
Linklist rear=L;
while(rear->next!=L)
{
rear=rear->next;
}
rear->next=s;
s->next=L;
}
return L;
}
/*
* function: 头删除
* @param [ in]
* @param [out]
* @return
*/
Linklist loop_delete_head(Linklist L)
{
//判断链表是否为空
if(NULL==L)
{
return L;
}
if(L->next==L)
{
free(L);
L=NULL;
}
else
{
Linklist q=L->next;
L->data=q->data;
L->next=q->next;
free(q);
q=NULL;
}
return L;
}
/*
* function: 尾部删除
* @param [ in]
* @param [out]
* @return
*/
Linklist delete_rear(Linklist L)
{
//1.判断链表是否为空
if(NULL==L)
{
return NULL;
}
//2.判断如果链表只有一个节点
else if(L->next==L)
{
free(L);
L=NULL;
}
else
{
//3.有多个节点
//循环倒数第二个节点
Linklist second=L;
while(second->next->next!=L)
{
second=second->next;
}
free(second->next);
second->next=L;
}
return L;
}
/*
* function: 约瑟夫环
* @param [ in]
* @param [out]
* @return
*/
void Joseph(Linklist L,int n,int m)
{
Linklist p=L;
for(int i=0;inext;
}
Linklist q=p->next;
p->next=q->next;
printf("%d\t",q->data);
free(q);
q=NULL;
p=p->next;
}
printf("\n");
}
main.c：
#include "head.h"
int main(int argc, const char *argv[])
{
Linklist L=NULL;
/*
int n;
datatype e;
printf("please enter n:");
scanf("%d",&n);
for(int i=0;i
练习13：双向链表节点创建
/*
* function: 创建节点
* @param [ in]
* @param [out]
* @return 返回节点的地址
*/
DoubleLink create_node()
{
DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
if(NULL==node)
return NULL;
//对新节点的数据域初始化
strcpy(node->data,"");
//对指针域赋值
node->next=node->prev=NULL;
return node;
}练习14：双向链表头插
/*
* function: 双向链表头插
* @param [ in]
* @param [out]
* @return 返回链表
*/
DoubleLink insert_head(datatype e,DoubleLink L)
{
//1,创建新节点s
DoubleLink s=create_node();
if(NULL==s)
return L;
strcpy(s->data,e);
if(NULL !=L)
{
s->next=L;
L->prev=s;
}
L=s;
return L;
}练习15：双向链表尾插
/*
* function: 尾部插入
* @param [ in]
* @param [out]
* @return 返回地址
*/
DoubleLink insert_rear(datatype e,DoubleLink L)
{
//1,创建新节点s
DoubleLink s=create_node();
if(NULL==s)
return L;
strcpy(s->data,e);
//链表为空
if(NULL==L)
{
L=s;
return L;
}
//表示存在多个节点
//找到尾部节点
DoubleLink rear=L;
while(rear->next!=NULL)
{
rear=rear->next;
}
rear->next=s;
s->prev=rear;
return L;
}练习16：双向链表头删
/*
* function: 头删
* @param [ in]
* @param [out]
* @return 返回地址
*/
DoubleLink delete_head(DoubleLink L)
{
//1,如果链表为空，
if(NULL==L)
return L;
//2,判断链表只有一个节点
if(NULL==L->next)
{
free(L);
L=NULL;
return L;
}
//3,有多个节点
DoubleLink q=L->next;
strcpy(L->data,q->data);
L->next=q->next;
if(q->next!=NULL)
q->next->prev=L;
free(q);
q=NULL;
return L;
}练习17：双向链表尾删
/*
* function: 尾部删除
* @param [ in]
* @param [out]
* @return 返回地址
*/
DoubleLink delete_rear(DoubleLink L)
{
//1,如果链表为空，
if(NULL==L)
return L;
//2,判断链表只有一个节点
if(NULL==L->next)
{
free(L);
L=NULL;
return L;
}
//3,存在多个节点
//找到倒数第一个节点
DoubleLink rear=L;
while(rear->next!=NULL)
rear=rear->next;
rear->prev->next=NULL;
free(rear);
rear=NULL;
return L;
}练习18：双向链表遍历
/*
* function: 循环输出
* @param [ in]
* @param [out]
* @return
*/
void output(DoubleLink L)
{
//1,判断链表是否为空
if(NULL==L)
{
return;
}
//正向遍历
puts("正向遍历");
while(L->next!=NULL)
{
printf("%s\t",L->data);
L=L->next;
}
printf("%s\t",L->data);
puts("\n逆向遍历");
while(L!=NULL)
{
printf("%s\t",L->data);
L=L->prev;
}
puts("");
}双向链表目前整体代码：
head.h：
#ifndef __HEAD_H
#define __HEAD_H
#include
#include
#include
typedef char datatype[20];//datatype-->char [20]
//定义双向链表节点的结构体
typedef struct Node
{
//数据域：数据元素
datatype data;
//指针域：下一个节点的地址
struct Node *next;
//指针域：上一个节点的地址
struct Node *prev;
}*DoubleLink;
DoubleLink create_node();
DoubleLink insert_head(datatype e,DoubleLink L);
void output(DoubleLink L);
DoubleLink insert_rear(datatype e,DoubleLink L);
DoubleLink delete_head(DoubleLink L);
DoubleLink delete_rear(DoubleLink L);
#endif
test.c：
#include "double_head.h"
/*
* function: 创建节点
* @param [ in]
* @param [out]
* @return 返回节点位置
*/
DoubleLink create_node()
{
DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
if(NULL==node)
return NULL;
//对新节点的数据域初始化
strcpy(node->data,"");
//对指针域赋值
node->next=node->prev=NULL;
return node;
}
/*
* function: 双向链表头插
* @param [ in]
* @param [out]
* @return 返回链表
*/
DoubleLink insert_head(datatype e,DoubleLink L)
{
//1.创建新节点s
DoubleLink s=create_node();
if(NULL==s)
return L;
strcpy(s->data,e);
if(NULL!=L)
{
s->next=L;
L->prev=s;
}
L=s;
return L;
}
/*
* function: 循环输出
* @param [ in]
* @param [out]
* @return
*/
void output(DoubleLink L)
{
//1.判断链表是否为空
if(NULL==L)
{
return;
}
//正向遍历
puts("正向遍历：");
while(L->next!=NULL)
{
printf("%s\t",L->data);
L=L->next;
}
printf("%s\t",L->data);
puts("");
//逆向遍历
puts("逆向遍历");
while(L!=NULL)
{
printf("%s\t",L->data);
L=L->prev;
}
puts("");
}
/*
* function: 双向链表尾插
* @param [ in]
* @param [out]
* @return
*/
DoubleLink insert_rear(datatype e,DoubleLink L)
{
//1.创建新节点s
DoubleLink s=create_node();
if(NULL==s)
return L;
strcpy(s->data,e);
//链表为空
if(NULL==L)
{
L=s;
return L;
}
//表示存在多个节点
//找到尾部节点
DoubleLink rear=L;
while(rear->next!=NULL)
{
rear=rear->next;
}
rear->next=s;
s->prev=rear;
return L;
}
/*
* function: 双向链表头删
* @param [ in]
* @param [out]
* @return 返回地址
*/
DoubleLink delete_head(DoubleLink L)
{
//1.如果链表为空
if(NULL==L)
return L;
//2.判断链表只有一个节点
if(NULL==L->next)
{
free(L);
L=NULL;
return L;
}
//3.存在多个节点
DoubleLink q=L->next;
strcpy(L->data,q->data);
L->next=q->next;
if(q->next!=NULL)
q->next->prev=L;
free(q);
q=NULL;
return L;
}
/*
* function: 双向链表尾删
* @param [ in]
* @param [out]
* @return 返回地址
*/
DoubleLink delete_rear(DoubleLink L)
{
//1.如果链表为空
if(NULL==L)
return L;
//2.判断链表只有一个节点
if(NULL==L->next)
{
free(L);
L=NULL;
return L;
}
//3.存在多个节点
//找到倒数第一个节点
DoubleLink rear=L;
while(rear->next!=NULL)
rear=rear->next;
rear->prev->next=NULL;
free(rear);
rear=NULL;
return L;
}
main.c：
#include "double_head.h"
int main(int argc, const char *argv[])
{
DoubleLink L=NULL;
int n;
datatype e;
printf("please enter n:");
scanf("%d",&n);
for(int i=0;i
三、课后作业：
1.单向链表简单选择排序
void Sort(Linklist L)
{
//1.判断是否为空
//2.判断如果链表只有一个节点
if(NULL==L||L->next==NULL)
{
return;
}
//简单选择
int len=Len_linklist(L);
Linklist p;
Linklist q;
int i,j;
for(i=0,p=L;inext)
{
Linklist min=p;
for(j=i+1,q=p->next;jnext)
{
if(min->data>q->data)
{
min=q;
}
}
if(min!=p)
{
datatype t=p->data;
p->data=min->data;
min->data=t;
}
}
}
2.单向链表任意元素插入
/*
* function: 按元素插入
* @param [ in]
* @param [out]
* @return 成功返回0 失败返回-1
*/
int insert_by_data(datatype key,datatype e,Linklist L)
{
//1.判断元素是否为空
if(NULL==L)
{
return -1;
}
//2.查找元素key
Linklist p = L;
while(p!=NULL&&p->data!=key)
{
p = p->next;
}
//若key不存在，则返回错误码-1
if(p==NULL)
{
return -1;
}
//3.创建新节点并插入链表
Linklist q=create_node();
q->data=e;
q->next=p->next;
p->next=q;
return 0;
}
3.单向链表任意元素修改
/*
* function: 按元素修改
* @param [ in]
* @param [out]
* @return 成功返回0 失败返回-1
*/
int update_by_data(datatype key,datatype e,Linklist L)
{
//1.判断元素是否为空
if(NULL==L)
{
return -1;
}
//2.查找元素key
Linklist p = L;
while(p!=NULL&&p->data!=key)
{
p = p->next;
}
//若key不存在，则返回错误码-1
if(p==NULL)
{
return -1;
}
p->data=e;
return 0;
}
