C++链表

最新推荐文章于 2024-09-25 15:54:35 发布
最新推荐文章于 2024-09-25 15:54:35 发布
阅读量280 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26884501/article/details/103335266
版权 
#include <iostream>
using namespace std;

int main()
{
	struct Students//定义结构体
	{
		int id;
		char names[100];
		char scores[100];
		Students* next;//使用类指针时要在类的构建时声明类的指针，即保存一个指针而已
	};
	Students ss[4] =//定义类型的四个实例
	{
		{1,"码云","100"},
		{2,"麻花疼","90"},
		{3,"武延著","80"},
		{4,"温柔","70"}
	};
	//制作链表
	ss[0].next = &ss[1];//将声明的类指针指向下一个链表地址
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = NULL;

	Students* ptr = &ss[0];//指针指向第一个链表的地址
	while (ptr)
	{
		cout << ptr->id << endl;
		ptr = ptr->next;
	};
	return 0;

}

//在调试的时候还可以明显的看到链表的结构
在这里插入图片描述

#include <iostream>
using namespace std;
struct Students//定义结构体
{
	int id;
	char names[100];
	char scores[100];
	Students* next;//使用类指针时要在类的构建时声明类的指针
};
Students ss[4] =//定义类型的四个实例
{
	{20190401,"码云","100"},
	{20190402,"麻花疼","90"},
	{20190403,"武延著","80"},
	{20190404,"温柔","70"}
};

Students* find(Students* ptr_head, int input_id)//定义一个查找函数，根据id输出学生的信息.返回值类型为指针
{
	Students* ptr = ptr_head;//类指针指向这个输入的链表的地址
	while (ptr)
	{
		if (ptr->id == input_id)
		{
			return ptr;
			//cout << ptr->names << "\t" << ptr->scores << endl;
			//break;
		}
		ptr = ptr->next;
	}
	return NULL;
}


int main()
{
	
	//制作链表
	ss[0].next = &ss[1];//将声明的类指针指向下一个链表地址
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = NULL;

	Students* ptr = &ss[0];//指针指向第一个链表的地址
	while (ptr)
	{
		cout << ptr->names << "\t" << ptr-> scores << endl;
		ptr = ptr->next;
	};
	Students* ptr2 = find(&ss[0], 20190402);//返回的是一个指针，所以要通过指针调用成员变量
	cout << "查找的用户信息为：" << ptr2->names << "\t" << ptr2->scores << endl;
	return 0;

}

//程序输出

码云    100
麻花疼  90
武延著  80
温柔    70
查找的用户信息为：麻花疼        90

C:\Users\C_plus_test\constructdemo\Debug\constructdemo.exe (进程 188688)已退出，返回代码为: 0。
若要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
按任意键关闭此窗口...

固定一个头链表

添加一个链表元素

在这里插入图片描述

