数据结构 从0到1 - 链表篇 (1) -搞懂链表从这篇文章开始

最新推荐文章于 2023-08-20 16:00:00 发布
置顶 最新推荐文章于 2023-08-20 16:00:00 发布
阅读量1.2k 收藏 9
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 java c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36912990/article/details/109805211
版权

数据结构 - 链表篇(1)


上篇文章是数据结构的基础部分，主要介绍了一些注意事项。

今天开始线性表部分的梳理，线性表主要分为了基础概念和基本操作两大部分，由于某些过程或概念比较抽象，我添加了部分图示，希望能够把这些抽象的东西直观的表达出来。

基本操作模块重点主要在单链表和顺序表两部分，本文着重梳理了线性表插入、删除、查询等基础方法并搭配了部分实例供参考。

1 线性表的基本概念


对于线性表来说，它是一组相同元素的有限序列，元素的个数就是线性表的长度，当元素个数为 0 时，线性表就是空表。


数据结构包括逻辑结构、存储结构和算法。线性表的基本概念这里主要看线性表的逻辑结构和存储结构就可以了。


1.1.1 线性表的逻辑结构


线性表的逻辑特性也很好理解，由于是相同元素的有限序列，可以类比生活中的排队场景：

  • 只有一个表头元素，表头元素没有前驱

  • 只有一个表尾元素，表尾元素没有后继

  • 除表头表尾元素外，其他元素都只有一个前驱和一个后继

1.1.2 线性表的存储结构


线性表的存储结构有两类：顺序表和链表。

  • 顺序表

将线性表的元素按照逻辑关系，存储到指定位置开始的一块连续的存储空间。


特性：占用一块连续的存储空间，随机读取，插入（删除）时需要移动多个元素


  • 链表

链表包含指针域与数值域两部分，因此存储不需要占用连续空间，由指针来连接记录结点位置信息，通过前驱节点的指针找到后继结点。

特性：动态分配空间，顺序读取，插入(删除)时不需要移动元素




在这里插入图片描述




  • 链表的分类：

单链表：每个节点包含数据域与指针域，单链表分为带头节点的和不带头结点的。



在这里插入图片描述



  • 带头结点的链表中，头结点的值域不含任何储存数据的信息，从头结点的下一个结点开始存储数据信息，头结点的指针 head 始终不等于 NULL，当 head -> next 等于 NULL 时，此时链表为空

  • 不带头结点的链表中，头指针直接指向第一个结点，第一个结点就开始存储数据信息，当 head 等于 NULL 时链表为空。

注意区分头结点和头指针：


头指针： 指向链表的第一个结点，无论带不带头结点都有头指针


头结点：只有带头结点的链表才有，值域只存描述链表属性的信息，此时头指针指向头结点始终不为 NULL 。


双链表


双链表在单链表的基础上添加一个指针域指向前驱结点，可以通过不同的指针域找到其前驱结点或后继节点。


  • 带头结点的双链表，类似单链表，当 head -> next 为空链表为空

  • 不带头结点的双链表 当 head 为空时链表为空

循环单链表：

在单链表的基础上，将最后一个结点的指针域指向表头结点即可。

  • 带头结点的循环单链表，当 head 等于 head -> next 时 链表为空

  • 不带头结点的循环单链表，当 head 为 空时链表为空

循环双链表：

在双链表的基础上，将最后一个结点的尾指针指向第一个结点，将第一个结点的头指针指向最后一个结点。


  • 不带头结点的循环双链表 当 head 为空时 链表为空

  • 带头结点循环双链表 当 head -> next (尾指针) 和 head -> prior （头指针） 任一一个等于 head 时 ，链表为空，事实上满足以下任一条件，链表都为空：

    head -> next = head
    head ->prior = head
    head -> next = head && head ->prior = head
    head -> next = head || head ->prior = head

静态链表


静态链表与一般链表不同，它一般来自于数组，数组中每个节点包含两个分量，一个是数据元素，一个是指针分量：


在这里插入图片描述


1.1.3 顺序表和链表的比较


  • 时间角度-存取方式

顺序表支持随机读取（查询快），时间复杂度为 O(1)，


链表只能顺序读取（查询慢）,时间复杂度为 O（n）



  • 时间角度-插入（删除）时需要移动元素的个数

