C++模板链表类

最新推荐文章于 2025-05-14 08:55:39 发布
最新推荐文章于 2025-05-14 08:55:39 发布
阅读量2.1k 收藏 2
点赞数 2
CC 4.0 BY-SA版权
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/swairf/article/details/21987353
封装了一个链表类，有空再详细讲解，后续还得写个矩阵类库。
测试结果：



完整代码：
/*
 ============================================================================
 Name        : 单链表（带表头L）
 Author      : Swair Fang，any question @qq swair@qq.com
 Version     : 3.1
 Copyright   : by Swair Fang
 Description : 带表头的单链表，表头索引为-1， 后接链表0，1，2，3，4，5，6，7，8，。。。），实现了通用链表的功能
 及 堆内单链表与栈内数组相互格式之间的转换。
 功能：
    1.获得链表长度
    2.清空链表
    3.查找元素索引
    4.查找元素前一个元素索引
    5.删除元素
    6.插入操作，默认插入到第一个位置
    7.在P位置后插入元素
    8.索引P后插入元素
    9.打印链表
    10.数组转换为链表
    11.链表转换为数组
    12.根据索引得到值
    13.给定内存地址之间的链表快速排序
    14.给定索引区间内的连表快速排序
    15.地址转换为索引
    16.索引转换为地址
    17.打印数组
 ============================================================================
 */
#ifndef _List_H
#define _List_H

#include 
#include 
#include 
using namespace std;

