【数据结构】-----链表（无头单向非循环链表的实现+常见链表面试题）

已于 2022-11-11 18:14:27 修改
阅读量541 收藏 12
点赞数 16
分类专栏： # 数据结构 文章标签： 链表 数据结构 c语言
于 2022-10-04 18:43:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55752775/article/details/127145366
版权

目录

一、链表的概念及结构

二、链表的实现

无头+单向+非循环链表增删查改实现

三、顺序表和链表的优缺点

四、链表常见的面试题

1. 删除链表中等于给定值 val 的所有节点

2. 反转一个单链表。

3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个 中间结点。

4. 输入一个链表，输出该链表中倒数第k个结点。

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

6. 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

7. 链表的回文结构。

8. 输入两个链表，找出它们的第一个公共结点。

9. 给定一个链表，判断链表中是否有环。

10. 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL 

11. 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。 要求返回这个链表的深度拷贝。

一、链表的概念及结构


概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

逻辑结构：想象出来的，为了便于理解。

物理结构：在内存中实际是如何存储的

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向、双向 

 2. 带头、不带头 

  3. 循环、非循环 

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结 构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

二、链表的实现

无头+单向+非循环链表增删查改实现

SList.h ---函数的声明


#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDataType;
typedef struct SListNode {
	SLTDataType data;
	struct SlistNode* next;
}SLTNode;
void SListPrint(SLTNode* phead);
//链表后插入节点
void SListPushBack(SLTNode** pphead,SLTDataType x);
//链表前插入节点
void SListPushFront(SLTNode** pphead, SLTDataType x);
//链表后删除节点
void SListPopBack(SLTNode** pphead);
//链表前删除节点
void SListPopFront(SLTNode** pphead);
//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//在pos位置之前插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在pos位置之前插入一个节点
void SListInsertAfter(SLTNode* pos, SLTDataType x);
void SListErase(SLTNode** pphead, SLTNode* pos);
void SListEraseAfter(SLTNode* pphead, SLTNode* pos);
void SListDestory(SLTNode** pphead);
//void SListInsert(SLTNode**pphead, int pos, SLTDataType x);

SList.c ---函数的实现

#include "SList.h" 
SLTNode* BuyListNode(SLTDataType x) 
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("%s\n", "malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;

}
void SListPrint(SLTNode* phead) 
{
	assert(phead);
	SLTNode* cur = phead;
	while (cur != NULL) 
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
void SListPushBack(SLTNode** pphead, SLTDataType x) 
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	
	if (*pphead == NULL) 
	{
		*pphead = newnode;
	}
	else 
	{
		//找到尾节点
		SLTNode* tail = *pphead;
		while (tail->next != NULL) 
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
	
	
}
void SListPushFront(SLTNode** pphead, SLTDataType x) 
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void SListPopBack(SLTNode** pphead)
{
	assert(*pphead);
	//只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next!= NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
	prev->next = NULL;
	}
	
	 
	/*SLTNode* tail = *pphead;
	while (tail->next->next)
	{
		tail = tail->next;
	}
	free(tail->next);
	tail->next = NULL;*/
}
void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead=next;
}
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}
//在pos位置之后去插入一个节点(更适合单链表，更简单)  O(1)
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	 newnode->next=pos->next ;
	 pos->next = newnode;
}
//在pos位置之前去插入一个节点 O(n)
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		//找到pos的前一个位置
		SLTNode* posPrev = *pphead;
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}
		posPrev->next = newnode;
		newnode->next = pos;
	}
	
}
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	if (*pphead == pos)
	{
		/* *pphead = pos->next;
		free(pos);*/
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}
void SListEraseAfter(SLTNode* pphead, SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	//next = NULL;
}
void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead == NULL;
}

三、顺序表和链表的优缺点

顺序表
优点：
1、支持随机访问。需要随机访问结构支持算法可以很好的适用。
2、cpu高速缓存命中率更高。

