封装 链表

已于 2023-05-26 09:24:44 修改
阅读量686 收藏 1
点赞数
分类专栏： C进阶 文章标签： 封装 链表
于 2015-07-29 02:18:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouruifu2015/article/details/47118271
版权 
<strong><span style="font-family:Microsoft YaHei;">linknode.h</span></strong>
<strong><span style="font-family:Microsoft YaHei;">#include <stdio.h>
#include <stdlib.h>

typedef struct student
{
	int num;
	float score;
	struct student *pNext;//用于存储下一个节点的地址
}ST;
//函数声明
void add(ST **phead, int inum, float iscore);//函数声明  传入头结点的地址  然后插入数据
//显示所有数据
void showall(ST *head);//传递头结点的指针  用于有可能要改变头结点的指向
//实现逆转   不改变数据 改变指针指向
ST *rev(ST *head);
//统计链表节点个数
int getnum(ST *head);
//查找数据
ST *search(ST*head, int num);
//查找oldnum  修改为newnum
void change(ST*head, int oldnum, int newnum);
//删除链表所有的节点  用完后释放链表
void *freeall(ST *head);
//返回头结点  传入头结点  要删除节点的编号
ST *delete(ST*head, int num);//头指针
//根据节点  在节点前面插入
ST *HeadInsert(ST*head, int num, int inum, float iscore);
//根据节点  在节点尾部插入
ST*BackInsert(ST*head, int num, int inum, float iscore);
//链表排序
void sort(ST*head, char ch);//传入头结点   当ch=='>'时，实现从大到小排序   当ch=='<'时，实现从小到大排序</span></strong>

---------------------------------------------------------------------------------------------------------------------------------------------------------

linknode.cpp

<strong><span style="font-family:Microsoft YaHei;">//函数定义  及实现
#include "linknode.h"
void add(ST **phead, int inum, float iscore)//函数声明  传入头结点的地址  然后插入数据
{
	if (*phead==NULL)//判断链表是否为空
	{
		ST *newnode = (ST *)malloc(sizeof(ST));//分配内存
		if (newnode==NULL)
		{
			printf("内存分配失败\n");
			return;
		}

		newnode->num = inum;//节点初始化
		newnode->score = iscore;
		newnode->pNext = NULL;
		*phead = newnode;//让头指针指向这个节点
	}
	else//建立链表：先建立一个空链表   然后在一个一个的将元素插在队尾
	{//尾部插入方式
		//链表不为空
		ST*p = *phead;//指向头结点
		//while (p!=NULL)//p=NULL循环终止  表示到了链表的尾部
		//{
		//	p = p->pNext;//循环向前
		//}

		//让p存储最后一个节点地址
		while (p->pNext != NULL)//循环到最后一个节点的地址
		{
			p = p->pNext;//循环向前
		}
		//p->pNext==NULL//跳出循环

		//创建节点
		ST*newnode = (ST*)malloc(sizeof(ST));//
		if (newnode == NULL)
		{
			printf("内存分配失败\n");
			return;
		}
		newnode->num = inum;
		newnode->score = iscore;
		newnode->pNext = NULL;
		p->pNext = newnode;//链接上
	}
}

void showall(ST *head)//传递头结点的指针  显示所有数据   用于有可能要改变头结点的指向
{//遍历所有节点
	while (head!=NULL)//判断指针指向是否为空
	{
		printf("num=%d   score=%f   ",head->num,head->score);
		printf("%p   %p\n",head,head->pNext);//打印两个节点的地址
		head = head->pNext;//指针不断向前循环
	}
}

//实现逆转
ST *rev(ST *head)
{
	ST*p1, *p2, *p3;
	p1 = p2 = p3 = NULL;
	if (head==NULL||head->pNext==NULL)//如果头结点为空   有一个节点 或者链表为空
	{
		return head;//返回头结点
	}
	p1 = head;
	p2 = head->pNext;
	while (p2!=NULL)//从第二个到最后一个节点进行循环
	{
		p3 = p2->pNext;//布局三个节点
		p2->pNext = p1;//指向前面一个节点
		p1 = p2;//指针向前移动  从第二个到最后一个节点全部指向前面的节点
		p2 = p3;
	}
	head->pNext = NULL;//代表链表的结束  设置第一个节点指向为空
	head = p1;//指向最后一个节点
	return head;//副本机制  改变的head并不会生效  需要返回值赋值生效
}

