数据结构与算法之关于链表

最新推荐文章于 2024-09-07 05:15:02 发布
最新推荐文章于 2024-09-07 05:15:02 发布
阅读量415 收藏 10
点赞数 10
文章标签： 链表 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49035795/article/details/134066482
版权

不支持随机访问，因为不是连续的空间

链表的数据结构中一个存放元素 一个存放下一个元素的指针 头指针指向头结点 尾指针指向最后一个结点

#include<iostream>
using namespace std;
struct node
{
	unsigned char elem;
	node* next;
};
node* head = NULL;
node* tail = NULL;
void create_list(unsigned char elem);
void insert_node(int pos, unsigned char elem);
void delete_node(int pos);
void print_linklist(void);
int search(unsigned char elem);

int main()
{
	create_list('a');
	create_list('b');
	create_list('c');
	print_linklist();
	insert_node(0, 'd');
	print_linklist();
	delete_node(0);
	print_linklist();
	return 0;
}
void create_list(unsigned char elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
	{
		head = p;
	}
	else
	{
		tail->next = p;
	}
	tail = p;
}
//插入分三种情况
void insert_node(int pos, unsigned char elem)
{
	node* pre = NULL;
	pre = head;
	node* p = new node;
	int i = 0;
	if (pos == 0) //插入第一个
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while (i<pos-1)
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == NULL)//插入最后一个元素
		{
			tail = p;
		}
	}
}
//也是分三种情况
void delete_node(int pos)
{
	node* pre = head;
	node* p = NULL;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == NULL)
		{
			tail = pre;
		}
		delete p;
	}
}
void print_linklist(void)
{
	node* p = NULL;
	for (p = head; p != NULL; p = p->next)
	{
		cout << p->elem;
	}
	cout << endl;
}
int search(unsigned char elem)
{
	node* p;
	for (p = head; p; p = p->next)
	{
		if (p->elem == elem)
		{
			return 1;
		}
	}
	return 0;
}

链表应用一：合并有序链表

其他的基础基本不变

思想：1.创建两个链表存储两组数据 

           2.再创建两个遍历指针比较大小

           3.将比较大小后的数字放进一个新的链表中

#include<iostream>
using namespace std;
struct node
{
	unsigned int elem;
	node* next;
};
node* head = NULL;
node* tail = NULL;
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(node*head);
int search(unsigned int elem);

int main()
{
	node* head1 = nullptr;
	node* head2 = nullptr;
	create_list(1);
	create_list(9);
	create_list(13);
	create_list(27);
	head1 = head;
	print_linklist(head1);
	head = nullptr;
	create_list(3);
	create_list(5);
	create_list(14);
	create_list(81);
	create_list(88);
	create_list(95);
	create_list(99);
	head2 = head;
	print_linklist(head2);
	head = nullptr;
	node* p1 = head1;
	node* p2 = head2;
	//任意数组为空的时候跳出循环
	while (p1&&p2)
	{
		if (p1->elem <= p2->elem)
		{
			if (head == nullptr)
			{
				head = p1;
			}
			else
			{
				tail->next = p1;
			}
			tail = p1;
			p1 = p1->next;
		}
		else
		{
			if (head == nullptr)
			{
				head = p2;
			}
			else
			{
				tail->next = p2;
			}
			tail = p2;
			p2 = p2->next;
		}
	}
	//p1为空时连接p2，否则连接p1
	tail->next = p1 ? p1 : p2;
	print_linklist(head);
	return 0;
}
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
	{
		head = p;
	}
	else
	{
		tail->next = p;
	}
	tail = p;
}
//插入分三种情况
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	node* p = new node;
	int i = 0;
	if (pos == 0) //插入第一个
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while (i<pos-1)
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == NULL)//插入最后一个元素
		{
			tail = p;
		}
	}
}
//也是分三种情况
void delete_node(int pos)
{
	node* pre = head;
	node* p = NULL;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == NULL)
		{
			tail = pre;
		}
		delete p;
	}
}
void print_linklist(node*head)
{
	node* p = NULL;
	for (p = head; p != NULL; p = p->next)
	{
		cout << p->elem<<" ";
	}
	cout << endl;
}
int search(unsigned int elem)
{
	node* p;
	for (p = head; p; p = p->next)
	{
		if (p->elem == elem)
		{
			return 1;
		}
	}
	return 0;
}

链表应用二：删除链表重复元素

输入范围0~9 10个数

1 2 1 4 5 4  ===》1 2 4 5

