数据结构单向链表、单向循环链表、双向链表、双向循环链表操作

链表

• 顺序表存在满，适用于数据量较小的情况，且顺序表不方便插入和删除操作，由此引出了链表；链表不需要预估存储空间，是动态分配空间

概念

• 链表：线性的链式存储称为链表
• 链表的逻辑结构：线性结构【一对一】
• 链式的存储结构：链式存储【逻辑相邻，物理不一定相邻】
• 链表分类：单向链表、单向循环链表、双向链表、双向循环链表
  
• 节点：节点由数据域和指针域组成
  
• 头结点和头指针

单链表的操作

单链表的创建

/*
 * 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=NULL;
    return node;//0x10
}

单链表的头插

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
Linklist insert_head(datatype e,Linklist L)
{
    //在堆区创建一个节点
Linklist node=create_node();
node->data=e;
node->next=L;
    L=node;
    return L;
}

单链表的尾插

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_rear(datatype e,Linklist L)
{
    //创建一个新节点
Linklist s=create_node();
s->data=e;
    if(L==NULL)
    {
    L=s;
    }
    else
    {
    //rear指向最后一个节点的地址
    Linklist rear=L;
    while(rear->next!=NULL)
    {
        rear=rear->next;
    }
    rear->next=s;
    }
    return L;
}

单链表头删

/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_head(Linklist L)
{
    //判断链表是否为空
    if(NULL==L)
    {
    return L;
    }
    if(L->next==NULL)
    {
    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==NULL)
    {
    free(L);
    L=NULL;
    }
    else
    {
    //3,有多个节点
    //循环倒数第二个节点
    Linklist second=L;
    while(second->next->next!=NULL)
    {
        second=second->next;
    }
    free(second->next);
    second->next=NULL;
    }
    return L;
}

单链表遍历

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int output(Linklist L)
{
    //判断是否创建
    //判断是否为空
    if(NULL==L )
    {
    return -1;
    }
    while(L!=NULL)
    {
    printf("%d\t",L->data);
    L=L->next;
    }
    puts("");
}

单链表任意位置插入

int Len_linklist(Linklist L)
{
    int count=0;
    while(L!=NULL)
    {
    count++;
    L=L->next;
    }
    return count;
}
/*
 * function:    按位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_by_pos(int pos,datatype e,Linklist L)
{
    //1,判断链表是否为空
    //2，判断位置是否合法
    int len;
    if(NULL==L || pos<1 || pos>(len=Len_linklist(L))+1)
    {
    puts("insert arror");
    return L;
    }
    
    //3,插入
Linklist p=L;
    if(pos==len+1)
    {
    insert_rear(e,L);
    return L;
    }
    
    for(int i=1;i<pos;i++)
    {
    p=p->next;
    }
    
    
    //在p节点后面插入新节点s
Linklist s=create_node();
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
    
    
    return L;
}

单链表任意位置删除

/*
 * function:    按位置删除
 * @param [ in] 
 * @param [out] 
 * @return      返回链表
 */
Linklist delete_by_pos(int pos,Linklist L)
{
    //1,判断是否为空
    //2，判断位置是否合法
    if(NULL==L|| pos<1 || pos>Len_linklist(L))
    {
    return L;
    }
    //3，删除
    if(pos==1)
    {
    L=delete_head(L);
    }
    else
    {
        //找到pos-1的节点
        Linklist p=L;
        for(int i=1;i<pos-1;i++)
        {
            p=p->next;
        }
        Linklist q=p->next;
        p->next=q->next;
        free(q);
        q=NULL;
    }
    return L;
}

单链表任意位置修改

参数：查找的位置、链表
思路：
判断链表是否为空
判断位置是否合法
循环找到当前pos位置，
直接重新赋值该节点的数据域

/*
 * function:    修改
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int update_by_pos(Linklist L,int pos,datatype e)
{
    //1,判断是否为空
    //2，判断位置是否合法
    if(NULL==L||pos<1|| pos>Len_linklist(L))
    {
        puts("update error");
        return -1;
    }
    //3,修改
    //循环到pos当前节点
    Linklist p=L;
    for(int i=1;i<pos;i++)
    {
        p=p->next;
    }
    p->data=e;
    return 0;
}

单链表任意位置查找

/*
 * function:    按位置查找
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int search_by_pos(Linklist L,int pos)
{
    //1,判断是否为空
    //2，判断位置是否合法
    if(NULL==L|| pos<1|| pos>Len_linklist(L))
    {
        puts("search error");
        return -1;
    }
    //3,查找
    //找到pos当前节点
    Linklist p=L;
    for(int i=1;i<pos;i++)
    {
        p=p->next;
    }
    printf("find data is:%d\n",p->data);
    return 0;
}

单链表任意元素查找

/*
 * 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;
}

单链表任意元素删除

/*
 * 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;*/

}

