【数据结构】链表总结

最新推荐文章于 2024-01-22 13:14:10 发布
最新推荐文章于 2024-01-22 13:14:10 发布
阅读量244 收藏
点赞数
分类专栏： 毕业生-必看系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dai_wen/article/details/81672158
版权

一、链表逆置

1、题目、已知一链表，求将其逆置后的链表
2、代码实现

#include<iostream>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
};

class solution
{
public:
	ListNode* reverseList(ListNode* head)
	{
		ListNode* newhead =NULL ;
		while( head )
		{
			ListNode* pNode = head->next ;
			head->next = newhead;
			newhead = head;
			head = pNode;
		}
		return newhead;
	}

};

int main()
{
	ListNode a;
	ListNode b;
	ListNode c;
	ListNode d;
	ListNode e;
	ListNode f;
	ListNode g;
	a.val =1;
	b.val =2;
	c.val =3;
	d.val =4;
	e.val =5;
	f.val =6;
	g.val =7;
	a.next =&b;
	b.next =&c;
	c.next =&d;
	d.next =&e;
	e.next =&f;
	f.next =&g;
	g.next =NULL;
	solution solve;
	printf("原链表长度为：");
	ListNode*phead = &a;
	while(phead)
	{
		printf("%d ",phead->val );
		phead = phead->next ;
	}
	printf("\n逆序后链表为：");
	phead = solve.reverseList (&a);
	while(phead)
	{
		printf("%d ",phead->val );
		phead = phead->next ;
	}
	return 0;
}

3、程序结果

1.2.1、题目：已知一链表，将从m到n之间的节点逆置，并打印逆置后链表

1.2.2程序实现

#include<iostream>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
};

class solution
{
public:
	ListNode* reverseList(ListNode* head,int m,int n)
	{
		int change_len =  n - m +1;
		ListNode* result = head;
		ListNode* pre = NULL;

		while(head && --m)
		{
			pre = head;
			head = head->next ;
		}
		ListNode* newhead = NULL;
		ListNode* modify_list_tail = head;
		while( head && change_len)
		{
			ListNode* pNode = head->next ;
			head->next = newhead;
			newhead = head;
			head = pNode;
			change_len--;
		}

		modify_list_tail->next = head;

		if(pre)
		{
			pre->next = newhead;
		}

		return result;
	}

};

int main()
{
	ListNode a;
	ListNode b;
	ListNode c;
	ListNode d;
	ListNode e;
	ListNode f;
	ListNode g;
	a.val =1;
	b.val =2;
	c.val =3;
	d.val =4;
	e.val =5;
	f.val =6;
	g.val =7;
	a.next =&b;
	b.next =&c;
	c.next =&d;
	d.next =&e;
	e.next =&f;
	f.next =&g;
	g.next =NULL;
	solution solve;
	printf("原链表打印为：");
	ListNode*phead = &a;
	while(phead)
	{
		printf("%d ",phead->val );
		phead = phead->next ;
	}
	printf("\n逆序后链表为：");
	phead = solve.reverseList (&a,3,6);
	while(phead)
	{
		printf("%d ",phead->val );
		phead = phead->next ;
	}
	return 0;
}

1.2.3程序结果

二、求两个链表的交点

2、题目：已知链表A的头节点head1，链表B的节点head2，两个链表相交，求相交节点

2.1.1程序实现

#include<iostream>
#include<set>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
	ListNode(int x)
		:val(x)
		,next(NULL)
	{}
};

class solution
{
public:
	ListNode* FindTheCrossPoint(ListNode* head1,ListNode* head2)
	{
		std::set<ListNode*> node_set;
		while(head1)
		{
			node_set.insert(head1);
			head1 = head1->next ;
		}
		while(head2)
		{
			if( ( node_set.find(head2) )!= node_set.end())
			{
				return head2;
			}
			head2 = head2->next ;
		}
	    return NULL;
	}
	
};
void print(ListNode*head)
{
	while(head)
	{
		printf("%d ",head->val );
		head = head->next ;
	}

}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	ListNode f(6);
	ListNode g(7);

	a.next =&b;
	b.next =&c;
	c.next =&d;
	d.next =NULL;
	e.next =&f;
	f.next =&g;
	g.next =&c;
	solution solve;
	
	ListNode*phead1 = &a;
	printf("phead1打印为：");
	print(phead1);

	ListNode* phead2 = &e;
	printf("\nphead2打印为：");
	print(phead2);

	printf("\n相交链表为：");
	ListNode* phead = solve.FindTheCrossPoint(phead1,phead2);
	print(phead);
	return 0;
}

