链表和顺序表

已于 2023-06-15 11:14:14 修改
阅读量42 收藏
点赞数
分类专栏： C语言 文章标签： 数据结构 算法 链表
于 2023-06-15 11:10:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/choose_heart/article/details/131218549
版权

文章目录

链表

1.链表就是一种数据结构，可以从上一个数据找到下一个数组的位置。从而进行访问。
一般标准的符合上述描述的就是单链表。‘
单链表示意图
在理解具体结结构的基础上，就可以着手链表的创建、销毁以及增删查改.
具体在于头插，尾插，头删，尾删，某个位置插入数据，查找数组，删除某位置数据

#include  <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLdata;

typedef struct SLCA {
    struct SLCA* p;
    SLdata a;
}CA;//取名叫CA，是因为查单词出现偏差，chain list，CA也就是链表的结构体
//里面包含了一个指针，指向下一个数据
void SL_firinsert(CA** pca,SLdata data);
void SL_endinsert(CA** pca,SLdata data);
void SLprint(CA* pca);
CA* Crea_node(SLdata X);
void SL_deletefir(CA** pca);
void SL_deletefend(CA** pca);
CA* SLdfind(CA* phead,SLdata data);
void SLindata(CA** phead,CA* pos,SLdata x);
void SLindata2(CA** phead,CA* pos,SLdata x);
void SLdele_now(CA** phead,CA* pos);
void SLdele_aft(CA** phead,CA* pos);

void SLprint(CA* pca)//打印链表，可以传空
{
    CA* cur = pca;
    while(cur)
    {
        printf("%d ->",cur->a);
        cur = cur->p;
    }
    printf("NULL\n");
    return ;
}

CA* Crea_node(SLdata X)//创建一个链表节点
{
    CA* newnode = (CA*)malloc(sizeof(CA));
    if(!newnode)
    {
        perror("malloc fail:");
        return NULL;
    }
    newnode->a = X;
    newnode->p = NULL;
    return newnode;
}
void SL_firinsert(CA** pca,SLdata data)//头插，这里传二级指针，是为了确实修改节点，
//如果直接传以及指针，是不是就无法修改你改变头节点之后的值的还回去
{
    assert(pca);
    CA* cur = *pca;
    CA* temp = Crea_node(data);
    temp ->a = data;
    temp->p = cur;
    *pca = temp;
    return;
}

void SL_endinsert(CA** pca,SLdata data)//尾插
//这里一样，如果是一开始传的空头，那么就需要二级指针，
{
    assert(pca);
    CA* temp = Crea_node(data);
    temp->a = data;
    temp->p=NULL;
    CA* p = *pca;
    if(p)
    {
        
        while(p->p)
        {
            p = p->p;
        }
        p->p = temp;
    }
    else
    {
        *pca = temp;
    }
    return ;
}




void SL_deletefir(CA** pca)
{
    assert(pca);
    if(*pca)//不为空，去删除
    {
        CA* cur = *pca;
        *pca = cur->p;
        free(cur);//free the place malloc;
    }
    else{
        perror("plist is NULL\n");
        return ;//已经为空
    }
}

void SL_deletefend(CA** pca)
{
    assert(pca);
    if(*pca)//不为空，去删除
    {
        if((*pca)->p)
        {
            CA* cur = *pca;
            while(cur->p->p)
            {
                cur = cur->p;
            }
            free(cur->p);//free the place malloc;
            cur->p = NULL;
        }
        else
        {
            free(*pca);
            *pca = NULL;
        }
    }
    else{
        perror("plist is NULL\n");
        return ;//已经为空
    }
}

CA* SLdfind(CA* phead,SLdata data)
{
    CA* cur = phead;
    while(cur)
    {
        if(cur->a== data)
        {
            return cur;
        }
        cur = cur->p;
    }
    printf("NO this DATA!\n");
    return NULL;
}

//某节点前插入
void SLindata(CA** phead,CA* pos,SLdata x)
{
    assert(phead);
    CA* cur = *phead;
    if(!(*phead))
    {
        *phead = Crea_node(x);
        return ;
    }
    if(!pos)
    {
        perror("pos is NULL\n");
        return;
    }
    if(*phead == pos)//solve teh probem if here only one value or it the head of the list insert
    {
        SL_firinsert(phead,x);
        return ;
    }
    while(cur && cur->p != pos)//if cur is NULL ,exit
    {
        cur = cur->p;
    }
    if(cur)
    {
        CA*newnode = Crea_node(x);
        newnode->p = pos;
        cur->p = newnode;
    }
    else
    {
        printf("NO pos int the list\n");
    }

}