按任意元素插入

/*
 * function:    按任意元素插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Insert_data(datatype e,datatype data,Linklist L)
{
	if(NULL==L)
	{
		printf("插入失败\n");
		return L;
	}
	int pos=Serach_data(data,L);
	if(pos==-1)
		printf("插入失败\n");
	else
	L=Insert_pos(pos,e,L);
	return L;
}

按任意元素修改

/*
 * function:    任意元素修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Update_data(datatype e,datatype data,Linklist L)
{
	if(NULL==L)
	{
		printf("修改失败\n");
		return -1;
	}
	int pos=Serach_data(data,L);
	if(pos==-1)
		printf("修改失败\n");
	else
		Update_pos(pos,e,L);
	return 0;
}

单链表逆置

/*
 * 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;
}

单链表冒泡

/*
 * 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;
            }
        }
    }
}

单链表简单选择

void Simple(Linklist L)
{
	if(NULL==L||L->next==NULL)
	{
		printf("无法排序\n");
		return ;
	}
	int len=Len_linklist(L);
	Linklist p,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)
		{
			int t=min->data;min->data=p->data;
			p->data=t;
		}
	}
}

单链表释放

/*
 * 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;
}

单向循环链表

单向循环链表节点创建

/*
 * 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
}

单向循环链表头插

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
Linklist insert_head(datatype e,Linklist L)
{
    //在堆区创建一个节点
Linklist node=create_node();
node->date=e;
if(NULL==L)
{
	L=s;
}
Linklist rear=L;
while(rear->next!=L)
{
rear=rear->next;
}
reaar->next=node;
node->next=L;
    return L;
}

单向循环链表头删

/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist 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 insert_rear(datatype e,Linklist L)
{
    //创建一个新节点
Linklist s=create_node();
s->data=e;
    if(L==NULL)
    {
    L=s;
    }
    else
    {
    //rear指向最后一个节点的地址
    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 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      成功返回0 失败返回-1
 */
int output(Linklist L)
{
    //判断是否创建
    //判断是否为空
    if(NULL==L )
    {
    return -1;
    }
    Linklist p=L;
	do
    {
    printf("%d\t",L->data);
    L=L->next;
    } while(L!=p);
    puts("");
}

约瑟夫环

/*
 * 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;
        }
}

双向链表

• 单向链表只可以向后遍历，使用起来不方便，由此引出了双向链表可以向前遍历

双向链表创建

/*
 * 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      返回地址
 */
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;
}

双向链表遍历

/*
 * 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("");
    
}

双向链表逆置

DoubleLink rev_list(DoubleLink L)  //双向链表逆置
{
	if(NULL==L_list||L->next==NULL)
		return L;
	int len=len_Llist(L)-1;
	DoubleLink p=L->next;
	L->next=NULL;
    L->prev=L->next;
	for(int i=0;i<len;i++)
	{
		DoubleLink q=p;
		p=p->next;
		q->prev=q->next;
		q->next=L;
		L=q;
	}
	return L;
}

双向循环链表

双向循环链表创建

/*
 * 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=node;
    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)
    {
    rear=L->prev;
    s->next=L;
    L->prev=s;
    rear->next=s;
    s->prev=rear;
    }
    L=s;
    return L;
}

双向循环链表尾插

/*
 * 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->prev;
s->next=L;
L->prev=s;
    return L;
}

双向循环链表头删

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_head(DoubleLink L)
{
    //1,如果链表为空，
    if(NULL==L)
    return L;
    //2,判断链表只有一个节点
    if(L==L->next)
    {
    free(L);
    L=NULL;
    return L;
    }
    //3,有多个节点
DoubleLink q=L->next;
    strcpy(L->data,q->data);
	L->next=q->next;
    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(L==L->next)
    {
    free(L);
    L=NULL;
    return L;
    }
    //3,存在多个节点
    //找到倒数第一个节点
DoubleLink rear=L->prev;


L->prev=rear->prev=L;
    free(rear);
rear=NULL;
    return L;
}

双向循环链表遍历

/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DoubleLink L)
{
    //1,判断链表是否为空
    if(NULL==L)
    {
    return;
    }
    //正向遍历
   	DoubleLink p=L
    puts("正向遍历");
    while(L->next!=p)
    {
    printf("%s\t",L->data);
    L=L->next;
    }
    printf("%s\t",L->data);
    puts("\n逆向遍历");
    while(L!=p)
    {
        
    printf("%s\t",L->data);
    L=L->prev;
    }
    printf("%s ",L->data);
    puts("");
    
}