2.1.2程序结果

2.2第二种解法
2.2.1程序实现

#include<iostream>
#include<set>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
	ListNode(int x)
		:val(x)
		,next(NULL)
	{}
};

class solution
{
public:
	int Length(ListNode* head)
	{
		int count  = 0;
		while(head)
		{
			++count;
			head = head->next ;
		}
		return count;
	}

	ListNode* Forward(int Long_len ,int Short_len, ListNode* head)
	{
		int dis = Long_len - Short_len;
		while(head && dis)
		{
			head = head->next ;
			--dis;
		}
		return head;
	}
	ListNode* FindTheCrossPoint(ListNode* head1,ListNode* head2)
	{
		
		int len_head1 = Length(head1);
		int len_head2 = Length(head2);

		if(len_head1 > len_head2)
		{
			head1 = Forward(len_head1, len_head2, head1);
		}
		else
		{
			head2 = Forward(len_head2,len_head1, head2);
		}

		while(head1 && head2)
		{
			if(head1 == head2)
			{
				return head1;
			}

			head1 = head1->next ;
			head2 = head2->next ;
		}
		return NULL;
	}
	
};
void print(ListNode*head)
{
	while(head)
	{
		printf("%d ",head->val );
		head = head->next ;
	}

}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	ListNode f(6);
	ListNode g(7);

	a.next =&b;
	b.next =&c;
	c.next =&d;
	d.next =NULL;
	e.next =&f;
	f.next =&g;
	g.next =&c;
	solution solve;
	
	ListNode*phead1 = &a;
	printf("phead1打印为：");
	print(phead1);

	ListNode* phead2 = &e;
	printf("\nphead2打印为：");
	print(phead2);

	printf("\n相交链表为：");
	ListNode* phead = solve.FindTheCrossPoint(phead1,phead2);
	print(phead);
	return 0;
}

2.2.2程序结果

三、链表求环

3.题目:已知链表可能存在环，若有，返回环的起始节点，没有返回NULL
3.1使用STL中set实现
3.1.1程序实现

#include<iostream>
#include<set>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
	ListNode(int x)
		:val(x)
		,next(NULL)
	{}
};

class solution
{
public:
	ListNode* FindTheCircle(ListNode* head)
	{
		std::set<ListNode*> node_set;
		while(head)
		{
			if(node_set.find(head)!= node_set.end())
			{
				head->next =NULL;
				return head ;
			}
			node_set.insert(head);
			head = head->next ;
		}
		return NULL;
	}
	
};
void print(ListNode*head)
{
	while(head)
	{
		printf("%d ",head->val );
		head = head->next ;
	}

}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	ListNode f(6);
	ListNode g(7);

	a.next =&b;
	b.next =&c;
	c.next =&d;
	d.next =&e;
	e.next =&f;
	f.next =&g;
	g.next =&c;
	solution solve;
	
	ListNode*phead1 = &a;
	printf("\n环的入口节点为：");
	ListNode* head = solve.FindTheCircle(phead1);
	print(head);
	return 0;
}

3.1.2程序结果

3.2使用快慢指针思想实现
3.2.1程序实现

#include<iostream>
using namespace std;
struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
    	ListNode *fast = head;
    	ListNode *slow = head;
    	ListNode *meet = NULL;
    	while(fast){
    		slow = slow->next;
    		fast = fast->next;
    		if (!fast){
		    	return NULL;
		    }
		    fast = fast->next;
		    if (fast == slow){
    			meet = fast;
    			break;
    		}
	    }
	    if (meet == NULL){
    		return NULL;
    	}
    	while(head && meet){
	    	if (head == meet){
	    		return head;
	    	}
	    	head = head->next;
	    	meet = meet->next;
	    }
        return NULL;
    }
};