缺点：
1、头部中部插入删除时间效率低。O(n)
2、连续的物理空间，空间不够了以后需要增容。
         a、增容有一定的程序消耗
         b、为了避免频繁增容，一般我们都按倍数去增，用不完可能存在一定的空间浪费。


链表（双向带头循环链表）
优点：
1、任意位置插入删除效率高.O(1)
2、按需申请释放空间。

缺点：
1、不支持随机访问。（用下标访问）意味着：一些排序、二分查找等在这种结构上不适用。
2、链表储存一个值，同时需要存储链接指针，也有一定的消耗。
3、cpu高速缓存率更低。

四、链表常见的面试题

1. 删除链表中等于给定值 val 的所有节点

移除链表元素https://leetcode.cn/problems/remove-linked-list-elements/

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

struct ListNode* removeElements(struct ListNode* head, int val){

    Struct ListNode* cur=head;
     Struct ListNode* prev=NULL;
     
     while(cur!=NULL)
     {
         //1.头删
         //2.中间删除
         if(cur->val==val)
         {
             if(cur==head)
            {

                head=cur->next;
                free(cur);
                cur=head;

            }
            else{
                 prev=cur->next;
                free(cur);
                cur=prev->next;
            }
            
         }
         else
         {
             //迭代往后走
             prev=cur;
             cur=cur->next;
         }
     }
}

2. 反转一个单链表。

反转链表https://leetcode.cn/problems/reverse-linked-list/

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表

 思路一：将链表直接翻转

struct ListNode* reverseList(struct ListNode* head){
    if(head==NULL)
        return NULL;
    struct ListNode*n1=NULL;
    struct ListNode*n2=head;
    struct ListNode*n3=head->next;

    while(n2)
    {
        //翻转
        n2->next=n1;
        //迭代往后走
        n1=n2;
        n2=n3;
        if(n3)
             n3=n3->next;
    }
    return n1;
}

反转链表思路二：创建一个新的头节点，头插。

struct ListNode* reverseList(struct ListNode* head){
   
    struct ListNode*newhead=NULL;
    struct ListNode*cur=head;
    

    while(cur)
    {
        struct ListNode*next=cur->next;
        //头插
        cur->next=newhead;
        newhead=cur;
        //迭代往后走
        cur=next;
    }
    return newhead;
}

 3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个 中间结点。

链表的中间结点https://leetcode.cn/problems/middle-of-the-linked-list/

思路：可以直接遍历一遍计算出链表的长度，再遍历一遍找到 长度/2 的位置，时间复杂度是O(n).

快慢指针法：定义一个快指针，一个慢指针，快指针走两步，慢指针走一步，当快指针走到最后一个节点（链表的元素是奇数个）或者走到空时（链表的元素是偶数个），慢指针走到的位置就是中间节点。

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode*fast,*slow;
    fast=head;
    slow=head;

    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

4. 输入一个链表，输出该链表中倒数第k个结点。

思路：1.fast先走k步  2.slow和fast再一起走，fast==NULL时，slow就是倒数第k个节点 

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode*fast,*slow;
    fast=slow=pListHead;
    while(k--)
    {
        //k大于链表的长度
        if(fast==NULL)
            return NULL;
        fast=fast->next;
    }
    while(fast)
    {
        fast=fast->next;
        slow=slow->next;
    }
    return slow;
}

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

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode*head=NULL;
    struct ListNode*tail=NULL;
    //如果一个链表为空，返回另一个链表
    if(list2==NULL)
        return list1;
    if(list1==NULL)
        return list2;

     /*//取两个链表第一个节点中较小的那一个作为头节点
    if(list1->val<list2->val)
    {
        head=tail=list1;
        list1=list1->next;
    }
    else
    {
        head=tail=list2;
        list2=list2->next;
    }*/

    //哨兵位的头节点
    head=tail=(struct ListNode*)malloc(sizeof(struct ListNode));

    while(list1&&list2)
    {
        if(list1->val<list2->val)
        {
            tail->next=list1;
            tail=list1;
            list1=list1->next;
        }
        else
        {
            tail->next=list2;
            tail=list2;
            list2=list2->next;
        }
    }
    if(list1)
    {
        tail->next=list1;
    }
    if(list2)
    {
        tail->next=list2;
    }
    struct ListNode* list = head->next;
    return list;
}