顺序表需要平均需要移动近一般的元素，时间复杂度为 O（n），增删慢


链表不需要移动元素，时间复杂度为 O(1)，增删快


  • 空间角度-存储分配的方式

顺序表内存一次性分配完，占用连续存储空间


链表存储空间需要多次分配，动态分配，来一个分配一个


  • 空间角度-存储密度 (存储密度=结点值域所占存储量/结点结构所占存储量)

顺序表存储密度等于 1，链表存储密度小于 1



2 线性表的基本操作（顺序表 单链表）


2.1 结构体定义


2.1.1 顺序表

#define maxSize 100;
struct typedef 
{
	int data [maxSize];//定义顺序表存放元素的数据
	int length;    //定义顺序表的长度
}Sqlist; 			    // 顺序表类型定义

2.1.2 单链表

struct typedef ListNode
{
	int data,  // 值域
	struct ListNode *next;//指针域

}ListNode; //定义链表的结点类型

2.1.3 双链表


struct typedef DLNode
{
	int data;    //值域
	struct DLNode *prior;//前驱结点指针
	struct DLNode *next;//后继结点指针
}DLNode;//定义双链表结点类型

2.2 顺序表的操作


操作部分就要结合例题来看了，顺序表部分的操作类似 Java 中 数组的操作十分类似。


2.2.1 顺序表的插入操作

例1：已知一个顺序表 L，其中元素递增有序，设计一个算法，插入一个元素 m （int 型），后保持该顺序表仍然递增有序排列。(假设每次插入都是成功的)


分析题目可以看出两点：

1 顺序表已经排序，递增有序
2 插入 m 元素后仍然递增有序，递增排序不变

需要进行的步骤如下：

1 找出插入元素的位置
2 移动位置后面的元素 (从大下标的开始移动)
3 插入元素

图示：

在这里插入图片描述



代码：

int findElement(SqList l,int m)
{
	int i;
	for(i=0;i<l.length;++i)
	{
		if(m < l.data[i])
			{
				return i; // 找到第一个比 m 大的元素的位置返回
			}
	
	}
return i;//如果整个顺序表都不大于m，则返回最后的位置


}


void insertElement(SqList &l,int m) // 顺序表本身需要发生变化所以传入的是引用型 
{
	
	int p,i;
	p = findElement(l,m);
	
	for(i=l.length-1;i>=p;--i) // 条件为 i>=p ,p位置的元素也需要移动
	{
		l.data[i+1] = l.data[i];//从顺序表的最后开始向右移动
	}
	
	l.data[p] = m;
	
	++(l.length);

}

2.2.2 顺序表的删除操作

删除操作与插入操作相反，删除掉元素后，将后续元素都前移即可。


例2：删除顺序表L中下标为 p (0<=p<=l.length-1)的元素，成功返回 1，否则返回0，并将删除的数值赋值给 e。


分析题目可知：

1 需要删除的元素位置为 p
2 删除元素前需要将值赋值给 e

需要进行的步骤如下：

1 找到需要删除的元素的位置，题目已提供 p (如果没有提供位置，需要循环查找)

2 将删除元素 p 赋值给元素 e

3 将P后的元素左移 (与插入不同，删除要从小下标的开始移动)


​
代码：

   int deleteElement(SqList &l,int p,int &e)//需要改变的元素用引用变量
   {
   	int i;
   	if( p < 0 || p > l.length -1) return 0;
   	
   	e = l.data[p];
   	
   	for(i=p;i < l.length-1;++i){//判断条件应为 i < l.length-1 ,如果为  i < l.length  i+1 会下标越界
   		l.data[i] = l.data[i+1];
   	}
   	
   	--(l.length)

	return 1;
   }

2.3 单链表的操作


链表的相关操作是数据结构中比较常用的，这部分需要划重点。


2.3.1 单链表的插入操作

单链表的插入主要有尾插法头插法两种。


尾插法比较常规就是将新加的结点依次链接到链表最后一个结点。


尾插法:
/**
 * C 准备要插入的链表
 * a 数组，要插入到链表中的元素
 * n 将要插入的节点数
 *
 *  *&C 指针型变量在函数体中需要改变的写法
 *  顺序表 &L （ 普通变量 &m ）引用型变量需要改变的写法
 * 
 */