思考：如何标记已经出现的数字呢？

辅助数组，下标=要检索的内容   元素：状态（显示是否出现）

 出现0 代表没有出现过   1代表出现过

100个数的话就100个大小（数组） 相当于下标对应数

#include<iostream>
using namespace std;
struct node
{
	unsigned int elem;
	node* next;
};
node* head = NULL;
node* tail = NULL;
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(node*head);
int search(unsigned int elem);
void delete_repeat(node* head);
int main()
{
	create_list(1);
	create_list(2);
	create_list(8);
	create_list(2);
	create_list(3);
	create_list(9);
	create_list(4);
	create_list(6);
	create_list(4);
	create_list(8);
	create_list(7);
	create_list(5);
	create_list(2);
	create_list(9);
	create_list(6);
	print_linklist(head);
	delete_repeat(head);
	print_linklist(head);
	return 0;
}
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
	{
		head = p;
	}
	else
	{
		tail->next = p;
	}
	tail = p;
}
//插入分三种情况
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	node* p = new node;
	int i = 0;
	if (pos == 0) //插入第一个
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while (i<pos-1)
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == NULL)//插入最后一个元素
		{
			tail = p;
		}
	}
}
//也是分三种情况
void delete_node(int pos)
{
	node* pre = head;
	node* p = NULL;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == NULL)
		{
			tail = pre;
		}
		delete p;
	}
}
void print_linklist(node*head)
{
	node* p = NULL;
	for (p = head; p != NULL; p = p->next)
	{
		cout << p->elem<<" ";
	}
	cout << endl;
}
int search(unsigned int elem)
{
	node* p;
	for (p = head; p; p = p->next)
	{
		if (p->elem == elem)
		{
			return 1;
		}
	}
	return 0;
}
void delete_repeat(node* head)
{
	int flag[10] = { 0 };
	node* p = head;
	node* q = nullptr;
	flag[p->elem] = 1;
	while (p->next!=nullptr)
	{
		if (flag[p->next->elem] == 0)
		{
			flag[p->next->elem] = 1;
			p = p->next;
		}
		else
		{
			q = p->next;
			p->next = q->next;
			delete (q);
		}
	}
}

应用三：查找链表的中间节点

#include<iostream>
using namespace std;
struct node
{
	unsigned int elem;
	node* next;
};
node* head = NULL;
node* tail = NULL;
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(node* head);
int search(unsigned int elem);
int find_mid(node* head);
int main()
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	create_list(8);
	create_list(9);
	create_list(10);
	print_linklist(head);
	cout << find_mid(head);
	return 0;
}
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
	{
		head = p;
	}
	else
	{
		tail->next = p;
	}
	tail = p;
}
//插入分三种情况
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	node* p = new node;
	int i = 0;
	if (pos == 0) //插入第一个
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == NULL)//插入最后一个元素
		{
			tail = p;
		}
	}
}
//也是分三种情况
void delete_node(int pos)
{
	node* pre = head;
	node* p = NULL;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == NULL)
		{
			tail = pre;
		}
		delete p;
	}
}
void print_linklist(node* head)
{
	node* p = NULL;
	for (p = head; p != NULL; p = p->next)
	{
		cout << p->elem << " ";
	}
	cout << endl;
}
int search(unsigned int elem)
{
	node* p;
	for (p = head; p; p = p->next)
	{
		if (p->elem == elem)
		{
			return 1;
		}
	}
	return 0;
}
int find_mid(node* head)  
{
	node* p1 = head; //快指针
	node* p2 = head;//慢指针
	while (p1 != NULL && p1->next != NULL)//注意这块不能写反 否则会访问冲突
	{
		p1 = p1->next->next;
		p2 = p2->next;
	}
	return p2->elem;
}

while (p1 != NULL && p1->next != NULL)//注意这块不能写反 否则会访问冲突

 应用四：找到链表中倒数第n个结点的内容

思想：快慢指针

快指针总比慢指针多走n-1步