6. 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

 ListNode* partition(ListNode* pHead, int x) {
        struct ListNode *lessHead,*greaterHead,*lessTail,*greaterTail;

        //开一个哨兵位的头节点，方便尾插
        lessHead=lessTail=(struct ListNode*)malloc(sizeof(struct ListNode));
        lessTail->next=NULL;

        greaterHead=greaterTail=(struct ListNode*)malloc(sizeof(struct ListNode));
        greaterTail->next=NULL;

        struct ListNode*cur= pHead;
        while(cur)
        {
            if(cur->val<x)
            {
                lessTail->next=cur;
                lessTail=cur;
                
            }
            else{
                greaterTail->next=cur;
                greaterTail=cur;
                
            }
            cur=cur->next;  
        }
        lessTail->next=greaterHead->next;
        greaterTail->next=NULL;//如果不将偏大的链表置为空，可能会形成环

        struct ListNode*listHead=lessHead->next;
        free(lessHead);
        free(greaterHead);
        return listHead;

    }

7. 链表的回文结构。

 思路：1.找到链表的中间节点  2.将链表的后半部分逆置  3.将链表的前半部分和逆置后的后半部分链表进行比较

//找到中间节点
struct ListNode* middleNode(struct ListNode* head){
    struct ListNode*fast,*slow;
    fast=head;
    slow=head;

    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

//逆置
struct ListNode* reverseList(struct ListNode* head){
   
    struct ListNode*newhead=NULL;
    struct ListNode*cur=head;
    

    while(cur)
    {
        struct ListNode*next=cur->next;
        //头插
        cur->next=newhead;
        newhead=cur;
        //迭代往后走
        cur=next;
    }
    return newhead;
}

 bool chkPalindrome(ListNode* A) {
        struct ListNode*mid=middleNode(A);
        struct ListNode*RHead=reverseList(mid);

        struct ListNode*curA=A;
        struct ListNode*curR=RHead;
        while(curA&&curR)
        {
            if(curA->val!=curR->val)
            {
                return false;
            }
            else{
                curA=curA->next;
                curR=curR->next;
            }
        }
        return true;
}

8. 输入两个链表，找出它们的第一个公共结点。

思路一：

暴力求解---穷举(O(n^2))

依此取A链表中的每个节点跟B链表中的所有节点比较，如果有地址相同的节点，就是相交，第一个相交的节点就是第一个公共节点。

思路二：（要求时间复杂度优化到O(n)）

1.尾节点相同就是相交(单链表相交尾节点一定相同，因为一个节点只能存一个指针，呈横着的“Y”)，否则就是不相交。

2.求交点：长的链表从头先走长度差步，再同时走，第一个相同的节点就是交点。

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *tailA=headA;
    struct ListNode *tailB=headB;

    int lenA=1;
    while(tailA->next)
    {
        ++lenA;
        tailA=tailA->next;
    }

     int lenB=1;
     while(tailB->next)
    {
        ++lenB;
        tailB=tailB->next;
    }

    //不相交
    if(tailA!=tailB)
        return NULL;

    //长的链表先走差距步，再同时走找交点
    int gap=abs(lenA-lenB);//abs--求绝对值
    struct ListNode *longList=headA;
    struct ListNode *shortList=headB;
    if(lenA<lenB)
    {
        longList=headB;
        shortList=headA;
    }