//获取节点个数
int getnum(ST *head)
{
	//遍历所有的节点
	int i = 0;//节点计数器
	while (head!=NULL)
	{
		i++;//计数器自增
		head = head->pNext;//指针不断向前循环
	}
	return i;//统计个数
}

//查找数据
ST *search(ST*head, int num)//根据编号查找节点
{
	while (head!=NULL)//判定指针指向是否为空  循环遍历一个链表
	{
		if (num==head->num)
		{
			return head;//返回当前节点的指针地址   表示找到
		}
		head = head->pNext;//指针不断向前移动  循环
	}
	return NULL;//如果没有找到   返回为空
}

//查找oldnum  修改为newnum
void change(ST*head, int oldnum, int newnum)
{
	ST*psearch = search(head, oldnum);//创建指针psearch    调用查找节点函数search
	if (psearch==NULL)
	{
		printf("没有找到\n");
	}
	else
	{
		psearch->num = newnum;
		printf("修改成功\n");
	}
}

//链表的清空   用完后就要释放链表
void *freeall(ST *head)// error C2040: “freeall”:“void *(ST *)”与“void (ST *)”的间接寻址级别不同
{//此处的freeall添加*  不要忘记头文件中的声明也要添加*
	ST *p1, *p2;
	p1 = p2 = NULL;
	p1 = head;
	while (p1->pNext!=NULL)//循环遍历所有节点
	{
		p2 = p1->pNext;//pw2为p1的下一个节点
		p1->pNext = p2->pNext;//p1存储了p2的下一个节点的地址
		free(p2);//释放

		//显示删除的中间状态
		printf("\n---删除的过程---\n");
		showall(head);
	}
	free(head);//释放最后一个节点
	return NULL;
}

//返回头结点  传入头结点  要删除节点的编号  定位要删除的节点所在位置
ST *delete(ST*head, int num)
{
	ST*p1, *p2;
	p1 = p2 = NULL;//定义两个空节点
	p1 = head;//从头结点开始循环
	while (p1!=NULL)//循环所有的节点
	{
		if (num == p1->num )//判断是否等价于参数中的num
		{
			break;
		}
		else
		{
			p2 = p1;//记录当前节点
			p1 = p1->pNext;//继续完后循环
		}
	}

	if (p1==head)//头结点的情况
	{
		head = p1->pNext;//跳过头结点
		free(p1);//释放第一个节点
	}
	else//如果不是head的情况
	{
		p2->pNext = p1->pNext;//跳过p1
		free(p1);
	}

	return head;//函数有副本机制  所以返回头结点的值
}

//根据节点  在节点前面插入
ST *HeadInsert(ST*head, int num, int inum, float iscore)
{
	ST*p1, *p2;
	p1 = p2 = NULL;//定义两个空节点
	p1 = head;//从头结点开始 
	while (p1!=NULL)//一直循环到尾部最后一个节点
	{
		if (p1->num==num)
		{
			break;
		}
		else//找到节点当前位置
		{
			p2 = p1;//记录当前节点
			p1 = p1->pNext;//循环到下一个节点
		}
	}
	if (p1==head)//如果是头结点  就在头结点的前部插入节点
	{
		ST*newnode = (ST*)malloc(sizeof(ST));//分配内存
		newnode->num = inum;//初始化节点
		newnode->score = iscore;
		newnode->pNext = head;//指向第一个节点的头结点
		head = newnode;//newnode成为第一个节点
	}
	else
	{
		ST*newnode = (ST*)malloc(sizeof(ST));//分配内存
		//初始化节点的两个数据
		newnode->num = inum;
		newnode->score = iscore;
		newnode->pNext = p1;//新节点指向p1
		p2->pNext = newnode;//指向新节点
	}
	return head;
}