void SLindata2(CA** phead,CA* pos,SLdata x)
{
    assert(phead);
    CA* cur = *phead;
    if(!(*phead))
    {
        *phead = Crea_node(x);
        return ;
    }
    if(!pos)
    {
        perror("pos is NULL\n");
        return;
    }
    while(cur && cur!=pos)
    {
        cur = cur->p;
    }
    if(cur)
    {
        CA*newnode = Crea_node(x);
        cur->p = newnode;
    }
    else
    {
        printf("NO pos int the list\n");
    }
}

void SLdele_aft(CA** phead,CA* pos)
{
    assert(phead);
    CA* cur = *phead;
    if(!(*phead))
    {
        printf("thee head is NULL!\n");
        return ;
    }
    while(cur && cur!=pos)
    {
        cur = cur->p;
    }
    if(!cur->p)
    {
        printf("the pos after the target is NULL.\n");
    }
    else
    {
        CA* t = pos->p;
        cur->p = cur->p->p;
        free(t);
    }
}


void SLdele_now(CA** phead,CA* pos)
{
    assert(phead);
    if(!pos)
    {
        perror("pos is NULL\n");
        return ;
    }
    CA* cur = *phead;
    if(!(*phead))
    {
        printf("thee head is NULL!\n");
        return ;
    }
    if(cur==pos)
    {
        *phead = cur->p;
        free(pos);
    }
    else
    {
        while(cur->p &&cur->p!=pos)
        {
            cur = cur->p;
        }
        if(cur->p)
        {
            cur->p = cur->p->p;
            free(pos);
        }
    }
}

详细需要注意的我标准在代码里面了。可以自己动手去实现下。牢记物理结构，结合C语言特征去尝试的调试代码即可。
链表特点：根据代码和物理结构，我们就知道，链表对数据头部的改动是非常方便的，但是对于随机访问和查找数据就不方便。
同时也不方便访问尾部数据。
这里其实有一种解决方式，就是双向链表。
有种很好用的就是带头双向链表。
如下图：
双向链表示意图

typedef int SLdata;
struct ListNode
{
    struct ListNode* next;
    struct ListNode* prev;
    SLdata val;
};
typedef struct ListNode LIST;
void init(LIST ** head);
void pushback(struct ListNode* head,SLdata x);
void pushfront(struct ListNode* head ,SLdata x);
void SLprint(struct ListNode* head);
void popback(struct ListNode* head);
void popfront(struct ListNode* head);
struct ListNode*SLfind(struct ListNode* head,SLdata x);
void intsert_befpos(struct ListNode* pos,SLdata x);
void intsert_aftpos(struct ListNode* pos,SLdata x);


struct ListNode* creat_node(SLdata x)
{
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->prev=NULL;
    node->next=NULL;
    node->val=x;
    return node;
}
void init(LIST ** head)
{
    *head = (struct ListNode*)malloc(sizeof(struct ListNode));
    (*head)->next =(*head);
    (*head)->prev = (*head);
    (*head)->val = -1;
}
void pushback(struct ListNode* head,SLdata x)//尾插
{
    assert(head);
    LIST* cur = head;
    LIST* newnode = creat_node(x);
    cur = cur->prev;
    cur->next = newnode;
    newnode->next = head;
    newnode->prev = cur;
    head->prev = newnode;
}