    while(gap--)
    {
        longList=longList->next;
    }
    while(longList!=shortList)
    {
        longList=longList->next;
        shortList=shortList->next;
    }
    return longList;
}

9. 给定一个链表，判断链表中是否有环。

141. 环形链表https://leetcode.cn/problems/linked-list-cycle/

思路：

快慢指针法：slow和fast指向链表的开始，slow一次走一步，fast一次走两步，如果不带环，fast就会走到空，如果带环，fast就会再环里面追上slow。

bool hasCycle(struct ListNode *head) {
    struct ListNode *fast=head,*slow=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
            return true;
    }
    return false;
}

问题：

1.当fast一次走两步，slow一次走一步时，为什么slow和fast一定会在环中相遇吗？如果是，请证明。

slow和fast,一定是fast先进环，这时slow走了入环前距离的一半，随着slow进环，fast已经在环里面走了一段，走的距离跟环的大小有关。假设slow进环的时候，slow和fast的距离是N，fast开始追slow,slow每往前走一步，fast往前走两步，每追一次，判断是否相遇。追及过程中，fast和slow的距离变化：N,N-1,N-2,N-3....1,0。每追一次，fast和slow的距离就减少1，当fast和slow的距离为0是，就是相遇的点。

2.能不能fast走一次走n步(n>2),当fast一次走n步时，slow和fast是否能够相遇？

假设slow一次走一步，fast一次走三步，slow进环以后，fast跟slow之间的距离为N，fast开始追slow，他们的距离变化：当N时偶数时：N,N-2,N-4,N-6....2,0，这时fast可以追上slow；当N时奇数时：N,N-2,N-4,N-6....1,-1，这时fast追不上slow。如果N是奇数，距离变成-1意味着fast和slow的距离变成C-1(C是环的长度)，如果C-1是奇数，就永远追不上了，如果C-1是偶数，就可以追上。

10. 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL 

环形链表 IIhttps://leetcode.cn/problems/linked-list-cycle-ii/

结论：一个指针从相遇点开始走，一个指针从链表头开始走，他们会在环的入口点相遇。

证明：

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *fast=head,*slow=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
        {
                //相遇
            struct ListNode * meetnode=slow;
        
            while(meetnode!=head)
            {
                head=head->next;
                meetnode=meetnode->next;
            }
            return meetnode;
        }
    }
    return NULL;
}

11. 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。 要求返回这个链表的深度拷贝。

38. 复制带随机指针的链表https://leetcode.cn/problems/copy-list-with-random-pointer/

思路： 

struct Node* copyRandomList(struct Node* head) {
    //拷贝节点插入原节点的后面
	struct Node*cur=head;
    while(cur)
    {
        struct Node* copy=(struct Node*)malloc(sizeof(struct Node));
        copy->val=cur->val;

        //插入copy节点
        copy->next=cur->next;
        cur->next=copy;

        cur=copy->next;
    }
    //根据原节点，处理copy节点的random
    cur=head;
    while(cur)
    {
         struct Node*copy=cur->next;
        if(cur->random==NULL)
        {
             copy->random=NULL;
        }
           
        else
        {
             copy->random=cur->random->next;
        }
           

        cur=copy->next;
    }

    //将copy节点解下来链接成新链表，恢复原链表
    struct Node* copyHead=NULL, *copyTail=NULL;
    cur=head;
    while(cur)
    {
        struct Node*copy=cur->next;
        struct Node*next=copy->next;

        if(copyTail==NULL)
        {
            copyHead=copyTail=copy;
        }
        else
        {
            copyTail->next=copy;
            copyTail=copy;
        }
        cur->next=next;
        cur=next;
    }
    return copyHead;
}

 做数据结构的题一定要多画图，这样逻辑才会更清晰。