//根据节点  在节点尾部插入  不需要记录前面的节点  要记住后面的节点
ST*BackInsert(ST*head, int num, int inum, float iscore)
{
	ST*p1, *p2;
	p1 = p2 = NULL;//对节点置空
	p1 = head;//从头结点开始
	while (p1!=NULL)//一直循环到最后一个节点
	{
		if (p1->num==num)//判断相等
		{
			break;
		}
		else
		{
			p1 = p1->pNext;//循环到下一个节点
		}
	}
	if (NULL==p1->pNext)//最后一个节点
	{
		ST*newnode = (ST*)malloc(sizeof(ST));//分配内存
		newnode->num = inum;//初始化节点
		newnode->score = iscore;
		newnode->pNext = NULL;//指针域此时为空  代表最后一个节点
		p1->pNext = newnode;//指向新开辟的节点
	}
	else
	{
		p2 = p1->pNext;//记录下一个节点的位置
		ST*newnode = (ST*)malloc(sizeof(ST));//分配内存
		newnode->num = inum;//初始化节点
		newnode->score = iscore;
		newnode->pNext = p2;//连接下一个节点
		p1->pNext = newnode;//p1指向新的节点
	}
	return head;
}

//链表排序   不能随便访问另外一个节点，只能访问与自己相近的一个节点  选择排序不适用于链表，需要使用冒泡排序法
void sort(ST*head, char ch)//传入头结点   当ch=='>'时，实现从大到小排序   当ch=='<'时，实现从小到大排序
{
	//链表的冒泡排序
	if ('>'==ch)//从大到小排序
	{
		for (ST*p1=head; p1!=NULL; p1=p1->pNext)//循环终止条件 首结点为空
		{
			for (ST*p2 = head; p2 != NULL; p2 = p2->pNext)
			{
				if (p1->num<p2->num)
				{
					ST temp;//交换p1、p2节点
					temp.num = p1->num;//实现编号num的交换
					p1->num = p2->num;
					p2->num = temp.num;
					
					//此结构体中还有成绩
					temp.score = p1->score;//实现成绩score的交换
					p1->score = p2->score;
					p2->score = temp.score;
				}
			}
		}
	}
	else if ('<'==ch)//从小到大排序
	{
		for (ST*p1=head;p1!=NULL;p1=p1->pNext)//外层循环   只能遍历所有情况  数组可以规避一些无意义的，但是链表必须全部遍历一遍
		{
			for (ST*p2 = head; p2 != NULL;p2=p2->pNext)//内层循环
			{
				if (p1->num>p2->num)
				{
					ST temp;
					temp.num = p1->num;
					p1->num = p2->num;
					p2->num = temp.num;

					//交换score
					temp.score = p1->score;
					p1->score = p2->score;
					p2->score = temp.score;
				}
			}
		}
	}
}</span></strong>


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

测试代码段   主程序

main.c

<strong><span style="font-family:Microsoft YaHei;">#include "linknode.h"
void main5()
{
	struct student *head = NULL;//创建头结点的指针
	//添加5个节点
	add(&head, 1, 70);
	add(&head, 2, 67);
	add(&head, 3, 99);
	add(&head, 4, 87);
	add(&head, 5, 67);

	//显示所有节点
	//printf("%d   %f\n",head->num,head->score);//打印数据
	//printf("%d   %f\n",head->pNext->num,head->pNext->score);
	//printf("%d   %f\n",head->pNext->pNext->num,head->pNext->pNext->score);
	
	//逆转链表
	head = rev(head);
	//显示所有节点
	showall(head);

//测试获取有多少个节点
	printf("num=%d\n",getnum(head));

//链表查找测试
	ST*psearch = search(head, 3);
	printf("%d   %f\n",psearch->num,psearch->score);//打印返回链表指针指向的数据
	change(head, 3, 30);//修改数据
	showall(head);//显示所有的节点

	//显示所有数据  传递头结点的指针
	showall(head);
	getchar();
}
<img src="https://img-blog.csdn.net/20150729085428211?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />


void main4()
{
	struct student *head = NULL;
	add(&head, 1, 70);
	add(&head, 2, 67);
	add(&head, 3, 99);
	add(&head, 4, 87);
	add(&head, 5, 67);

	showall(head);//显示所有的节点

	printf("删除之后：");
	//freeall(head);
	//由于最后把head也给释放掉了  所以在此处要把head设为NULL
	//head = NULL;//方法一  ok    删除所有节点之后  头结点务必为空

	//为了代码的稳健型  使用方法二
	//方法二   让freeall函数返回void*指针  最后return NULL 即可
	head=freeall(head);
	showall(head);//显示所有的节点

	getchar();
}
<img src="https://img-blog.csdn.net/20150729085337085?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="" />