void createListR(ListNode *&C,int a[],int n) // 要改变的变量传引用型
{
	ListNode *s,*r; // 指针r 准备指向 C，s准备指向要插入的节点
	int i; // 循环使用的变量
	C = (ListNode*) malloc (sizeof(ListNode)); //申请 C 的头结点空间
	C -> next = NULL; // 申请头结点空间时一定不要忘记将头结点指针指向NULL
	r = C; //r 指向头节点
	for(i=0;i<n,++i)
	{
		s = (ListNode*)malloc(sizeof(ListNode));//s 指向新申请的节点
		s -> data = a[i]; // 值域赋值
		r->next = s; // 插入新的结点
		r = r->next;// 指针移动到终端结点，准备在终端插入新结点
	}

	r ->next = NULL;//插入完成后将 ，终端结点的指针域设置为NULL，C 建立完成

}

头插法则是将新加的结点始终插入在头结点的后面，因此越早插入的结点在链表中的位置实际上越靠后。


图示：

在这里插入图片描述



头插法：
/**
 * C 准备要插入的链表
 * a 数组，要插入到链表中的元素
 * n 将要插入的节点数
 *
 *  *&C 指针型变量在函数体中需要改变的写法
 *  顺序表 &L （ 普通变量 &m ）引用型变量需要改变的写法
 * 
 */
void createlistF(ListNode *&C,int a[],int n)
{
   ListNode *s;
   int i ;
   C = (ListNode *)malloc( sizeof(ListNode));
   C -> next = NULL;
   for(i=0;i<n;++i)
   {
   	s = (ListNode*)malloc(sizeof(ListNode));
    s->data = a[i];
    //头插法
    s->next = C->next;
    C->next = s;
   }

}

2.3.2 单链表的删除操作

链表的删除操作就比较简单了，要删除第m个结点，需要找到第 m-1 个结点，将第 m-1个结点的指针指向 m+1 个结点就可以了，删除操作必须要找到删除节点的上一个节点。


图示：

在这里插入图片描述



相关操作：


q = p->next;
p->next = p->next->next;
free(q);

例 3 查找链表 L(带头结点) 中是否有一个值为 m 的节点，如果有则删除该节点，返回1，否则返回0。


代码

 
 int deleteElement(ListNode *L,int m )
 {
 	ListNode *p,*q; // 定义一个指针 p，在链表中一直往下找 , q作为删除节点的
 	p = L;
 	while(p->next != NULL)
 	{
 		
 		if(p->next->data == x){ // 注意此处是 p->next->data ==x,而不是 p->next == x
 			break;
 		}
 		p = p -> next;
 	}
	
    if(p -> next == NULL)
    {
    	return 0;
    }
    else
    {
    	q = p->next; // 要删除的节点是 p->next ，q 
    	p->next = p->next->next;
    	free(q);
    	return 1;
    }
    
 
 }

2.3.3 单链表合并操作

链表的基本的查询 、插入、 删除操作的重点部分已经回顾完了，下面来看看 leetCode 的例题:


leetcode 21


题目如下：

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

思路：
1.两个链表都是升序的链表，使用一个移动指针 r 指向新链表的头结点，依次从头比较两个链表的值将
数值比较小的链接到新结点，指针r指向新结点。
2.重复以上步骤，直到两个链表指针中有任意一个移动到表尾
3.将指针未移动到表尾的链表，链接到新结点。


图解：

在这里插入图片描述
在这里插入图片描述



代码：

常规解法：
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
	
	 struct ListNode *head = (struct  ListNode*)malloc(sizeof(struct  ListNode));//申请头结点空间
  
	 struct ListNode *r = head;//定义移动指针 r ，r始终指向终端结点
   
  
     while( l1 !=NULL && l2 != NULL){

        if(l1 -> val <= l2 -> val){
            r -> next = l1;//将  r->next指向 l1
            l1 = l1->next; //l1 指针前移
            r = r->next; //r 指针前移

        }else{
            r -> next = l2;
            l2=l2 -> next;
            r = r-> next;
        }


    }
   
    r->next = NULL;
    
    if(l1 != NULL){ // 如果循环插入结束后仍有剩余结点，直接插入到末尾
        r -> next  = l1;
    }

    if(l2 != NULL){// 如果循环插入结束后仍有剩余结点，直接插入到末尾
        r -> next = l2;
    }

    return head ->next;//不用返回头结点

}