int main(){
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	ListNode f(6);
	ListNode g(7);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = &f;
	f.next = &g;
	g.next = &c;
	Solution solve;
	ListNode *node = solve.detectCycle(&a);
	if (node){
		printf("%d\n", node->val);
	}
	else{
		printf("NULL\n");
	}
	return 0;
}

3.2.2程序结果

四、链表划分

4.1题目:已知链表的头指针head与数值X，将所有小于X的数，全部放在大于X或者等于X的节点前,并且保持这些节点的原来相对位置。
4.1.2程序实现

#include<iostream>
using namespace std;

struct ListNode
{
	int val;
	ListNode* next;
	ListNode(int x)
		:val(x)
		,next(NULL)
	{}
};

class solution
{
public:
	ListNode* partion(ListNode* head,int x)
	{
		ListNode less_head(0);//注意
		ListNode more_head(0);
		ListNode* less_ptr = &less_head;//注意
		ListNode* more_ptr = &more_head;

		while(head)
		{
			if(head->val >= x )
			{
				more_ptr->next = head;
				more_ptr = head;
			}
			else
			{
				less_ptr->next = head;
				less_ptr = head;
			}

			head = head->next ;
		}
		less_ptr->next = more_head.next ;
		more_ptr->next = NULL;
		return less_head.next  ;
	}
	
};
void print(ListNode*head)
{
	while(head)
	{
		printf("%d ",head->val );
		head = head->next ;
	}

}
int main()
{
	ListNode a(1);
	ListNode b(4);
	ListNode c(3);
	ListNode d(2);
	ListNode e(5);
	ListNode f(2);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = &f;
	f.next = NULL;
	printf("原链表打印为：");
	print(&a);
	solution solve;
	printf("\n链表划分应为：");
	ListNode*head = solve.partion(&a,3);
	print(head);
	

	return 0;
}

4.1.2程序结果

五、复杂链表的深度拷贝

5.1题目：已知一个复杂链表，每个节点有两个指针，一个指向下一个节点，另一个是指向本链表的任意一个节点的随机指针，求这个链表的深度拷贝
5.2程序实现

#include<iostream>
#include<map>
#include<vector>
using namespace std;

struct ListNode
{
	int val;
	ListNode* next;
	ListNode* random;
	ListNode(int x)
		:val(x)
		,next(NULL)
		,random(NULL)
	{}
};

class solution
{
public:
	ListNode* copyRandom(ListNode* head)
	{
		std::map<ListNode*,int> node_map;
		std::vector<ListNode*> node_vec;
		ListNode* ptr = head;
		int i = 0;
		while(ptr)//将节点装入vector中，并使得map形成地址映射
		{
			node_vec.push_back(new ListNode(ptr->val));
			node_map[ptr] = i;
			ptr = ptr->next ;
			i++;
		}
		node_vec.push_back (0);

		ptr = head;//再次遍历链表，
		i = 0;
		while(ptr)
		{
			node_vec[i] ->next = node_vec[i+1];//将节点链接起来
			if(ptr->random )//将指针指好
			{
				int id = node_map[ptr->random ];
				node_vec[i]->random = node_vec[id];
			}
			ptr = ptr->next ;
			i++;
		}
		return node_vec[0];

	}
	
};
void print(ListNode*head)
{
	while(head)
	{
		printf("%d ",head->val );
		head = head->next ;
	}

}
int main(){
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;	
	a.random = &c;
	b.random = &d;
	c.random = &c;
	e.random = &d;	
	solution solve;
	ListNode *head = solve.copyRandom(&a);	
	while(head)
	{
		printf("val = %d ", head->val);
		if (head->random)
		{
			printf("rand = %d\n", head->random->val);
		}
		else
		{
			printf("rand = NULL\n");
		}
		head = head->next;
	}
	return 0;
}

5.3程序结果

六、两个链表的合并