//测试链表的排序
void main3()
{
	struct student *head = NULL;
	add(&head, 10, 70);
	add(&head, 2, 67);
	add(&head, 30, 99);
	add(&head, 4, 87);
	add(&head, 50, 67);

	showall(head);//显示所有的节点

	printf("\n从小到大，排序之后：\n");
	sort(head,'>');
	showall(head);//显示所有的节点

	printf("\n从大到小，排序之后：\n");
	sort(head, '<');
	showall(head);

	printf("该链表一共有：%d个节点\n",getnum(head));
	getchar();
}
</span></strong>

<strong><span style="font-family:Microsoft YaHei;"><img src="https://img-blog.csdn.net/20150729085528724?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="" /></span></strong>

<strong><span style="font-family:Microsoft YaHei;">
//测试前插 节点
void main2()
{
	struct student *head = NULL;
	add(&head, 10, 70);
	add(&head, 2, 67);
	add(&head, 30, 99);
	add(&head, 4, 87);
	add(&head, 50, 67);
	showall(head);//显示所有的节点

	printf("\n插入之后的链表节点\n");
	head = HeadInsert(head, 2, 20, 90.0);//在节点2的前面插入20
	showall(head);
	printf("\n插入之后的链表节点\n");
	head = HeadInsert(head, 50, 520, 590.0);//在节点2的前面插入20
	showall(head);
	printf("\n插入之后的链表节点\n");
	head = HeadInsert(head, 4, 40, 444.0);//在节点2的前面插入20
	showall(head);

	getchar();
}

</span></strong>

<strong><span style="font-family:Microsoft YaHei;"><img src="https://img-blog.csdn.net/20150729085546274?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="" /></span></strong>

<strong><span style="font-family:Microsoft YaHei;">


//测试后 插节点
void main()
{
	struct student *head = NULL;
	add(&head, 10, 70);
	add(&head, 2, 67);
	add(&head, 30, 99);
	add(&head, 4, 87);
	add(&head, 50, 67);
	showall(head);//显示所有的节点

	printf("\n插入之后的链表节点\n");
	
	head = BackInsert(head, 2, 20, 90.0);//在节点2的前面插入20
	showall(head);
	printf("\n插入之后的链表节点\n");
	head = BackInsert(head, 50, 520, 590.0);//在节点2的前面插入20
	showall(head);
	printf("\n插入之后的链表节点\n");
	head = BackInsert(head, 4, 40, 444.0);//在节点2的前面插入20
	showall(head);


	//测试删除指定节点
	printf("\n删除节点后：\n");
	//head = delete(head, 33);//如果删除一个不存在的节点  程序就会崩溃
	head = delete(head, 4);//删除节点2

	head = delete(head, 10);//删除节点2

	head = delete(head, 50);//删除节点2
	showall(head);
	getchar();
}</span></strong>

<img src="https://img-blog.csdn.net/20150729085602092?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="" />