template
class CList
{
	typedef struct CNode
	{
		T Elt;
		struct CNode *pNext;
	} *Position;
private:
	Position m_pList;
	int m_iSize;
	Position m_pNode;
public:
	CList();
	~CList();
	//1.获得链表长度
	int GetSize();
	//2.清空链表
	void Empty();
    //3.查找元素索引
	int Find(T X);
    //4.查找元素前一个元素索引
	int FindPrevious(T X);
    //5.删除元素
	void Delete(T X);
    //6.插入操作，默认插入到第一个位置
	void Insert(T X);
    //7.在P位置后插入元素
	void insert_after_p(Position P,T X);
	//8.索引P后插入元素
	void PInsert(int Pindex,T X);
	//9.打印链表
	void Print();
	//10.数组转换为链表
	void Array2List(const T *Ay,int Size);
    //11.链表转换为数组
	void List2Array(T *Ay,int Size);
    //12.根据索引得到值
	int GetValue(int index);
	//13.给定内存地址之间的链表快速排序
	void quick_sort(Position Head,Position Tail);
	//14.给定索引区间内的连表快速排序
	void QuickSort(int begin,int end);
    //15.地址转换为索引
	int Addr2Index(Position Addr);
	//16.索引转换为地址
	Position Index2Addr(int N)
	{
		m_pNode=m_pList;
		int i;
		for(i=-1;ipNext;
		return m_pNode;
	};
	//17.打印数组
	void PrintArray(T *Ay,int Size);
};
template
CList::CList()
{
	m_pList=new CNode;
	if(m_pList==NULL)
	{
		printf("Out of Space!!!");
		exit(1);
	}
	m_pList->pNext=NULL;
	m_iSize=0;
}
template
CList::~CList()
{
	Position Tmp;
	m_pNode=m_pList->pNext;
	m_pList->pNext=NULL;
	while(m_pNode!=NULL)
	{
		Tmp=m_pNode->pNext;
		delete m_pNode;
		m_pNode=Tmp;
	}
	delete m_pList;
}
template
int CList::GetSize()
{
	return m_iSize;
}
template
void CList::Empty()
{
	Position Tmp;
	m_pNode=m_pList->pNext;
	m_pList->pNext=NULL;
	while(m_pNode!=NULL)
	{
		Tmp=m_pNode->pNext;
		delete m_pNode;
		m_pNode=Tmp;
	}
	m_iSize=0;
}
template
int CList::Find(T X)
{
	int index=0;
	m_pNode=m_pList->pNext;
	while(m_pNode!=NULL&&m_pNode->Elt!=X)
	{
		m_pNode=m_pNode->pNext;
		index++;
	}
	if(m_pNode==NULL)
	{
		printf("链表中无%d这个数\n",X);
		return -1;
	}
	return index;
}
template
int CList::FindPrevious(T X)
{
	int index=-1;
	m_pNode=m_pList;
	while(m_pNode->pNext!=NULL&&m_pNode->pNext->Elt!=X)
	{
		m_pNode=m_pNode->pNext;
		index++;
	}
	if(m_pNode->pNext==NULL)
	{
		printf("链表中无%d这个数\n",X);
		return -1;
	}
	return index;
}
template
void CList::Delete(T X)
{
	Position TmpCell;
	FindPrevious(X);
	if(m_pNode->pNext!=NULL)
	{
		TmpCell=m_pNode->pNext;
		m_pNode->pNext=m_pNode->pNext->pNext;
		delete TmpCell;
		m_iSize--;
	}
}
template
void CList::Insert(T X)
{
	Position TmpCell=new CNode;
	TmpCell->Elt=X;
	TmpCell->pNext=m_pList->pNext;
	m_pList->pNext=TmpCell;
	m_iSize++;
}
template
void CList::insert_after_p(Position P,T X)
{
	Position TmpCell=new CNode;
	if(TmpCell==NULL)
	{
		printf("Out of Space!!!");
		exit(1);
	}
	TmpCell->Elt=X;
	TmpCell->pNext=P->pNext;
	P->pNext=TmpCell;
	m_iSize++;
}
template
void CList::PInsert(int Pindex,T X)
{
	Position P=Index2Addr(Pindex);
	Position TmpCell=new CNode;
	if(TmpCell==NULL)
	{
		printf("Out of Space!!!");
		exit(1);
	}
	TmpCell->Elt=X;
	TmpCell->pNext=P->pNext;
	P->pNext=TmpCell;
	m_iSize++;
}
template
void CList::Print()
{
	if(m_pList->pNext==NULL)
		printf("链表为空\n");
	else
	{
		m_pNode=m_pList->pNext;
		while(m_pNode!=NULL)
		{
			char *cp=(char*)m_pNode;
			printf("0x%x: %d\n  ",cp,m_pNode->Elt);
			m_pNode=m_pNode->pNext;
		}
		printf("\n");
	}
}
template
void CList::Array2List(const T *Ay,int Size)
{
	Empty();
	m_pNode=m_pList;
	Position Tmp;
	int i=0;
	while(iElt=Ay[i];
		Tmp->pNext=NULL;
		m_pNode->pNext=Tmp;
		m_pNode=m_pNode->pNext;
		i++;
		m_iSize++;
	}
}
template
void CList::List2Array(T *Ay,int Size)
{
	m_pNode=m_pList->pNext;
	int i=0;
	while(iElt;
		m_pNode=m_pNode->pNext;
		i++;
	}
}
template
int CList::Addr2Index(Position Addr)
{
	int index=0;
	m_pNode=m_pList->pNext;
	while(m_pNode!=NULL&&m_pNode!=Addr)
	{
		m_pNode=m_pNode->pNext;
		index++;
	}
	if(m_pNode==NULL)
	{
		printf("链表中无%x这个地址\n",Addr);
		return -1;
	}
	return index;
}
template
int CList::GetValue(int index)
{
	if(index<0)
	{
		printf("Not in List\n");
		return -666666;
	}
	m_pNode=m_pList->pNext;
	for(int i=0;ipNext;
	return m_pNode->Elt;
}
template
void CList::quick_sort(Position Head,Position Tail)
{
	if(Head->pNext!=Tail&&Head->pNext->pNext!=Tail)
	{
		Position KeyP=Head->pNext;      //指向存key值内存单元的指针
		Position LP=Head;              //比key值小的游标指针,KeyP的左边
		Position RP=KeyP;              //比key值大的游标指针,KeyP的右边
		Position IncP=KeyP->pNext;      //遍历单链表的游标指针,每次移动一位
		while(IncP!=Tail)
		{
			if(IncP->EltElt)
				LP=LP->pNext=IncP;
			else
				RP=RP->pNext=IncP;
			IncP=IncP->pNext;
		}
		LP->pNext=KeyP;    //将小于Key值的子链表衔接
		RP->pNext=Tail;    //将大于Key值的子链表衔接

		//递归
		quick_sort(Head,KeyP); //比Key小的子链表排序
		quick_sort(KeyP,Tail); //比Key大的子链表排序
		//注Head和Tail是不参与排序的，只起表头和表尾标识作用,故原链表的Tail值为NULL
	}
}
template
void CList::QuickSort(int begin,int end)
{
	Position Head=Index2Addr(begin-1);
	Position Tail=Index2Addr(end+1);
	quick_sort(Head,Tail);
}
//打印数组
template
void CList::PrintArray(T *Ay,int Size)
{
	int i=0;
	while(i List;
	List.Print();

	printf("===============数组转换为链表===============\n");
	int array[6]={2,3,4,1,6,7};
	int size=sizeof(array)/sizeof(array[0]);
	List.Array2List(array,size);
	List.Print();

	printf("===============删除7===============\n");
	List.Delete(7);
	List.Print();

	printf("===============插入111,123===============\n");
	List.Insert(111);
	List.Insert(123);
	List.Print();

	printf("===============快速排序===============\n");
	List.QuickSort(0,List.GetSize()-1);
	//	List.quick_sort(List.GetAddr(-1),NULL);
	List.Print();

	printf("===============查找4前一个节点的数===============\n");
	int index=List.FindPrevious(123);
	cout<
链表类模板
weixin_52827539的博客
06-26 1564
链表类模板 题目描述 结点数据类型为int的单链表类CIntList可定义如下: class CNode { public: int data; CNode *next; }; class CIntList { private: CNode *head; public: CIntList(); void append(int a); //加到链表最后 void insert(int a, int n); //在第n个结点后加 void remove(int n); //移除第n个结点 int get(int
C++链表类 模板类
11-20
C++链表类 模板类 #include #include #include "LinkedList.h" using namespace std; template Node *LinkedList::GetNode(const T& item, Node* ptrNext) //生成新结点 { Node *p; p = new Node(item,ptrNext); if (p == NULL) { cout << "Memory allocation failure!\n"; exit(1); } return p; } ................
链表模板
qq_42095768的博客
10-17 459
链表模板 #include&lt;iostream&gt; using namespace std; struct node { int data; node *next; }Node; class link { private: node *head; public: link() { head = (node*)new node[1]; head = NULL; } ~link();...
手搓 C++ 中LinkedList（链表）类模板
最新发布
qq_44751268的博客
05-14 453
本文介绍了如何使用C++模板手动实现一个单向链表类（LinkedList），并提供了基本的操作功能。文章解释了链表的创建、遍历和删除操作，并强调了使用前驱节点和头节点的重要性。此外，作者还提供了完整的代码示例，展示了链表的基本操作。最后，作者提出了关于STL链表中迭代器功能的问题，寻求进一步的学习和指导。通过本文，读者可以了解链表的基本原理及其在C++中的实现方式。
实现一个模板类的链表（c++）
06-03
面向对象程序设计课程作业 1. 请创建一个数据类型为T的链表类模板List，实现以下成员函数： 1） 默认构造函数List()，将该链表初始化为一个空链表（10分） 2） 拷贝构造函数List(const List& list)，根据一个给定的链表构造当前链表（10分） 3） 析构函数~List()，释放链表中的所有节点（10分） 4） Push_back(T e)函数，往链表最末尾插入一个元素为e的节点（10分） 5） operator<<()友元函数，将链表的所有元素按顺序输出（10分） 6） operator=()函数，实现两个链表的赋值操作（10分） 7） operator+()函数，实现两个链表的连接，A=B+C（10分） 2. 请编写main函数，测试该类模板的正确性： 1) 用List模板定义一个List类型的模板类对象int_listB，从键盘读入m个整数，调用Push_back函数将这m个整数依次插入到该链表中；（4分） 2) 用List模板定义一个List类型的模板类对象int_listC，从键盘读入n个整数，调用Push_back函数将这n个整数依次插入到该链表中；（4分） 3) 用List模板定义一个List类型的模板类对象int_listA，调用List的成员函数实现A = B + C；（4分） 4) 用cout直接输出int_listA的所有元素（3分） 5) 用List模板定义List类型的模板类对象double_listA, double_listB, double_listC，重复上述操作。（15分） 3. 输入输出样例： 1) 输入样例 4 12 23 34 45 3 56 67 78 3 1.2 2.3 3.4 4 4.5 5.6 6.7 7.8 2) 输出样例 12 23 34 45 56 67 78 1.2 2.3 3.4 4.5 5.6 6.7 7.8
C++模板链表类实现与源码解析
本例中的模板链表类展示了如何使用C++模板技术实现一个灵活的数据结构。通过模板，我们可以创建一个能够处理任意数据类型的通用链表类，这不仅简化了代码，还提高了代码的复用性。在C++工程中，这样的泛型编程技术是...
C++模板链表类实现与内存分配机制
下面，我们将从提供的文件信息中详细解释C++链表类模板类的关键知识点。 ### 知识点概述 1. **模板类**： - 在C++中，模板类是参数化类型的类，允许类包含未指定类型的参数，这些参数在类实例化时会被具体的类型...
c++模板链表类代码
06-04
在“c++模板链表类代码”中，模板被用来定义通用的链表类，这样就可以处理不同类型的数据，如整型、浮点型或者自定义对象。例如，在`CourseNode.h`中，可能定义了一个模板类`CourseNode<T>`，表示链表节点，其中`T`...
C++模板链表类实现与多文件编译指南
这意味着可以通过模板创建链表类，它可以处理整型、字符型、用户自定义类型等多种数据类型的链表。一个基本的链表类通常包括节点的定义和链表操作方法的实现。 节点定义（Node）通常包含以下内容： 1. 数据成员：...
C++利用链表模板类实现简易队列
08-26
C++利用链表模板类实现简易队列 本文主要为大家详细介绍了C++利用链表模板类实现一个简易队列，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 知识点一：链表模板类 在C++中，链表是一种常用的数据结构，...
链表类 c++ 实现的 链表类 c++ 实现的
12-27
链表类 c++ 实现的 链表类 c++ 实现的 链表类 c++ 实现的
链表 模板+详解
weixin_34192732的博客
02-01 317
链表是什么东西？？？ 关于这个问题，提的很好，把我这个蒟蒻提蒙了... 好吧这个不是我们今天的重点（关于上面这个问题你可以去问度娘） 这里我们只需要知道链表是一个线性数据结构即可... 下面，我们就根据下面这个代码，来详细讲解链表的一些知识及其代码实现.... 1 #include<cstdio> 2 3 using namespace...
C++链表类
kepp_smiling的博客
08-12 926
C++中的类就是C中结构体的化身，两者区别在于 C++中的成员默认为私有（private） 结构体中默认为（public）#include<iostream> using namespace std; struct node//结构体默认公有 { node(); node(int); int data; struct node* next;//单纯存地址，不指向任
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值