6.1题目:已知两个已排序头节点指针head1,head2,将这两个链表合并，使得合并后链表也是有序的，并且返回合并后的头节点
6.2程序实现

#include<iostream>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
	ListNode(int x)
		:val(x)
		,next(NULL)
	{}
};

class solution
{
public:
	ListNode* MergeTwoList(ListNode* head1,ListNode* head2)
	{
		ListNode  temp(0);
		ListNode* temp_head = &temp;

		while(head1 && head2)
		{
			if(head1->val < head2->val )
			{
				temp_head->next  = head1;
				head1= head1->next ;
			}
			else
			{
				temp_head->next = head2;
				head2 = head2->next ;
			}
			temp_head = temp_head->next ;
		}
		if(head1)
		{
			temp_head->next = head1;
		}
		if(head2)
		{
			temp_head->next = head2;
		}

		return temp.next ;
	}
	
};
void print(ListNode*head)
{
	while(head)
	{
		printf("%d ",head->val );
		head = head->next ;
	}

}
int main()
{
	ListNode a(1);
	ListNode b(3);
	ListNode c(5);
	ListNode d(7);
	ListNode e(2);
	ListNode f(4);
	ListNode g(6);

	a.next =&b;
	b.next =&c;
	c.next =&d;
	d.next =NULL;
	e.next =&f;
	f.next =&g;
	g.next =NULL;
	solution solve;
	
	ListNode*phead1 = &a;
	printf("phead1打印为：");
	print(phead1);

	ListNode* phead2 = &e;
	printf("\nphead2打印为：");
	print(phead2);

	printf("\n合并后链表为：");
	ListNode* phead = solve.MergeTwoList(phead1,phead2);
	print(phead);
	return 0;
}

6.3程序结果

##七、 k个已排序的链表合并 ##
7.1题目:已知k个已派序链表头节点指针，将这K个链表合并，合并后仍为有序的，返回合并后的头节点
7.1.1利用vector实现，将所有的链表节点都放在vector中，在将vector中的每个节点排序，最后实现

7.1.2程序实现

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
	ListNode(int x)
		:val(x)
		,next(NULL)
	{}
};


void print(ListNode*head)
{
	while(head)
	{
		printf("%d ",head->val );
		head = head->next ;
	}

}

bool cmp(const ListNode *a,const ListNode* b)
{
	return a->val <b->val ;
}
int main()
{
	ListNode a(1);
	ListNode b(3);
	ListNode c(5);
	ListNode d(7);

	ListNode e(2);
	ListNode f(4);
	ListNode g(6);


	ListNode h(8);
	ListNode i(9);
	ListNode j(11);

	ListNode k(10);
	ListNode l(15);
	ListNode m(17);
	ListNode n(19);


	a.next =&b;
	b.next =&c;
	c.next =&d;
	d.next =NULL;

	e.next =&f;
	f.next =&g;
	g.next =NULL;

	h.next = &i;
	i.next = &j;
	j.next = NULL;

	k.next = &l;
	l.next = &m;
	m.next =&n;
	n.next =NULL;

	std::vector<ListNode*> node_vec;
	node_vec.push_back(&a);
	node_vec.push_back(&b);
	node_vec.push_back(&c);
	node_vec.push_back(&d);

	node_vec.push_back(&e);
	node_vec.push_back(&f);
	node_vec.push_back(&g);

	node_vec.push_back(&h);
	node_vec.push_back(&i);
	node_vec.push_back(&j);


	node_vec.push_back(&k);
	node_vec.push_back(&l);
	node_vec.push_back(&m);
	node_vec.push_back(&n);
	std::sort(node_vec.begin(),node_vec.end(),cmp);

	
	ListNode*phead1 = &a;
	printf("phead1打印为：");
	print(phead1);

	ListNode* phead2 = &e;
	printf("\nphead2打印为：");
	print(phead2);

	ListNode*phead3 = &h;
	printf("\nphead3打印为：");
	print(phead3);

	ListNode*phead4 = &k;
	printf("\nphead4打印为：");
	print(phead4);

	printf("\n合并后链表为 ：");
	for(int i = 0; i<node_vec.size();i++)
	{
		printf("%d ",node_vec[i]->val );
	}
	return 0;
}