想变成自大狂
关注
专栏目录
链表（一）——无头单向非循环链表实现
C、Java知识分享
08-11 373
初始链表
面试-Java一些常见面试题+题解之数据结构-DataStructure.zip
最新发布
03-03
本资料包"面试-Java一些常见面试题+题解之数据结构-DataStructure.zip"聚焦于Java中的数据结构，旨在帮助求职者更好地准备面试。下面我们将详细探讨其中可能涉及到的一些关键知识点。 1. **数组**： - 数组是最...
创建非循环链表
qq_37677421的博客
06-16 250
/* 2017年6月16日 09:13:09   创建非循环链表   (disunderstand 2) */ #include #include #include typedef struct Node {  int data;  struct Node * pNext; }NODE, *PNODE; //函数声明 PNODE create_list(int
单链表的程序实现
dididisailor的博客
11-16 355
#include<stdio.h> //#include<malloc.h> #include<stdlib.h> typedef struct Node { int data; struct Node * pnext; }NODE, * PNODE; PNODE create_list() { PNODE phead=(PNODE)malloc(sizeof(NODE));
无头单向非循环链表
qq_65285898的博客
08-27 273
单链表的实现
单向非循环链表
qq_41213290的博客
02-18 138
带一个头节点的单向非循环链表实现 C语言结构体实现 typedef int SLTDataType; typedef struct SListNode //链表中的每一个节点 { SLTDataType _data; //链表储蓄的数据 struct SListNode* _next; //指向下一个节点 }SListNode; typedef struct SList //链表...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
链表是一种线性数据结构，其中元素以节点的形式存储，每个节点包含数据和指向下一个节点的引用。在单链表中，每个节点只有一个指向后继节点的指针，而链表的末尾节点指向null。在C#中，可以使用类`Link`来表示链表...
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
- **链表分类**：在实际应用中，最常见的链表类型是无头单向非循环链表（常作为其他数据结构的子结构）和带头双向循环链表（用于独立存储数据）。 - **链表的实现**：链表节点通常包含数据和指向下一个节点的指针...
算法大全-面试题-链表-栈-二叉树-数据结构
05-25
### 算法大全-面试题-链表-栈-二叉树-数据结构 #### 单链表 单链表是一种线性数据结构，其中的每个元素包含一个指向其后继元素的链接。单链表是算法和数据结构学习的基础之一，并且是面试时常见的考察对象。 ### ...
[最新整理公布][汇总II]微软等数据结构+算法面试100题[第1-80题]
11-20
以上四个知识点覆盖了从二叉树转换到双向链表、特殊栈的设计、求解最大子数组和、以及在二叉树中寻找特定路径等问题，这些问题是数据结构与算法面试中的常见题型，对于理解基本的数据结构原理及其应用有着重要的意义...
无头单向链表
lxy_zzZ的博客
03-07 152
#define _CRT_SECURE_NO_WARNINGS 1 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;assert.h&gt; typedef int SLDataType; //无头单向链表结构体 typedef struct SListNode{ SLDataType data; struct...
C语言实现非循环单链表
lxshann的博客
06-05 383
学习到了数据结构中的链表，写此文档方便自己加固理解，加深记忆。 链表 链表与数组同为线性结构，但是区别于数组。在定义数组时存储的大小必须是已知，并且在内存分配中是必须连续的，所以可以使用下标随机访问。 链表在内存中的分配非常灵活，但也就无法进行随机访问，必须遍历，顺序访问链表中的某一个节点。 节点：链表中存放有效数据的单位。 头节点：在单链表的第一个结点之前附设一个结点，称之为头结点。 ...
链表之无头单向非循环链表（Java语言）
qq_57563254的博客
11-21 846
链表（Java语言）前言链表的概念及结构无头单向非循环链表节点类——ListNode链表类——MyLinkedList打印链表查找是否包含关键字获取链表的长度（节点的个数）插入一个节点——头插法 前言 上篇博客中介绍了顺序表有关的知识，我们知道顺序表增加，删除某个元素都需要移动其他元素，增加了时间复杂度；顺序表空间不够用又需要我们进行扩容，导致可能造成空间上的浪费，增加了空间复杂度，因此有必要优化顺序表，因此我们引入链表的概念。 链表的概念及结构 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是
牛客网现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。
weixin_44436675的博客
01-11 1217
题目描述 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。 代码： import java.util.*; /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Par
【数据结构】链表之无头单向非循环链表
田怼怼的博客
02-15 227
链表的特点是：物理地址不连续 数据元素的逻辑顺序是通过链表中的指针链接次序实现的 链表 链表的结构：链表由数据域和指针域两部分组成，数据域是存储数据元素的部分，指针域一般指向下一个节点的指针。 链表的优点 在进行插入和删除操作时比较方便 链表的缺点 存储密度小，空间利用率低 要访问某特定元素，只能从链表开头进行遍历 头结点的作用 为了保持和后面结点的设计算法一致，保持算法的高效性 链表共...
数据结构、手写双向非循环链表
lsplook的博客
08-22 188
Java中数组是对线性结构，也是顺序存储结构的具体实现。Java中数组会在内存中开辟大小固定，地址连续的空间，数组中的数据具有从前往后的顺序。1.链表的存储分类为链式结构，非连续的空间。2.链表第一个节点称为头节点，最后一个节点称为尾节点。栈（Stack）是一种存储受限的线性结构。其具体实现可以用链表或数组。栈只允许从一侧进行操作数据，这侧称为栈顶（top）。另一侧称为栈底(bottom)。往栈中放入元素的过程称为：入栈（push）。从栈中删除元素的过程称为：出栈（pop）。先进后出。
【数据结构：链表】——无头单向非循环链表的实现（C语言）
紫阳战君的博客
07-28 383
1、什么是链表？ 链表：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 详细了解： 链表的详解 注： 实际上链表的结构是多样的，总共有8种链表结构。 1.单项、双向 2.带头、不带头 3.循环、不循环 虽然有八种数据结构但是生活中我们常用的结构也就是这两种链表结构：无头单向非循环链表、带头双向循环链表。 无头单向非循环链表：...
【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~
codewinter的博客
08-28 2837
文章目录（1）链表介绍1）为什么引入链表2）链表的概念及结构3）链表的分类（2）无头单向非循环链表的实现1）单链表的定义2）动态申请一个节点3）打印单链表4）单链表尾插5）单链表头插6）单链表尾删7）单链表头删8）在单链表中查找指定值的节点9）单链表在pos位置之后插入10）单链表删除指定pos位置的节点11）单链表删除指定pos位置之后的节点12）求单链表长度13）判断单链表是否为空12）求单链表长度13）判断单链表是否为空 学习链表之前，建议先学习下顺序表，配合这篇文章食用更佳哦： 【数据结构入门】顺序
无头单向非循环链表（C语言实现）
qq_61939403的博客
03-20 3138
文章目录：链表引入链表介绍三级目录 链表引入 问：上次我们看了顺序表，那么顺序表有些什么优缺点呢？ 优点： 顺序表是连续的物理空间，方便下标的随机访问。 缺点： 1.增容需要申请新空间，拷贝数据，释放旧的空间。会有一定消耗。 2.头部或者中间位置插入或者删除数据，需要挪动数据，效率较低。 3.可能存在一定空间占用，浪费空间，不能按需申请和释放空间。 为了解决上诉问题，我们引入了链表。首先我们先来看看单链表。 链表介绍 链表是一种物理存储结构上非连续、非顺序的存储结构、数据元素的逻辑顺序是通过链表中的指针链接
链表与数据结构面试题集锦：反转、查找、合并等
"算法大全-面试题-链表-栈-二叉树-数据结构" 在IT面试中，数据结构和算法是考察候选人技术能力的重要部分。本资源主要涵盖了与链表、栈、二叉树相关的经典面试题，帮助求职者准备这些关键知识点。 1. **单链表操作...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值