SteveRocket
关注
专栏目录
LeetCode-链表思路进行两数相加
Jiangtagong的博客
09-12 197
给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。如果，我们将两个数相加起来，则会返回一个新的链表来表示它们的和。 例如： 输入：（2->4->3）+(5->6->4) 输出：7->0->8 原因：342+465=807 整体思路： 将长度较短的链表在末尾补零使得两个链表长度相等，再一个一个元素对其相加（考虑到进位）： 获取两个链表所对应的长度； 在较短的链表末尾补零； ..
C++封装链式表-链表
Frank's CSDN Blog
07-03 2825
此文章为上一篇文章续篇 面向对象三大特性：封装、继承、多态。这也是面向对对象语言相对面向过程而言，最大的优势和特点。面向对象使得程序更加利于维护，让设计人员更加关注设计，要想真正的理解面向对象的特性，则必须要清楚和掌握这三大规律。 链式结构分析对于链式结构而言，与线性结构有所差别的是，其逻辑结构不为连续的，而是采用一种前驱后继的方式进行节点之间的关联，使得上一个节点，可以访问到下一个节点，从而形
封装链表
qq_44442895的博客
02-01 554
封装链表 尾添加的效率低，非法下标的判断效率也很低 1、单链表 节点： ​ 数据域 ​ 指针域 数据项： ​ 头指针 ​ 尾指针 ​ 节点数量 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #define TYPE int // 单链表的实现 // 设计节点 typedef struct Node { TYPE data; struct Node* next; }Node; Node* cr
链表_链表封装
october_autumn的博客
03-24 706
链表结构本身就是一种可以代替数组的结构，所以它的操作与数组的操作非常类似。 与数组比较，它们都可以存储一系列的元素，但是实现的机制完全不同。 数组有很多缺点： 数组需要申请一段连续的内存空间，并且大小是固定的（大多数编程语言），所以在数组增加元素时需要扩容。（一般情况下是申请一个更大的连续内存空间，比如2倍，再将元素复制过去） 在数组的中间或末尾插入元素成本很高，因为它内部需要改变插入位置后面的...
链表封装
weixin_30764137的博客
10-03 806
// 链表 function LinkedList () { function Node(value) { this.next = null this.value = value } this.head = null this.length = 0 //在链表尾部追加元素 LinkedL...
数据结构——链表的封装
m0_59200231的博客
08-27 413
数据结构中链表封装的基本架构
【数据结构】封装单链表
Vcrossover的博客
12-21 379
  今天将之前所学习的链表进行封装，增加一些操作，重载输入，输出运算符。 一、概念 结点：数据元素的存储映像 链表：n个结点链接成起来形成一个链表，即为线性表的 链式存储结构 单链表： 结点中只包含一个指针域 头指针：指向链表中第一个结点（或为头结点、或为首元结点）的指针 头结点：在链表的首元结点之前附设的一个结点；数据域内只放表长等信息，它不计入表 长度。其作用是统一空表、和非空链表的形式 首元结点：指链表中存储线性表第一个数据元素a1的结点 二、封装链表类 #pragma once #include&
封装链表模板类的源代码
08-26
利用标准C++的语言，实现封装链表模板类，即List模板类
C++编程实例(c++封装链表、栈、队列).pdf
02-13
封装链表、栈和队列是C++编程中的基础数据结构，它们提供了对数据的高效管理。链表是一种动态数据结构，允许在任意位置插入和删除元素。栈是一种后进先出（LIFO）的数据结构，通常用于递归和表达式求值等场景。队列...
C++语言封装链表类
09-11
仅供大一参考联系， 利用C++中的类实现线性链表的常见操作
通用链表封装
12-29
程序是在vs2010上编译，链表封装的操作包括创建、插入、计算链表数等。
通用链表类封装
03-25
class CMyList { private: PLIST Head; PLIST Last; int iCount; public: CMyList(); ~CMyList(); }
链表类模板封装链表操作
10-25
在C++中，我们可以通过类模板来封装链表的操作，实现通用性且高效的数据处理。类模板是C++中的一个强大特性，允许我们创建泛型代码，适用于多种数据类型。 首先，链表的基本元素是节点，每个节点包含两部分：数据域...
如何用class封装链表
最新发布
07-13
你可以使用类来封装链表，下面是一个示例： ```python class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def add_node...
链表—— 最基础的动态数据结构
zjt980452483的博客
01-04 207
package dataStructure.chapter4; /** * @Author: zjtMeng * @Date: 2020/1/1 22:24 * @Version 1.0 */ public class LinkedList<E> { private class Node{ public E e; public Nod...
自己封装的链表操作
清流弯弯
12-07 1903
链表节点定义   struct CRectTracker_Node { CRectTracker_Node() { radio_distance_x=0; radio_distance_y=0; radio_width=0; radio_height=0; next=NULL; bSelected=FALSE; };
简单的链表封装(类)
m0_61907339的博客
08-31 336
【代码】简单的链表封装(类)
封装链表类
xal87v5的博客
11-22 292
Demo(int val=0,int val1=0) : val1(val1) //使用初始化列表对成员变量val val1初始化。//right getmyval()是static方法，是类的成员。//right const对象可以调用const方法。//const成员是只读的，只能初始化，不能修改。int getval() const //const成员方法:不能修改类对象。//error obj是const对象，只能调用const方法。//static成员。
单向链表的封装
03-24 177
#include<iostream>typedef int DataType;typedef int Status;typedef struct Node{ DataType data; struct Node *Next;}Node,*LinkList;#define TRUE 1#define FALSE 0#define OK 1#define E...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SteveRocket

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值