#include <iostream>
using namespace std;
#include <string.h>		//使用strcpy_s函数要用到#include <string.h>#include <stdio.h>两个头文件
#include <stdio.h>
struct Students//定义结构体
{
	int id;
	char names[100];
	char scores[100];
	Students* next;//使用类指针时要在类的构建时声明类的指针
};
Students ss[4] =//定义类型的四个实例
{
	{20190401,"码云","100"},
	{20190402,"麻花疼","90"},
	{20190403,"武延著","80"},
	{20190404,"温柔","70"}
};
int main()
{
	//链表，一般首先创建一个固定的头链表
	Students  head = { 0 };//一个空的类型，没有存数据，作为这个链表的头
	Students* ptr_head = &head;
	ptr_head->next = &ss[0];
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = NULL;
	//上面的链表已经构建完成，下面开始在表头插入一个表
	//首先动态构建一个表
	Students* ptr_obj1 = new Students();//使用堆生成一块内存动态的存储表
	ptr_obj1->id = 20190405;
	strcpy_s(ptr_obj1->names, "阿狸晕");
	strcpy_s(ptr_obj1->scores, "100");

	Students* ptr_obj2 = new Students();//使用堆生成一块内存动态的存储表
	ptr_obj2->id = 20190406;
	strcpy_s(ptr_obj2->names, "疼训晕");
	strcpy_s(ptr_obj2->scores, "89");
	//在表头插入这个表，让插入表指向头表的指向，然后再让头表指向插入的表
	ptr_obj1->next = ptr_head->next;
	ptr_head->next = ptr_obj1;

	//在表尾插入一个表，先让最后一个指向要插入的表，再将插入的那个表指向null
	Students* ptr = ptr_head;
	while (ptr->next)//这里判断标准是最后一个表，要用ptr->next,而非ptr，如果ptr是最后一个，那么它所指向的是NULL—>next = ptr_obj2就会进行报错
	{
		ptr = ptr->next;
	}
	ptr->next = ptr_obj2;
	ptr_obj2->next = NULL;

//将数据封装起来，加入用户输入的部分

#include <iostream>
using namespace std;
#include <string.h>		//使用strcpy_s函数要用到#include <string.h>#include <stdio.h>两个头文件
#include <stdio.h>
	
struct Students//定义结构体
{
	int id;
	char names[100];
	char scores[100];
	Students* next;//使用类指针时要在类的构建时声明类的指针
};
Students ss[4] =//定义类型的四个实例
{
	{20190401,"码云","100"},
	{20190402,"麻花疼","90"},
	{20190403,"武延著","80"},
	{20190404,"温柔","70"}
};

//链表，一般首先创建一个固定的头链表
Students  head = { 0 };//一个空的类型，没有存数据，作为这个链表的头
Students* ptr_head = &head;
//链表首插入
void add_head(Students*);
void add_head(Students* ptr_obj)
{
	ptr_obj->next = ptr_head->next;
	ptr_head->next = ptr_obj;
}
//链表尾部插入
void add_tail(Students*);
void add_tail(Students* ptr_obj)//
{
	Students* ptr = &head;//最好用全局变量，不然容易过载，自己都不知道那是啥
	while (ptr->next)//判断是否是尾指针
	{
		ptr = ptr->next;
	}
	ptr->next = ptr_obj;//进行尾指针的重新指向
	ptr_obj->next = NULL;
}

//定义一个查找函数，根据id输出学生的信息.返回值类型为指针
Students* find(Students* ptr_head, int input_id)
{
	Students* ptr = ptr_head;//类指针指向这个输入的链表的地址
	while (ptr)
	{
		if (ptr->id == input_id)
		{
			return ptr;
			//cout << ptr->names << "\t" << ptr->scores << endl;
			//break;
		}
		ptr = ptr->next;
	}
	return NULL;
}

//读取用户输入
int read_input(const Students* );
int read_input(const Students* ptr_obj)
{
	cout << "id: ";
	scanf_s("%d",&ptr_obj->id);
	cout << "name: ";
	scanf_s("%s", &ptr_obj->names,100);//这里一定要记得写上范围100，不然会报错
	cout << "score: ";
	scanf_s("%s",&ptr_obj->scores,100);
	return 0;
	
}

//打印链表
void showinfo();
void showinfo(Students* ptr_show)
{
	//Students* ptr = ptr_show->next;//这样比较乱，最好直接用元数据
	Students* ptr = head.next;
	while (ptr)
	{
		cout << "id: " << ptr->id << "\t" << "name: " << ptr->names << "\t" << "scores: " << ptr->scores <<  endl;
		ptr = ptr->next;
	}
}

int main()
{	
	
	//构建链表
	ptr_head->next = &ss[0];
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = NULL;
	
	//上面的链表已经构建完成，下面开始在表头插入一个表
	//首先动态构建一个表
	Students* ptr_obj1 = new Students();//使用堆生成一块内存动态的存储表
	read_input(ptr_obj1);

	Students* ptr_obj2 = new Students();//使用堆生成一块内存动态的存储表
	read_input(ptr_obj2);
	//在表头插入这个表
	add_head(ptr_obj1);
	//在表尾插入一个表
	add_tail(ptr_obj2);
	//打印链表
	showinfo(&head);
	//释放堆内存
	delete ptr_obj1;
	delete ptr_obj2;

	return 0;

}

//程序输出

id: 20190407
name: 六强冬
score: 59
id: 20190408
name: 顶雷
score: 59
id: 20190407    name: 六强冬    scores: 59
id: 20190401    name: 码云      scores: 100
id: 20190402    name: 麻花疼    scores: 90
id: 20190403    name: 武延著    scores: 80
id: 20190404    name: 温柔      scores: 70
id: 20190408    name: 顶雷      scores: 59

插入一个表
1、找到要插入的节点pre以后，就可以在结果点后面进行插入操作
2、关键点是一定要另记录上一个节点，因为通过当前节点cur判断，满足条件是是通过前一个节点进行操作的

#include <iostream>
using namespace std;
#include <string.h>		//使用strcpy_s函数要用到#include <string.h>#include <stdio.h>两个头文件
#include <stdio.h>
	
struct Students//定义结构体
{
	int id;
	char names[100];
	char scores[100];
	Students* next;//使用类指针时要在类的构建时声明类的指针
};
Students ss[4] =//定义类型的四个实例
{
	{20190401,"码云","100"},
	{20190402,"麻花疼","90"},
	{20190403,"武延著","80"},
	{20190404,"温柔","70"}
};

//按照id顺序插入节点
int insert_num(Students*);
int insert_num(Students* ptr_head,Students* ptr_new)//参数：原链表头指针、要插入表的指针
{
	//取出原链表的头指针
	Students* ptr_cur = ptr_head->next;
	Students* ptr_pre = ptr_head;//记录前一个节点非常重要
	while (ptr_cur)//如果不是尾指针
	{
		//找到插入位置
		if (ptr_new->id < ptr_cur->id)
		{
			break;
		}
		ptr_pre = ptr_cur;
		ptr_cur = ptr_cur->next;
	}
	//跳出while循环时ptr_table->next是NULL，说明ptr_table是尾指针，进行ptr_table指针的重新指向
	ptr_new->next = ptr_pre->next;
	ptr_pre->next = ptr_new;
	return 0;
}


//打印链表
void showinfo();
void showinfo(Students* ptr_show)
{
	//Students* ptr = ptr_show->next;//这样比较乱，最好直接用元数据
	Students* ptr = head.next;
	while (ptr)
	{
		cout << "id: " << ptr->id << "\t" << "name: " << ptr->names << "\t" << "scores: " << ptr->scores <<  endl;
		ptr = ptr->next;
	}
}

int main()
{	
	
	//构建链表
	ptr_head->next = &ss[0];
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = NULL;

	showinfo(&head);
	cout << "---------------------" << endl;
	Students kiki = {20190402,"层隆","10"};
	Students* ptr_kiki = &kiki;
	insert_num(&head, &kiki);
	showinfo(&head);

	return 0;
}

//程序输出

id: 20190401    name: 码云      scores: 100
id: 20190402    name: 麻花疼    scores: 90
id: 20190403    name: 武延著    scores: 80
id: 20190404    name: 温柔      scores: 70
---------------------
id: 20190401    name: 码云      scores: 100
id: 20190402    name: 麻花疼    scores: 90
id: 20190402    name: 层隆      scores: 10
id: 20190403    name: 武延著    scores: 80
id: 20190404    name: 温柔      scores: 70

同理删除一个节点，也是通过前一个节点pre进行操作的

pre->next = obj->next;
free(obj);

int remove_num(Students*, int);
int remove_num(Students* ptr_head, int id)//参数：原链表头指针、要插入表的指针
{
	//取出原链表的头指针
	Students* ptr_cur = ptr_head->next;
	Students* ptr_pre = ptr_head;
	while (ptr_cur)//如果不是尾指针
	{
		//判断是否是要找的节点id
		if (ptr_cur->id == id)
		{
			break;
		}
		ptr_pre = ptr_cur;
		ptr_cur = ptr_cur->next;
	}
	//找到节点后，跳出while循环，对这个节点的前一个节点，进行重新指向操作
	ptr_pre->next = ptr_cur->next;
	free(ptr_cur);
	return 0;//若是返回零的话，说明成功删除
}

int main()
{	//主函数省略了上面的一些代码
    cout << "---------------------" << endl;
	//删除一个实例
	remove_num(&head, 20190403);
	showinfo(&head);
	//释放堆内存
	delete ptr_obj1;
	delete ptr_obj2;

	return 0;

}

//程序输出

id: 20190401    name: 码云      scores: 100
id: 20190402    name: 麻花疼    scores: 90
id: 20190403    name: 武延著    scores: 80
id: 20190404    name: 温柔      scores: 70
---------------------
id: 20190401    name: 码云      scores: 100
id: 20190402    name: 麻花疼    scores: 90
id: 20190402    name: 层隆      scores: 10
id: 20190403    name: 武延著    scores: 80
id: 20190404    name: 温柔      scores: 70
---------------------
id: 20190401    name: 码云      scores: 100
id: 20190402    name: 麻花疼    scores: 90
id: 20190402    name: 层隆      scores: 10
id: 20190404    name: 温柔      scores: 70

Process returned 0 (0x0)   execution time : 0.194 s
Press any key to continue.
望长安于日下
关注
专栏目录
C++链表倒序实现方法
09-04
通过这个实例，我们可以了解到C++链表操作的基本步骤和技巧，这对于深入理解数据结构和算法非常重要。在实际编程中，链表的倒序操作常被用于各种场景，如处理数据序列、实现队列和栈等。熟悉和掌握这些基本操作能够...
链表的建立并返回链表头
salmonwilliam的博客
12-19 6287
上次刷leetcode这里，关于返回链表头我犯了一个错，当链表第一个元素赋值的时候，需要这个指针copy下来，就是链表头的地址 #include&lt;bits/stdc++.h&gt; using namespace std; typedef struct st{ int x; struct st*next; }Node; int main() { int n; cout&l...
链表各种操作函数（c++）
归忆_AC的博客
07-07 214
【代码】链表各种操作函数（c++）
C/C++中的链表数据结构实战
最新发布
weixin_35762258的博客
09-25 962
本文还有配套的精品资源，点击获取 简介：链表是计算机科学中的基础数据结构，尤其在C/C++编程中。它通过节点和指针链接数据，与数组不同，不依赖于连续内存地址。本教程涵盖链表的基本概念、创建过程、基本操作（插入、删除、遍历、查找），以及双向链表和循环链表的介绍。掌握链表的实现是深入学习数据结构和算法的基础。 1. 链表基本概念 链表是一种常见的基础数据结构，它...
链表基本操作详解
qq_39720552的博客
10-24 678
链表通过结构体将数据以一个一个节点的方式存储，然后通过指针将各个节点的地址串联起来。这里可以改进：通过将尾节点的位置存储起来，避免每次插入时循环找尾节点；同时：可以加入新参数（上一节点地址）实现各种位置的插入；
C++实现单链表
uxlike的博客
11-05 897
链表是一种以链式存储的线性表，由于内存空间可以不连续，使用十分灵活，与数组相比各有优缺点。 单链表需要有个标识指明起始位置以便于操作整个链表，可以是头指针也可以是头结点，只是实现上的不同，这里使用头结点的方式。
单链表的基本操作c++
这知识都不进脑子啊！
09-24 957
【代码】单链表的基本操作c++
c++链表的反转
09-04
c++链表的反转，创建链表，插入链表，链表反转，可下载直接运行。
用类的方式实现C++链表功能
05-29
本教程将介绍如何使用类的方式来实现一个简单的C++链表，包括链表的创建、插入、删除、修改和查找操作。下面我们将详细探讨这些知识点。 首先，链表的核心是链表节点，通常我们定义一个结构体或类来表示节点，它...
C++链表实现通讯录管理系统
08-25
总之，这个C++链表实现的通讯录管理系统展示了如何利用链表数据结构来存储和管理联系人信息。通过定义结构体、操作函数和系统功能，我们可以实现添加、查找、删除和显示联系人等基本功能。不过，为了构建一个完整的...
C++ 链表 详解
10-06
C++ 链表详解 链表是计算机科学中的一种基本数据结构，它是一种线性表，每个元素是一个独立的对象，在内存中各个元素不必相邻。链表是一种动态的数据结构，可以根据需要增长或缩减。C++ 中的链表是一种常用的数据...
注意：返回值是指针类型的自定义函数【详解】
皮蛋的Bk
02-17 1352
这里我们主要探讨一下返回类型是指针的自定义函数。返回类型是指针的自定义函数在其过程中需要注意些什么？
c++链表构造函数
qq_45797026的博客
08-19 7105
c++的链表结构是基于结构体创建的，下面结构来存放每个节点 struct ListNode { double value; ListNode *next; }; 在已经声明了一个数据类型来表示结点之后，即可定义一个初始为空的链表，方法是定义一个用作链表头的指针并将其初始化为 nullptr，示例如下： ListNode *head = nullptr; 现在可以创建一个链表，其中包含一个结点，存储值为 12.5，如下所示： head = new ListNode; //分配新结点 hea
c++函数指针以及返回函数指针的函数（参考摘自c++Primer）
In_Zihuatanejo的博客
04-25 1538
1、函数指针：指向函数的指针，指针函数，返回值是指针的函数。 函数指针声明举例： int (*pf)(int &, int &); //pf指向一个函数，该函数参数是两个int类型的引用，返回值是int类型 int TestFun(int &,int &); pf = TestFun; 调用方式： int a = 1;int b = 2; pf...
C++单链表指针实现 构造析构、相关操作及运算符重载
weixin_53369402的博客
10-11 3172
2个月没有发文章了，因为玩了两个月。。。开学后才又开始了学习。 我们先来看一下我们要实现的单链表相关操作有哪些，然后再一个个来根据代码解释。 #include<iostream> using namespace std; typedef int ElementType; class LinkList { //运算符<<和>>的重载 friend ostream & operator<<(ostream & cout, LinkLis
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
C++ 数据结构与算法（四）（链表）
chenyfan_blog
02-24 7094
链表 LeetCode 代码随想录
[Python]数据结构--链表
Festinatione facit vastum
01-11 684
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
c++链表（详解版）
热门推荐
slandarer的博客
06-13 22万+
在自学C++的时候，看到好多人都在提链表，于是就自学了一下，看了很多别人的文章，加入了一些自己的理解，做了一下总结
c++链表
05-25
C++中的链表是一种常见的数据结构，它由一个节点序列组成，每个节点包含两部分：数据和指向下一个节点的指针。 以下是一个简单的链表类的示例代码： ``` #include ...以上就是一个简单的C++链表的实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值