上面的解法结果没什么问题，就是我们新创建了一个头结点，如果置之不理的话，可能会导致内存泄漏。


下面是不创建头结点的解法，只是再开始的时候巧妙的使用两个链表中最小表头为新链表的头结点，后面操作类似。


不申请头结点解法：
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){	
	    if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        
        struct  ListNode *head;//定义头指针
        
        if (l1->val < l2->val){
            head = l1;  //如果 l1 表头元素值较小 ，将头指针指向l1
            l1 = l1->next;// l1 指针右移
        }else{
            head = l2;  //如果 l2 表头元素值较小 ，将头指针指向l1
            l2 = l2->next;//l2 指针右移
        }
       
        struct ListNode *r = head;
        
        // l1,l2一直向后遍历元素，向head中按序插入，直至l1或l2为NULL
        while(l1 && l2){
            if(l1->val < l2->val){
                r->next = l1;
                l1 = l1->next;
                r = r->next;
            }else{
                r->next = l2;
                l2 = l2->next;
                r = r->next;
            }
        }
        // l1或l2为NULL,此时将不会空的链表接到最后即可
        
        r->next = l1 ? l1 : l2;
        
        return head;
}

以上不同的解法都是使用了链表的尾插法，因为尾插法正好符合题目的要求，新插入的结点也是依次递增的，如果题目要求变成要求 将两个升序链表合并为一个新的 降序 链表并返回，这时使用头插法就比较合适了。


头插法：合并为一个新的 降序 链表
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){	
	struct ListNode *head = (struct  ListNode*)malloc(sizeof(struct  ListNode));//申请头结点空间
  
  	head ->next =NULL;
  
	struct ListNode *r;//定义移动指针 r ，r始终指向终端结点
   
  
     while( l1 !=NULL && l2 != NULL){

        if(l1 -> val <= l2 -> val){
            r = l1; // r 指针指向 l1 结点
            l1 = l1->next;//l1 结点右移
            r->next = head -> next ;//r->next 指向头结点的下一个结点，图 3.1
            head ->next = r; // 将 r 赋值给头结点的下一个结点
       

        }else{
            r = l2;
            l2 = l2->next;
            r->next = head->next;
            head->next = r;
        }

    }
    
    while(l1){ // 如果循环插入结束后仍有剩余结点，循环插入到头结点后
         r = l1;
         l1 = l1->next;
         r->next = head -> next ;
         head ->next = r;
    }

    while(l2){// 如果循环插入结束后仍有剩余结点，循环插入到头结点后
         r = l2;
         l2 = l2->next;
         r->next = head->next;
         head->next = r;
    }

    return head ->next;//不用返回头结点
	   
}

以上就是本文的所有内容了，最后的例题只是抛砖引玉，单链表的好多复杂的操作，有兴趣的可以去找题刷刷~


最后，顺序表和单链表的操作还是比较重要的，后续双链表、循环链表的操作基本都是在单链表的基础上演变而来的，搞懂以上基础部分，其他的演变自然也就迎刃而解了。



PS：下面是最后例题的可运行代码，可直接运行：


#include <stdio.h>
#include <malloc.h>

//构造结构体
typedef struct ListNode
{
	int data;
	struct ListNode *next;
}ListNode;


//函数声明

//初始化链表函数
ListNode* initList(ListNode *head,int num);

//初始化链表函数
ListNode* initListData(ListNode *head,int a[],int num);

//打印链表
void printList(ListNode *head);
//合并两个链表
ListNode* mergeTwoList(ListNode *l1,ListNode *l2);


void main()
{


struct ListNode *l1,*l2,*r;


l1 = ( ListNode*)malloc(sizeof( ListNode));



//l1 = initList(l1,3);
int a[] = { 1,2,3 };
l1 = initListData(l1,a,3);

l2 = ( ListNode*)malloc(sizeof( ListNode));


//l2 = initList(l2,5);
int b[] = { 2,4,6};

l2 = initListData(l2,b,3);

r = mergeTwoList(l1,l2);

printList(r);

}