#include<iostream>
using namespace std;
struct node
{
	unsigned int elem;
	node* next;
};
node* head = NULL;
node* tail = NULL;
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(node* head);
int search(unsigned int elem);
int find_last_nth(node* head,int n);
int main()
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	create_list(8);
	create_list(9);
	create_list(10);
	print_linklist(head);
	cout << find_last_nth(head,5);
	return 0;
}
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
	{
		head = p;
	}
	else
	{
		tail->next = p;
	}
	tail = p;
}
//插入分三种情况
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	node* p = new node;
	int i = 0;
	if (pos == 0) //插入第一个
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == NULL)//插入最后一个元素
		{
			tail = p;
		}
	}
}
//也是分三种情况
void delete_node(int pos)
{
	node* pre = head;
	node* p = NULL;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == NULL)
		{
			tail = pre;
		}
		delete p;
	}
}
void print_linklist(node* head)
{
	node* p = NULL;
	for (p = head; p != NULL; p = p->next)
	{
		cout << p->elem << " ";
	}
	cout << endl;
}
int search(unsigned int elem)
{
	node* p;
	for (p = head; p; p = p->next)
	{
		if (p->elem == elem)
		{
			return 1;
		}
	}
	return 0;
}
int find_last_nth(node* head,int n)
{
	node* p1 = head;//快指针
	node* p2 = head;//慢指针
	for (int i = 0; i < n - 1; i++)
	{
		p1 = p1->next;
	}
	while (p1->next!=NULL)
	{
		p1 = p1->next;
		p2 = p2->next;
	}
	return p2->elem;
}

应用五：逆置单链表

#include<iostream>
using namespace std;
struct node
{
	unsigned int elem;
	node* next;
};
node* head = NULL;
node* tail = NULL;
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(node* head);
int search(unsigned int elem);
void reverse_linklist(node* head);
int main()
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	create_list(8);
	create_list(9);
	create_list(10);
	print_linklist(head);
	reverse_linklist(head);
	print_linklist(head);
	return 0;
}
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
	{
		head = p;
	}
	else
	{
		tail->next = p;
	}
	tail = p;
}
//插入分三种情况
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	node* p = new node;
	int i = 0;
	if (pos == 0) //插入第一个
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == NULL)//插入最后一个元素
		{
			tail = p;
		}
	}
}
//也是分三种情况
void delete_node(int pos)
{
	node* pre = head;
	node* p = NULL;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == NULL)
		{
			tail = pre;
		}
		delete p;
	}
}
void print_linklist(node* head)
{
	node* p = NULL;
	for (p = head; p != NULL; p = p->next)
	{
		cout << p->elem << " ";
	}
	cout << endl;
}
int search(unsigned int elem)
{
	node* p;
	for (p = head; p; p = p->next)
	{
		if (p->elem == elem)
		{
			return 1;
		}
	}
	return 0;
}
void reverse_linklist(node* head1)
{
	node* n = NULL;
	node* p = head1->next;
	head1->next = NULL;
	while (p->next!=NULL)
	{
		n = p->next;
		p->next = head1;
		head1 = p;
		p = n;
	}
	p->next = head1;
	head1 = p;
	head = head1;
}

循环链表：

收尾相连

创建、插入、删除、查找都需要微改一点

#include<iostream>
using namespace std;
struct node
{
	unsigned int elem;
	node* next;
};
node* head = NULL;
node* tail = NULL;
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(node* head);
int search(unsigned int elem);
int main()
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	create_list(8);
	create_list(9);
	create_list(10);
	print_linklist(head);
	return 0;
}
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
	{
		head = p;
	}
	else
	{
		tail->next = p;
	}
	tail = p;
	tail->next = head;
}
//插入分三种情况
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	node* p = new node;
	int i = 0;
	if (pos == 0) //插入第一个
	{
		p->elem = elem;
		p->next = head;
		head = p;
		tail->next = head;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == head)//插入最后一个元素
		{
			tail = p;
		}
	}
}
//也是分三种情况
void delete_node(int pos)
{
	node* pre = head;
	node* p = NULL;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
		tail->next = head;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == head)
		{
			tail = pre;
		}
		delete p;
	}
}
void print_linklist(node* head)
{
	node* p = head;
	//这里不行因此想到用do先循环一次
	/*for (p = head; p != head; p = p->next)
	{
		cout << p->elem << " ";
	}*/
	do
	{
		cout << p->elem << " ";
		p = p->next;
	} while (p!=head);
	cout << endl;
}
int search(unsigned int elem)
{
	node* p;
	//用do
	/*for (p = head; p; p = p->next)
	{
		if (p->elem == elem)
		{
			return 1;
		}
	}*/
	do
	{
		p = head;
		if (p->elem == elem)
		{
			return 1;
		}
		p = p->next;
	} while (p!=head);
	return 0;
}

循环列表应用一：经典笔试题，约瑟夫环

