一、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,查找元素keyint 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;i<len;i++){Linklist t=p;p=p->next;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;i<len;i++){for( j=0,p=L;j<len-i;j++,p=p->next){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<len;i++){L=delete_head(L);}return L;
}

练习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;i<n;i++){for(int j=0;j<m-2;j++){p=p->next;}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 <stdio.h>
#include <string.h>
#include <stdlib.h>
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;i<n;i++){for(int j=0;j<m-2;j++){p=p->next;}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<n;i++){printf("please enter element:");scanf("%d",&e);//头插：在头指针当前节点插入L=loop_insert_head(e,L);}loop_output(L);//尾部插入for(int i=0;i<n;i++){printf("please enter element:");scanf("%d",&e);L=loop_insert_rear(e,L);}loop_output(L);//循环链表//loop_output(L);//头删//L=loop_delete_head(L);//loop_output(L);//尾删//L=delete_rear(L);//loop_output(L);*/int n,m;//n表示节点的总个数，m表示几个一出圈printf("输入一共有多个人：");scanf("%d",&n);for(int i=0;i<n;i++){L=loop_insert_rear(i+1,L);}//约瑟夫环printf("输入几个一出圈：");scanf("%d",&m);Joseph(L,n,m);return 0;
}

  

练习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 <stdio.h>
#include <string.h>
#include <stdlib.h>
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.创建新节点sDoubleLink 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.创建新节点sDoubleLink 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<n;i++){printf("please enter element:");scanf("%s",e);//L=insert_head(e,L);L=insert_rear(e,L);}//循环输出output(L);//头删//L=delete_head(L);//尾删L=delete_rear(L);output(L);return 0;
}

 

三、课后作业：

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;i<len-1;i++,p=p->next){Linklist min=p;for(j=i+1,q=p->next;j<len;j++,q=q->next){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.查找元素keyLinklist p = L;while(p!=NULL&&p->data!=key){p = p->next;}//若key不存在，则返回错误码-1if(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.查找元素keyLinklist p = L;while(p!=NULL&&p->data!=key){p = p->next;}//若key不存在，则返回错误码-1if(p==NULL){return -1;}p->data=e;return 0;
}