7.1.2程序结果

7.2.1使用map进行地址映射

7.2.2程序实现

#include <stdio.h>

struct ListNode {
 	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

#include <vector>
#include <algorithm>

bool cmp(const ListNode *a, const ListNode *b){
	return a->val < b->val;
}

class Solution {
public:
    ListNode* mergeKLists(std::vector<ListNode*>& lists) {
        std::vector<ListNode *> node_vec;        
        for (int i = 0; i < lists.size(); i++){
        	ListNode *head = lists[i];
        	while(head){
        		node_vec.push_back(head);
	        	head = head->next;
	        }
        }
        if (node_vec.size() == 0){
        	return NULL;
        }        
        std::sort(node_vec.begin(), node_vec.end(), cmp);
        for (int i = 1; i < node_vec.size(); i++){
        	node_vec[i-1]->next = node_vec[i];
        }
        node_vec[node_vec.size()-1]->next = NULL;
        return node_vec[0];
    }
};

int main(){
	ListNode a(1);
	ListNode b(4);
	ListNode c(6);
	ListNode d(0);
	ListNode e(5);
	ListNode f(7);
	ListNode g(2);
	ListNode h(3);
	a.next = &b;
	b.next = &c;	
	d.next = &e;
	e.next = &f;	
	g.next = &h;	
	Solution solve;	
	std::vector<ListNode *> lists;
	lists.push_back(&a);
	lists.push_back(&d);
	lists.push_back(&g);	
	ListNode *head = solve.mergeKLists(lists);
	while(head){
		printf("%d\n", head->val);
		head = head->next;
	}
	return 0;
}

7.2.3程序结果

长颈鹿仙女
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 链表学习总结
sumandavg的博客
11-02 1276
数据结构 其二 链表 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。 前言 线性表是数据结构中最基础也是最常见的一种结构，它像一根“线”把数据像“串珠子”一样串联了起来。根据数据在内存中是否连续，可以把线性表分为：顺序表和链表 ，本文详细介绍链表。 1. 链表介绍 1.1 什么是链表 链表（linked list），将数据如同锁链一样串联起来，每一个存储数据的节点不仅存储的数据（数据域）还存
数据结构链表总结一
zhangha0的博客
01-01 293
数据结构链表总结一         最近一直在学数据结构，刚开始学习的，觉得链表还是比较难的，今天自己写的代码贴上来分析一下#include #include #include #include "list.h" struct List { data_t data; //typedef int data_t; struct List *pNex
数据结构链表总结
Laynalute的博客
07-31 453
1.链表数据类型 typedef struct LNODE{ int data; struct LNODE *next; }LNODE,*LinkList; 指向结构体的指针。通过指针操作，来申请空间，插入数据，输出数据，释放空间。 2.创建链表 bool CreatList(LinkList &L) { LNODE *P; int x; L = (LinkList)malloc(
数据结构-链表 总结
toy_block的博客
03-28 211
总体来说链表的简单题还是比较好做的，就是好久没敲代码有些手有点生，开始有些不会敲了，但是慢慢就觉得比起以前acm的题完全不是一个档次。            但是做题后我发现虽然是水题，但是却也不是分分钟能a的，必须经过一定的推理过程，而且做题可以加深对链表的理解，比如说以前我将头尾节点的概念看的太重，动不动就觉到要想访问链表元素只能从头开始，后来我发现链表只是一组数据用链式存下来，像数组一样，
数据结构：链表总结
qq_41605114的博客
03-02 524
数据结构：单向链表Part1：https://blog.csdn.net/qq_41605114/article/details/104396149 数据结构：循环链表：https://blog.csdn.net/qq_41605114/article/details/104541315 数据结构：双向链表：https://blog.csdn.net/qq_41605114/articl...
数据结构课设报告，城市链表
08-09
数据结构课设报告——城市链表 1. 课程设计目标与任务 ...总结，本课程设计旨在提升学生对数据结构中链表的理解和应用能力，通过实现城市链表，学习了链表的基本操作，并锻炼了问题解决和文档撰写的能力。
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
数据结构链表：单链表的代码实现
最新发布
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
JAVA 数据结构链表操作循环链表
09-01
在Java编程中，数据结构是程序设计的基础，链表是一种常用的数据结构，它不依赖于数组的物理位置，而是通过节点间的引用关系进行组织。循环链表是链表的一种变体，它的特点是最后一个节点指向了链表的第一个节点，...
数据结构（链表）-总结
m0_50502677的博客
01-22 883
这篇文章以及代码都是在某培训机构学完数据结构之后，自己根据课程重新写了一点代码总结。文章和代码中如有谬误，敬请指出！1.简化定义语句，提高可读性在使用 typedef后，结构体变量的定义由原先的简化为，尤其在结构体名字较长时，可以使代码更为简洁，提高可读性。2.增强代码的可维护性和复用性通过使用 typedef定义数据类型的别名，代码在变更数据类型时变得更具灵活性。例如，若需将数据域的类型修改为 char，使用 typedef。
数据结构—链表（总结）
白夜行
12-01 732
链表 一、增删 1.增 在链表中插入一个目标节点keyNode （1）在链表尾插入：直接找到最后一个节点lastNode,使得lastNode.next=keyNode （2）在链表中间插入，特别是插入节点后要保持链表的有序性的问题：需要找到插入的位置，比如要查到mNode和nNode之间，那么： mNode.next=keyNode   ,  keyNode.next=nNode
数据结构学习之链表总结
birdexplore的博客
04-06 140
数据结构总结之链表（一）
sofia_fhx的博客
03-14 347
线性表 （1）顺序存储结构（数组，必须连续空间） 优点： 不需要为表中元素之间的逻辑结构添加额外的存储空间 可以快速的存取表中任一位置的元素 缺点： 插入和删除操作需要移动大量元素 当线性表长度变化比较大时，难以确定存储空间的容量 易造成存储空间的 “碎片 ” （2）链式存储结构（连续或不连续，由数据域和指针域组成，称为结点） 头指针与头节点异同： 头指针具有标识作用，常以头指针冠以链表的名字 ...
数据结构——链表（学习总结）
LQwraith的博客
04-20 426
链表基本概念 1.什么是链表 与数组相似，链表也是一种线性数据结构。 链表是一种逻辑顺序是连续的但物理存储单元上非连续、非顺序的存储结构。 引用力扣上的一张图加以解释： 在链表中，每个元素本身是一个单独的结构。 2.链表的类型 上图所示为单链表。还有种双向指向的双链表。如图： 本文重点介绍单链表。 3.链表的优缺点 与链表同为线性结构的数组相比起来有利有弊。 优点：操作简便，不需要知道具体位置，只需要知道附近的指针指向的地址。 缺点：创建复杂 单链表 1.初始化 链表是通过以结构体为节点，然后将
数据结构之链表 思路总结
MuqiuWhite的博客
03-29 442
如果对你有帮助，请一键三连（点赞+收藏+关注）哦~ 感谢支持！欢迎各位在评论区与博主友好讨论！缓慢更新中……
数据结构-几种链表的总结
viafcccy的博客
12-21 1746
数据结构链表题目总结
SDAUguo的博客
03-31 337
提交记录： 感想：学习完链表后，我就感觉它的用处一定会很大，做完这些题后，我的感触就更加深刻了，我发现他能解决原来好多不能解决的问题，比如说它可以在实现数组的功能的同时，还能够节约空间，因为数组大小是死的，只能一口气申请很大的空间，而链表却是活的，且他的位置是不需要外加条件来约束的。另外，这十个链表题真的是让我脑洞大开，不过只有自己真的思前想后又想不出来才能有这份
C语言实现单向链表动态数据结构
"本资源主要介绍了如何在C语言中...总结来说，这个资源提供了C语言实现单向链表的基础知识，包括链表节点的定义、链表的创建方法以及如何通过函数来构建链表，对于学习数据结构和C语言编程的初学者来说是非常有价值的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值