//头文件
#include<iostream>
using namespace std;
#pragma once
extern struct node* head;
extern struct node* tail;

struct node
{
	unsigned int elem;
	node* next;
};
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(void);
int search(unsigned int elem);
#include"linklist.h"
node* head=NULL;
node* tail=NULL;
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	if (head == NULL)
		head = p;
	else
		tail->next = p;
	tail = p;
	tail->next = head;
}
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	int i = 0;
	node* p = new node;
	if (pos == 0)  //插到最前面
	{
		p->elem = elem;
		p->next = head;
		head = p;
		tail->next = head;
	}
	else
	{
		while (i < pos - 1)//其他情况
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
		if (p->next == head) //插最后面
			tail = p;
	}
}
void delete_node(int pos)
{
	node* pre = NULL, * p = NULL;
	pre = head;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		delete pre;
		tail->next = head;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next == head)  //删除末尾
			tail = pre;
		delete p;
	}
}
void print_linklist(void)
{
	node* p = NULL;
	p = head;
	do 
	{
		cout << p->elem<<" ";
		p = p->next;
	} while (p != head);
	cout << endl;
}
int search(unsigned int elem)
{
	node* p = NULL;
	p = head;
	do
	{
		if (p->elem == elem)
			return 1;
		p = p->next;
	} while (p != head);

	return 0;
}
#include<iostream>
using namespace std;
#include"linklist.h"
//循环列表
int main()
{
	int n = 0, k = 0, m = 0;
	int i = 0;
	node* p = NULL, * q = NULL;
	cout << "请输入人数" << endl;
	cin >> n;
	for (i = 1; i <= n; i++)
	{
		create_list(i);
	}
	print_linklist();
	p = head;
	cout << "请输入从第几人开始" << endl;
	cin >> k;
	while (--k)
		p = p->next;
	cout << "数到的报数人数m" << endl;
	cin >> m;
	if (1 == m)
	{
		for (i = 0; i < n; i++)
		{
			cout << p->elem;
			p = p->next;
		}
		cout << endl;
	}
	else
	{
		while (n--)
		{
			for (i = 1; i < m - 1; i++)
				p = p->next;
			q = p;
			p = p->next;
			cout << p->elem;
			q->next = p->next;
			//delete p;
			p = p->next;
		}
		cout << endl;
	}
	return 0;
}

双向链表：

//头文件
#include<iostream>
using namespace std;
#pragma once
extern struct node* head;
extern struct node* tail;

struct node
{
	unsigned int elem;
	node* next;
	node* pre;
};
void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(void);
int search(unsigned int elem);
void reverse_print_linklist();//反转
//源文件
#include"linklist.h"
node* head=NULL;
node* tail=NULL;
void create_list(unsigned int elem)
{
	node* p = new node;
	p->elem = elem;
	p->next = NULL;
	p->pre = NULL;
	if (head == NULL)
		head = p;
	else
	{
		tail->next = p;
		p->pre = tail;
	}
	tail = p;
}
void insert_node(int pos, unsigned int elem)
{
	node* pre = NULL;
	pre = head;
	int i = 0;
	node* p = new node;
	if (pos == 0)  //插到最前面
	{
		p->elem = elem;
		p->next = head;
		head->pre = p;
		p->pre = NULL;
		head = p;
	}
	else
	{
		while (i < pos - 1)//其他情况
		{
			pre = pre->next;
			i++;
		}
		p->elem = elem;
		p->pre = pre;
		p->next = pre->next;
		if (p->next != NULL)
			pre->next->pre = p;
		pre->next = p;

		if (p->next == NULL)
			tail = p;
	}
}
void delete_node(int pos)
{
	node* pre = NULL, * p = NULL;
	pre = head;
	int i = 0;
	if (pos == 0)
	{
		head = head->next;
		head->pre = NULL;
		delete pre;
	}
	else
	{
		while (i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
		p = pre->next;
		pre->next = p->next;
		if (p->next != NULL)  //删除末尾
			p->next->pre = pre;
		else//if(p->next == NULL)
			tail = pre;

		delete p;
	}
}
void print_linklist(void)
{
	node* p = NULL;
	p = head;
	for (p; p; p = p->next)
		cout << p->elem << " ";
	cout << endl;
}
int search(unsigned int elem)
{
	struct node* p;

	for (p = head; p; p = p->next)
		if (p->elem == elem)
			return 1;
	return 0;

}
void reverse_print_linklist()
{
	struct node* p;

	for (p = tail; p; p = p->pre)
		cout << p->elem << " ";
	cout << endl;
}

#include<iostream>
using namespace std;
#include"linklist.h"
//循环列表
int main()
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	reverse_print_linklist();
	return 0;
}

