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

已于 2023-07-24 06:01:25 修改
阅读量285 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2023-07-24 05:50:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318298/article/details/131887548
版权

链表

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

概念

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

在这里插入图片描述

单链表的操作

单链表的创建

/*
 * 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("");
    
}
奕书想睡觉了。
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】单链表和双向循环链表
weixin_67312366的博客
09-09 758
链表
单链表、双链表、循环链表简介
最新发布
z2141830440的博客
03-10 734
对于一个链表，是由一系列不必在内存中相连的结构组成，每一个结构均含有表元素和指向包含该元素下一个表结构的指针（我们称之为Next指针）,它们也叫数据域和指针域。最后一个表结构的Next指针指向NULL，ANSI C规定NULL为零。（图1-2中箭头表示的就是Next指针）
单链表、双向链表、循环链表
hyt1152860391的博客
07-26 7388
常见链表 学习三种常见的链表结构，他们分别是：单链表、双向链表和循环链表。 单链表 单链表有两个较特殊节点，头结点和尾节点。头结点用来记录链表的基地址，可以用来遍历整条链表。尾结点的指针不是指向下一个节点而是指向一个空地址NULL，表示链表上的最后一个节点。 和数组一样，链表也支持数据的查找、插入和删除操作。但相对于数据的插入删除需要做大量的搬移操作，链表的插入，删除的时间复杂度为O(1)。但是链...
单链表、双链表、循环链表
ckk727的博客
09-20 2544
这学期的数据结构课有讲到链表，所以再来温故一下，毕竟温故知新嘛。 链表与数组的区别 链表和数组都是线性表，两者区别如下： 数组静态分配内存，链表动态分配内存；更进一步说就是数组不易拓展，但链表易拓展。 数组在内存中连续，链表不连续；更进一步说就是数组可能会造成内存浪费，但链表的内存利用率高； 数组利用下标定位元素，时间复杂度为O(1)，链表在最坏情况下是O(n)；即在随机性查找上数组比链表更...
python实现数据结构中双向循环链表操作的示例
12-16
双向循环链表是一种重要的数据结构，它允许我们在链表的两端进行插入和删除操作，同时每个节点都包含指向其前一个和后一个节点的引用，形成一个闭合的循环。在给定的示例中，我们看到了如何用Python实现这种数据结构...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
Python单向链表和双向链表原理与用法实例详解
09-20
Python实现链表时，可以使用内置的类来简化操作，如`collections`模块中的`deque`可以用来模拟双向链表，但通常我们会选择自定义数据结构，以便更好地理解和控制链表的行为。 总的来说，链表在内存效率和动态性方面...
链表——循环单链表，循环双链表及静态链表
薛定谔的猫的博客
04-18 3421
文章目录循环链表循环单链表循环双链表静态链表说明 循环链表  循环链表一般包括循环单链表和循环双链表，如下图所示： 循环单链表   循环单链表与单链表的区别在于，表中最后一个结点的指针不是NULL，而改为指向头结点，从而使整个链表形成一个环。   一般对循环单链表只设尾指针不设头指针，其原因是，如果设的是头指针，对表尾进行操作需要O(n)的时间复杂度，而若设的是尾指针r，那么r->next即为头指针，对表头与表尾进行操作都只需要O(1)的时间复杂度。  单链表与循环单链表：  详细的单链表操作请参
单链表、双链表、循环链表总结
SdustLiYang的专栏
01-12 4207
1.单链表（为升序链表，value按升序排列） #include #include typedef struct NODE { struct NODE *link; int value; } Node;//最好放在头文件中 Node *sll_creat(); int sll_length(Node *p); Node *sll_del(Node *head,int
单循环链表和双向循环链表
any_ways的博客
03-28 1958
循环链表就是普通的单链表，最后一个元素存的地址本来是ＮＵＬＬ，现在改成头结点的地址，从而形成循环． #include <stdio.h> #include <stdlib.h> #define MAX(X,Y) (X>Y?X:Y) #include <math.h> //尾部插入法创建一个包含５个元素的循环链表,从一个开始元素依次插入到头部 typedef struct S//创建一个链表元素 { int data;//数据域 struct S*
单链表&循环链表&双向链表的不同
qq_53830608的博客
01-14 2303
循环链表： ①判空条件为：p==plist或者p->next==NULL; ②判断结尾不同：循环链表的结尾又回到了头（是一个圈圈一样的循环）：p==plist；而单链表的结尾时NULL：p==NULL。 ③循环链表可以从一个结点到达任意节点，而单链表只能顺着链表一直查找下去(因为循环链表可以一直循环下去，而单链表只能走一遍）。 双向链表： 增加了前驱结点，在涉及前驱结点的头插、尾插、删除操作上有所不同，判空条件仍为p==NULL. ①头插与尾插的最后一部插入时，需要把前驱结点连接上，头插法
【面试题精选】两数相加
weixin_43958974的博客
09-25 171
题目：两数相加 思路： 设置一个哨兵节点dummy和增长节点cur 定义一些辅助变量x,y,flag,sum x表示链表L1当前节点的值，空节点为0； y表示链表L2当前节点的值，空节点为0； sum表示x+y的和； flag表示sum/10,即向十位的溢出值 while循环，只要链表L1和链表L2不同时为空，就对L1和L2所指的当前节点作如下处理： 计算sum = x + y + flag; 计算flag = sum / 10; 用sum % 10的值在cur后面创建一个新节点； 循环结束
单链表、双链表、循环链表和静态链表以及相应习题习题
热门推荐
Wlain的博客
08-26 1万+
一、单项选择题1.关于线性表的顺序存储结构和链式存储结构的描述中，正确的是（ ）。 Ⅰ.线性表的顺序存储结构优于其链式存储结构 Ⅱ.链式存储结构比顺序存储结构能更方便地表示各种逻辑结构 Ⅲ.如频繁使用插入和删除结点操作，顺序存储结构更优于链式存储结构 Ⅳ.顺序存储结构和链式存储结构都可以进行顺序存取A. Ⅰ、Ⅱ、Ⅲ B. Ⅱ、Ⅳ C. Ⅱ、Ⅲ D. Ⅲ、Ⅳ2.对于一个
单链表，循环链表，双向链表（C++实现）
weixin_30525825的博客
01-15 307
单链表：　　一.单链表与顺序表相比： 　　　1.顺序表可以方便的随机存取表中的任一节点，速度快；但是在表中插入删除一个数据时，为了保持其他元素的相对次序不变，平均需要移动一半的元素，效率很低；还有若事先对表长估计不足，过小会形成内存浪费，过大则需要拷贝到一个更大的数组，时间开销很大。相反，链表则适用于插入删除频繁，表长估计不定的情形。 　　　2.顺序表逻辑位置和物理位置都连续，而单链表中的逻辑...
二、单链表的实现和遍历，循环链表、双向循环链表的实现
Willwilling
04-07 1607
一、线性表的链式存储结构顺序存储结构线性表的最大问题：插入和删除需要移动大量的元素（时间复杂度高），如何解决呢？链式存储的定义：为了表示每个元素与其直接后继元素之间的逻辑关系，数据元素除了存储本身的信息之外，还需要存储其直接后继的信息。通过保存地址的关系将数据元素链接起来。Ai和Ai+1是线性表中的两个相邻的数据元素，在物理内存中无相邻关系。链式存储逻辑结构：基于链式存储结构的线性表，每个结点都包...
链表的基本概念以及java实现单链表-循环链表-双向链表
mcrwayfun，欢迎你
07-19 1637
前言 线性结构是非常简单且常用的数据结构，而线性表则是一种非常典型的线性结构。 线性表定义 线性表的数据结构 链表 单链表 单链表的定义 单链表的插入和删除 单链表的遍历，清空，判空，获取指定结点 循环链表 循环链表的定义 循环链表的插入和删除 循环链表的遍历，清空 双向链表 双向链表的定义 双向链表的插入和删除 本节代码传送门，欢迎star：https://github...
算法之链表
JIAWEA的博客
11-11 311
单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem用来存放具体的数据。 链接域next用来存放下一个节点的位置（python中的标识） 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。 下面引用算法图解一书中的链表： 链...
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值