void pushfront(struct ListNode* head,SLdata x)
{
    assert(head);
    LIST* cur = head->next;
    LIST* newnode = creat_node(x);
    cur->prev = newnode;
    newnode->next = cur;
    newnode->prev = head;
    head->next = newnode;
}
void SLprint(struct ListNode* head)
{
    assert(head);
    assert(head->next!=head);
    printf("guard-> ");
    struct ListNode* cur = head->prev;
    while (cur!=head)
    {
        printf("%d->",cur->val);
        cur = cur->prev;
    }
    printf("\n");
}
void popback(struct ListNode* head)
{
    assert(head);
    assert(head->next!=head);
    struct ListNode *cur = head->prev;
    struct ListNode * fir = cur->prev;
    fir->next = head;
    head->prev = fir;
    free(cur);
}
void popfront(struct ListNode* head)
{
    assert(head);
    assert(head->next!=head);
    struct ListNode *cur = head->next;
    struct ListNode * sec = cur->next;
    head->next = sec;
    sec->prev = head;
    free(cur);
}
struct ListNode* SLfind(struct ListNode* head,SLdata x)
{
    assert(head);
    assert(head->next!=head);
    struct ListNode *cur = head->next;
    while(head != cur)
    {
        if(cur->val==x)
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL;
}
void intsert_befpos(struct ListNode* pos,SLdata x)
{
    if(!pos)
    {
        perror("the pos is NULL\n");
        return ;
    }
    struct ListNode* pre = pos->prev;
    LIST* newnode = creat_node(x);
    pre->next = newnode;
    newnode->next = pos;
    newnode->prev = pre;
    pos->prev = newnode;
}


void intsert_aftpos(struct ListNode* pos,SLdata x)
{
    if(!pos)
    {
        perror("the pos is NULL\n");
        return ;
    }
    struct ListNode* sec = pos->next;
    LIST* newnode = creat_node(x);
    sec->prev = newnode;
    newnode->next = sec;
    newnode->prev = pos;
    pos->next = newnode;
}

这种链表使用起来就方便许多，在查找数据和增删查改都方便不少。

顺序表

顺序表其实就是我们常说的数组来实现的，只是一般数据都是结构体类型。
特点：可以通过下标快速访问，对尾部数据操作时比较方便，还可以进行排序等操作，但是挪动头部数据就需要较大的时间复杂度，并且会需要相对较大的内存。

顺序表也是增删查改，几个操作，可以类似

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
enum SLelments{
	NAME = 20,
	AGE = 10,
	GRADE  =6
};

//定义一个学生结构体 
struct S{
	char name[NAME];
	int age;
	int* grade;//去动态内存开辟 
};

typedef int sldata;//这里暂时将int类型定义位本次顺序表的元素类型。
//测试时可以把上面的学生结构体进行替换即可。 

struct seplist{
	sldata* a;//元素类型 
	int sz;//这个数据表有效数据个数 
	int capacity;//这个顺序表容量 
};
typedef struct seplist SEL;
void cr_SL(SEL* p);//初始化创建一个顺序表 ，结构体传地址
void des_SL(SEL* p);
void dul_SL(SEL* p);

void c_data(sldata*  t,const sldata* tem);

void first_add(SEL*p,const sldata*); 
void end_add(SEL*p,const sldata*);//尾部加一个元素 
void firdelete(SEL*p);
void enddelete(SEL*p);
void SLprint(SEL*p);
void element_intsert(SEL*p,int pos,const sldata* tem);//防止未来数据过大，传入地址 
void element_finre(SEL*p,int pos);
int finselement(SEL*p,const sldata* tem);
void element_modify(SEL*p,int pos,sldata* tem);
void cr_SL(SEL* p)//初始化创建一个顺序表 ，结构体传地址
{
	p->a = (sldata*)malloc(sizeof(sldata)*4);//初始化给四个元素 
	p->sz = 0;//有效数组任然是0； 
	p->capacity = 4;
	return; 
}
void des_SL(SEL*p){
	free(p->a);//记得置为空指针
	p->sz = 0;
	p->capacity = 4;
	return;
}
void dul_SL(SEL* p){
	p->a = (sldata*)realloc(p->a,p->capacity*2*sizeof(sldata));//二倍扩容 
	p->capacity *=2;
	return; 
}

//c_data是对数据的赋值，取决于你的数据类型在这里修改赋值 ， 
void c_data(sldata*  t,const sldata* tem){
	*t = (*tem)%11; 
	return;
}//暂时取整形，每个值赋值10以内 ,后续可在此修改,因为成员类型后续也会改变。也可以修改成函数指针的形式，让使用者自主 

 
void first_add(SEL*p,const sldata* tem){
	if(p->sz+2 > p->capacity)//考虑扩容 
	{
		dul_SL(p); 
	}
	memmove(p->a +1,p->a,sizeof(sldata)*(p->sz));
	c_data(p->a,tem);//这里传过去就是首元素 
	p->sz +=1;
	return ; 
}
void end_add(SEL*p,const  sldata* tem)//尾部加一个元素
{
	if(p->sz+2 > p->capacity)//考虑扩容 
	{
		dul_SL(p); 
	}
	c_data(&(p->a[p->sz]),tem);
	p->sz +=1;
	return ; 
} 
void firdelete(SEL*p)
{
	assert(p->sz>0);//注意检查元素个数 
	memmove(p->a,p->a+1,sizeof(sldata)*(p->sz-1));//首部删除，记得放置成空指针 
	p->sz-=1;
	p->a[p->sz]=0;
	return ; 
}
void enddelete(SEL*p)
{
	assert(p->sz>0);
	p->sz-=1;
	p->a[p->sz]=0;
	return ; 
}
void SLprint(SEL*p){
	int i=0;
	for(;i<p->sz;i++)
	{
		printf(" %d ",p->a[i]);//暂时打印整形后续换数据类型可以改变，也可以用函数去打印，，或者借助回调函数 
	}
	printf("\n");
	return ; 
}


void element_intsert(SEL*p,int pos,const sldata* tem)
{
	pos -=1;//输入下标一般是1以上的自然数 
	if(pos == 0)
	{
		first_add(p,tem); 
	 } 
	 else if(pos<=p->sz &&pos>=0 )
	 {
	 	if(p->sz+2 > p->capacity)//考虑扩容 
		{
			dul_SL(p); 
		}
	 	memmove(p->a+pos+1,p->a+pos,(p->sz-pos)*sizeof(sldata));
	 	c_data(&(p->a[pos]),tem);
		p->sz +=1;
	 }
	 else
	 {
	 	assert(0);
	 }
	 return ;
}
void element_finre(SEL*p,int pos)//给出下标删除 
{
	pos--;
	if(!(p->sz>0))
	{
		return ;
	}
	memmove(p->a+pos,p->a+pos+1,(p->sz-pos-1)*sizeof(sldata));
		p->sz -=1;
		return ; 
}


int finselement(SEL*p,const sldata* tem)
{
	int i=0;
	for(;i<p->sz;i++)
	{
		if(p->a[i]==*tem)
		{
			return i;
		}
	}
	return -1;
}

void element_modify(SEL*p,int pos,sldata* tem)
{
	
	c_data(&(p->a[pos-1]),tem);
}

上述代码可以用作参考。

总结

顺序表和链表算是各有优势，在不同的场景具备自己的优劣。熟悉物理结构和实现逻辑更加重要。在之后的队列和栈都是有帮助的。

choose_heart
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验 顺序表和链表
10-08
顺序表和链表的基本实现 数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍...
C语言链表和顺序表基本操作的头文件
03-20
链表顺序表的增删改查
数据结构顺序表和链表的相关操作
06-30
实现顺序表和链表的建立、取元素、修改元素、插入、删除等顺序表的基本操作。 设计要求: 首先设计一个含有多个菜单项的主菜单程序，然后再为这些菜单项配上相应的功能。 基本操作： 1.依次从键盘读入数据，建立...
顺序表和链表
03-26
顺序表和链表是两种基本且常用的数据结构，它们在理解和实现各种算法时起着至关重要的作用。下面将详细介绍这两种数据结构以及在VC++6.0环境下如何进行相关操作。 **顺序表** 是一种线性数据结构，它的元素在内存中...
顺序表和链表.pdf
04-24
顺序表和链表
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 274
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
(5) 深入探索Python-Pandas库的核心数据结构：Series详解
架构筑梦的Cherry Yang的博客
07-06 914
# 1. Series 简介 pandas数据结构中的Series是一个一维数组对象，能够保存任何数据类型（整数、字符串、浮点数、Python对象等），并有一个与之关联的标签序列，这些标签被称为“索引”（index）。索引与数据是一一对应的，通过索引可以快速获取、更新或删除数据。Series在pandas数据处理中起着至关重要的作用，是构建更复杂数据结构（如DataFrame）的基础。 以下是关于pandas Series的详细解释： * **定义**：Series类似于一维数组或列表，但它有一个显式的
Redis教程(二十三)：Redis的底层数据结构
十三月的博客
07-09 39
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
数据结构第07节：队列
hummhumm的专栏
07-04 553
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
数据结构双向循环链表
最新发布
picians的博客
07-09 445
printf("链表已空，无需遍历\n");printf("链表已空，无需删除\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("节点申请失败\n");printf("节点申请失败\n");
数据结构--顺序表
LH__1314的博客
06-30 4915
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
数据结构——单向循环链表
TENET123的博客
07-06 977
单向循环链表是一种特殊的单链表，其中最后一个节点的后继指针指向头节点，形成一个环。单向循环链表适合用于需要循环访问数据的场景，如约瑟夫环问题。
数据结构--单链表实现
LH__1314的博客
07-05 1126
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
【数据结构和算法的概念等】
Pumpkin_O的博客
07-09 243
又称为哈希存储，地址会通过hash算法来运算成一个相同长度的hash值，然后存放这个hash值，而不是直接存放地址，在访问关键字的时候会通过运算解码hash值，然后再访问。用一组连续的存储单元依次存储数据元素，数据元素之间的逻辑关系由元素的存储位置表示；一组值的集合以及定义于这个值集上的一组操作（如：int），原子类，结构类。用一组任意的存储单元存储数据元素，数据元素之间的逻辑关系用指针来表示；数据的存储结构是指：数据及其逻辑结构在计算机中的表示。数据的逻辑结构是指：数据之间逻辑关系的整体。
【力扣】每日一题—第217题，存在重复元素
m0_65146517的博客
07-05 249
暴力求解两重for循环直接出结果，但是超时了！如果数组中每个元素互不相同，返回。如果任一值在数组中出现。感觉自己越来越厉害了，哎，不过如此，嘿嘿嘿。
【数据结构】TreeMap及TreeSet
Chunfeng6yugan的博客
07-09 419
欢迎浏览高耳机的博客希望我们彼此都有更好的收获。
从零开始学数据结构系列之第四章《 图的遍历总代码》
铁匠匠匠的博客
07-06 1059
它的基本思想如下:首先访问图中某一起始顶点v，然后由v出发，访问与v邻接且未被访问的任一顶点,再访问与邻接且未被访问的任一顶点,重复上述过程。当不能再继续向下访问时，依次退回到最近被访问的顶点，若它还有邻接顶点未被访问过，则从该点开始继续上述搜索过程，直至图中所有顶点均被访问过为止。​   如果说图的深度优先遍历类似树的前序遍历，那么图的广度优先遍历就类似于树的层序遍历了。为了实现逐层的访问，算法必须借助一个辅助队列，以记忆正在访问的顶点的下一层顶点。​   图的遍历是和树的遍历类似，我们希望。
Redis 底层数据结构
xsgnzb的专栏
07-09 261
是列表和哈希表底层的实现之一，当只包含数字和短的字符串时，使用这个结构。由压缩列表和节点构成。压缩链表包含字节大小、尾指针偏移量、节点个数、节点列表、结束标识。编码类型包括int16、int32、int64，元素数组里的类型和编码类型相同。是有序集合的底层实现之一，由跳跃表和跳跃表节点组成。当新元素比元素数组里存放的类型比大时，会进行类型升级，重新分配空间和排序。跳跃表和平衡数的区别是，跳跃表查询复杂度平均跟平衡树一样是logn，最差是n²，但是它的实现很简单。上个节点的长度是动态的，分为1字节和5字节。
PHP数据结构之队列
likeshopgood的博客
07-09 257
队列是数据结构中的重要组成部分，尤其在多线程处理、任务调度和消息队列系统中发挥着关键作用。关于我们本文由ChatMoney团队出品，ChatMoney专注于AI应用落地与变现，我们提供全套、持续更新的AI源码系统与可执行的变现方案，致力于帮助更多人利用AI来变现，欢迎进入ChatMoney获取更多AI变现方案！
数据结构顺序表和链表
09-06
数据结构中，顺序表和链表是两种不同的存储结构。 顺序表是一种线性结构，它通过一段物理地址连续的存储单元来存储数据元素，并且采用数组的形式进行存储。顺序表在数组上完成数据的增删查改操作，同时记录表的长度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值