上善若水__
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++数据结构与算法之反转链表的方法详解
01-20
本文实例讲述了C++数据结构与算法之反转链表的方法。分享给大家供大家参考，具体如下： 算法概述：要求实现将一条单向链表反转并考虑时间复杂度。 算法分析： 数组法(略)： 将列表元素逐个保存进数组，之后再逆向...
JavaScript数据结构与算法之链表
11-26
链表是一种常见的数据结构，也属于线性表，但不会按线性的顺序来储存数据。而是在每一个节点中，储存了下一个节点的指针。可以看图理解。(有C语言基础的可能比较好理解)。 使用链表结构可以克服数组需要预先知道数据...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
Java数据结构与算法——双向链表
★★光亭★★
03-11 6137
Java数据结构与算法——双向链表
数据结构与算法之双链表的操作
dearQiHao的博客
10-12 2142
双链表的操作 /* 实现双链表的构建、初始化、数据添加（在指定位置添加）、数据删除（删除指定元素，并返回该元素的位置）的算法设计； */ #include<iostream> #include<Windows.h> using namespace std; typedef struct _DoubleLink { int data; struct _DoubleLi...
数据结构与算法之链表
努力让自己发光，对的人才能迎着光而来
08-24 1万+
单链表 概念 单链表操作 循环链表 概念 循环链表操作 双向循环链表 概念 双向循环链表操作单链表 概念 单链表操作 实现类： 测试类： 循环链表 概念 循环链表操作 实现类： 测试类： 双向链表 概念 双向链表操作 实现类： 测试类： ...
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Java数据结构与算法——单向链表
★★光亭★★
03-11 5881
Java数据结构与算法——单向链表
数据结构与算法-链表（练习一）
LoveXming的博客
03-12 1431
数据结构与算法-链表练习
Java数据结构与算法之链表插入操作
m0_43405302的博客
10-29 1879
一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构，关于Java链表的定义以及数据实例化，请查看数据结构之数组和链表（Java语言描述）。 二、插入元素操作 在介绍插入元素之前，我先对数据进行进行节点实例化。首先，我们建立n1、n2和n3的三个节点，其中n1的后继节点是n2，现在我们想把n3插入其中。这样我们有三种插入方式： class ListNode{ int val; //节点值 ListNode next; //后续节点使用 ListNode(int x){val=x;} } Li
数据结构与算法四：链表
qq_38837032的博客
01-29 1601
一、链表（linked list）特性： 链表是一种真正的动态的数据结构；（head、next） 链表的数据结构属于线性结构，但是存储结构属于链式存储结构，非顺序存储，而是每个节点（node）里存下一个节点的指针 使用链表可以克服数组需要预先知道数据大小的缺点，可以存储不同的数据类型，但是增加了指针域，空间开销大 链表允许在链表任意位置插入node或移除node，但是不允许随机存取 链表有很多类型：单向链表、双向链表及循环链表 二、单链表定义： 注：在《数据结构与算法分析》这本书中，线性结构用的是结点，而
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
C语言：刷题笔记
weixin_45930573的博客
09-04 389
c语言刷题记录
【C++】STL—vector的使用
2301_77112794的博客
09-04 680
本文介绍了vector重点函数接口的使用
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1084
vector的简单模拟实现！！！
C语言 | Leetcode C语言题解之第389题找不同
最新发布
m0_59237910的博客
09-07 441
C语言 | Leetcode C语言题解之第389题找不同
C语言 ——— #define 定义宏
weixin_55341642的博客
09-04 817
a + b 的和 于 b - a 的差 做乘法，a + b = 8 ，b - a = 2。#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称宏。在宏中的每个变量都加上了括号，加上括号的意义在哪，是否能去掉括号呢？所以在声明宏的时候，最好加上必要的括号，以免出现优先级问题。可以从代码验证中看出，不加括号的结果和预期的结果大相径庭。预期结果：8 * 2 = 16。
数据结构与算法练习：链表操作与逻辑结构解析
"数据结构与算法的练习题涵盖了线性表、链表、排序、存储结构等多个核心概念。" 在数据结构与算法的学习中，理解并掌握不同的数据结构及其操作至关重要。线性表是一种基本的数据结构，它可以采用链式存储或顺序存储...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值