ListNode* initList(ListNode *head,int num)
{
int i = 1;
struct ListNode *p = head;
while(i <= num)
{
struct ListNode *s;
s = (ListNode*)malloc(sizeof(ListNode));
s->data = i * num;
s->next = NULL;
p->next = s;
p = p->next;
i++;
}
return head->next;
}


ListNode* initListData(ListNode *head,int a[],int num)
{
int i = 0;
struct ListNode *p = head;
while(i < num)
{
	struct ListNode *s;
	s = (ListNode*)malloc(sizeof(ListNode));
	s->data = a[i];
	s->next = NULL;
	p->next = s;
	p = p->next;
	i++;
}

p->next  = NULL;

return head->next;
}





//链表输出函数

void printList(ListNode *head)
{

	struct ListNode *p = head;
	
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
	}

	printf("\n");


}
	
	

//两个有序链表的合并

ListNode* mergeTwoList(ListNode *l1,ListNode *l2)
{
	  struct ListNode *head = ( ListNode*)malloc(sizeof(ListNode));//申请头结点空间
  
	  struct ListNode *r = head;//定义移动指针 r ，r始终指向终端结点
   
  
     while( l1 !=NULL && l2 != NULL){

        if(l1 -> data <= l2 -> data){
            r -> next = l1;//将  r->next指向 l1
            l1 = l1->next; //l1 指针前移
            r = r->next; //r 指针前移

        }else{
            r -> next = l2;
            l2=l2 -> next;
            r = r-> next;
        }


    }
   
    r->next = NULL;
    
    if(l1 != NULL){ // 如果循环插入结束后仍有剩余结点，直接插入到末尾
        r -> next  = l1;
    }

    if(l2 != NULL){// 如果循环插入结束后仍有剩余结点，直接插入到末尾
        r -> next = l2;
    }

    return head ->next;//不用返回头结点

}

在这里插入图片描述

--The End --
大数据江湖
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
火影推荐程序连载72- 线性表的存储结构
li123128的博客
11-18 148
今天开始线性表部分的梳理，线性表主要分为了基础概念和基本操作两大部分，由于某些过程或概念比较抽象，我添加了部分图示，希望能够把这些抽象的东西直观的表达出来。 基本操作模块重点主要在单链表和顺序表两部分，本文着重梳理了线性表插入、删除、查询等基础方法并搭配了部分实例供参考。 1 基本概念 对于线性表来说，它是一组相同元素的有限序列，元素的个数就是线性表的长度，当元素个数为 0 时，线性表就是空表。 数据结构包括逻辑结构、存储结构和算法。线性表的基本概念这里主要看线性表的逻辑结构和存...
链表的概念以及相关基础操作
qq_61597023的博客
03-10 961
链表的定义，初始化，创建，打印，插入，删除，合并，反转操作实现
单链表(适合新手理解)
weixin_45074721的博客
10-27 927
这是一个带头结点的单链表，之前学的单链表头结点数据域都没怎么用，这里头结点的数据域保存链表长度。 核心就是利用头结点的长度来进行循环，找到任意你想去的结点位置，然后就可以随意进行各种操作了。假设头结点下标为0， 第一个元素下标就是1，以此类推， 头结点不考虑， 元素个数就是最后一个元素的下标，跟平时数组不一样， 这里第几个元素它的下标就是几，如下图 先讲一下核心代码： int length = p->data; //这里保存头结点数据域，也就是链表长度 for (int i = 1; i <
算法范本：链表
qq_42138662的博客
07-09 540
一、链表基础 链表的基础操作包括链表的创建和增删查改。其中链表的索引index一般从0开始。这里有以下几点需要注意： 链表是一个类，节点结构体是类中的一个私有结构体 对于一个链表，其私有数据需要包括节点结构体，虚拟头结点，节点数量 对于节点结构体，需要在定义结构体的时候需要定义构造函数，且不要忘记结构体定义最后的;号 对于链表，需要在public中定义链表的初始化构造函数 class MyLinkedList { private: /---链表依赖的基础结构：节点，节点数量，虚拟头结点---/
结构体的内存
weixin_51713937的博客
08-15 1991
结构体内存 一、概念 结构体占的是一片连续的内存空间，大小由其变量类型决定 二、结构体内存布局 1、变量类型相同时 type nums struct { a int //8字节 b int //8 c int //8 } func main(){ var zNums nums fmt.Printf("%d", unsafe.Sizeof(zNums))//24个字节 } 此时各字段的内存大小是相同的，一共为24个字节，但是字段类型也有不相同的时候，如下点。 2、变量类型不相同
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
数据结构从入门到精通-顺序表
最新发布
03-02
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和组织数据，以便进行各种操作。在所有数据结构中，顺序表是最基础的一种，适用于初学者理解和掌握。本篇文章将深入探讨顺序表的概念、实现、操作以及其在...
c语言链表的排序算法-排序链表最快的算法是什么？.pdf
04-07
在这篇文章中，我们将讨论链表排序算法的性能分析和优化。我们将比较不同的排序算法，包括合并排序和快速排序，并分析它们在链表中的性能。 首先，让我们讨论链表排序算法的挑战。链表的节点分布在内存中，可能会...
数据结构c版（1）-线性表文章代码汇总
11-19
在这个"数据结构C版（1）- 线性表文章代码汇总"中，我们将深入研究几种基本的线性数据结构：顺序表、单链表、双向带头循环链表、栈和队列。这些数据结构在算法设计和程序实现中扮演着重要角色。 首先，我们来看**...
数据结构_链表的分类_数据结构_
10-02
本篇文章将深入探讨链表的分类及其在数据结构中的应用。 链表主要分为以下几种类型： 1. 单链表：单链表是最基础的链表形式，每个节点包含两个部分——数据域和指针域。数据域存储实际的数据，而指针域存储下一个...
链表
qq_41965731的博客
10-04 430
根据尚硅谷的韩顺平老师的数据结构视频总结的笔记 观看视频的网址 一、链表的介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 1、单链表介绍 单链表（带头节点）逻辑结构如下图： 2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 ..
[数据结构]单链表(从0-＞1)
分享技术
08-19 665
学会单链表，看此篇，‘’有手就行”？
数据结构-链表（详解）
weixin_73142957的博客
05-11 2431
前言：内容包括：链表的分类，无头单向非循环链表的增删查改的实现，带头双向循环链表的增删查改的实现
【数据结构】链表
热门推荐
knous
03-13 6万+
链表
顺序表与链表
qq_45942662的博客
08-14 455
定义与特点 线性表定义：由0个或多个数据元素组成的有限序列。 顺序表：线性表的顺序存储结构。优点是查找，缺点是插入与删除。–优化–>单链表：优点：插入删除，缺点：查找（须从头到尾）–优化–>循环链表和双链表（还有双向循环）。 数组是从0开始而线性表是从1开始。 顺序表基操 顺序存储结构是把逻辑上相邻的节点存储在物理位置上相邻的存储单元中，结点之间的逻辑关系从物理上存储位置相邻得到体现。顺序存储结构的主要优点是节省存储空间，因为数据结点之间的逻辑关系没有占用额外的存储空间。另一个优点是可实现对结点
数据结构之链表详解
m0_56440500的博客
08-20 3827
链表是一种常见的数据结构，它可以用来存储一组数据，并支持快速的插入和删除操作。相比于数组，链表的大小可以动态地增加或减小，因此在某些场景下更加灵活和高效。本文将详细介绍链表的定义、基本操作和应用场景，希望能够帮助读者深入理解链表的原理和实现。链表是一种线性数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表中的节点可以在内存中任意位置，因此它们不必按照顺序连续存储。链表的头节点是第一个节点，尾节点是最后一个节点，它们分别由指向第一个节点和最后一个节点的指针来表示。
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5068
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
[数据结构] 链表(图文超详解讲解)
积跬步以至千里
09-30 3149
根据本文对链表的介绍后大家能对链表有更深的理解相信大家在过后时间能够保持求学的态度,我们一起加油!offer拿到手软!对博主感兴趣可以关注博主,我会继续更新博客,努力完善我的文章内容不会辜负大家的期待!
数据结构之——链表
xqx_999的博客
10-06 4224
链表的介绍，单链表和双向链表的接口实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值