[C++]数据结构之单链表

最新推荐文章于 2021-04-29 22:14:35 发布
最新推荐文章于 2021-04-29 22:14:35 发布
阅读量446 收藏 8
点赞数 1
分类专栏： VC++/MFC 学习 文章标签： C++ 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaab789456123/article/details/54799854
版权

2017/2/1 修改

///  
// LinkList.h : CLinkList 单链表类   
//   
  
#include <assert.h>  
  
// 节点类   
template <class Type>  
class CNode {  
// 方法  
public :  
    CNode()  
    {  
        m_pNext = 0;  
    }   
      
// 属性   
public :  
    Type m_data;  
    CNode * m_pNext;  
};  
  
// 单链表类  
template <class Type>  
class CLinkList {  
// 方法  
public :  
    // 构造   
    CLinkList();  
    CLinkList(Type arrInitial[], int iLen);  
    // 析构  
    ~CLinkList();  
      
    // 销毁   
    void Destroy();  
      
    // 是否为空  
    bool IsEmpty();  
    // 取链表长度  
    int GetSize();  
      
    // 以序号查找节点(-1表示根节点, 超出链表范围返回尾结点)   
    CNode<Type> * GetNodeFromID(int iIndex);  
    CNode<Type> * operator [] (int iIndex);  
    // 以内容查找节点   
    CNode<Type> * GetNodeFromData(Type data);  
    // 以内容查找序号(失败返回-1)  
    int Find(Type data);  
      
    // 插入  
    bool AddAt(int iIndex, Type data);  
    // 在末尾处加入   
    bool AddBack(Type data);  
    // 删除  
    bool Delete(int iIndex);  
    bool Delete(int iIndex, Type * data);   
      
// 属性  
private :  
    // 头结点，尾结点   
    CNode<Type> * m_pHead, * m_pTail;  
      
    // 链表长度  
    int m_iSize;   
};  
  
// 构造  
template <class Type>  
CLinkList<Type>::CLinkList()  
{  
    m_pHead = new CNode<Type>();  
    m_pTail = m_pHead;  
    m_iSize = 0;  
}  
  
// 构造  
template <class Type>  
CLinkList<Type>::CLinkList(Type arrInitial[], int iLen)  
{  
    m_pHead = new CNode<Type>();  
    m_pTail = m_pHead; 
    m_pHead->m_pNext = 0;  
    m_iSize = 0;  
      
    for (int i = 1; i <= iLen; i++)  
        AddBack(arrInitial[i - 1]);  
}  
  
// 析构  
template <class Type>  
CLinkList<Type>::~CLinkList()  
{  
    Destroy();  
    delete m_pHead;  
}  
  
// 销毁   
template <class Type>  
void CLinkList<Type>::Destroy()  
{  
    CNode<Type> * p, * q;  
    p = m_pHead;  
    while(p)  
    {  
        q = p;  
        p = p->m_pNext;  
        delete q;  
    }  
    m_iSize = 0;  
}  
  
// 是否为空  
template <class Type>  
bool CLinkList<Type>::IsEmpty()  
{  
    return (!m_iSize);  
    //return (m_pHead->m_pNext == 0);  
}  
  
// 以序号查找节点   
template <class Type>  
CNode<Type> * CLinkList<Type>::GetNodeFromID(int iIndex)  
{  
    // 我们经常会需要在链表尾部添加节点，   
    // 如果频繁地使用 GetNodeFromID() 获取尾部节点，可能耗时较长，   
    // 因此这样写  
    if (iIndex >= GetSize() - 1)  
        return m_pTail;  
      
    if (iIndex == -1)  
        return m_pHead;  
      
    assert(!IsEmpty());  
    if (IsEmpty())  
        return 0;  
      
    assert(iIndex >= 0);  
    assert(iIndex < GetSize());  
    if (iIndex < 0 || iIndex >= GetSize())  
        return 0;  
          
    CNode<Type> * pTmp = m_pHead->m_pNext;  
    while(pTmp && iIndex)  
    {  
        pTmp = pTmp->m_pNext;  
        iIndex--;  
    }  
      
    return pTmp;  
}  
  
// 以内容查找节点   
template <class Type>  
CNode<Type> * CLinkList<Type>::GetNodeFromData(Type data)  
{  
    assert(!IsEmpty());  
    if (IsEmpty())  
        return 0;  
      
    CNode<Type> * pTmp = m_pHead->m_pNext;  
    while (pTmp)  
    {  
        if (pTmp->m_data != data)  
            pTmp = pTmp->m_pNext;  
        else  
            return pTmp;  
    }  
      
    return 0;  
}  
  
// 以内容查找序号  
template <class Type>  
int CLinkList<Type>::Find(Type data)  
{  
    assert(!IsEmpty());  
    if (IsEmpty())  
        return 0;  
      
    CNode<Type> * pTmp = m_pHead->m_pNext;  
    int i = 0;  
    while (pTmp)  
    {  
        if (pTmp->m_data != data)  
        {  
            pTmp = pTmp->m_pNext;  
            i++;  
        }   
        else  
            return i;  
    }  
    return -1;  
}   
  
// 取链表长度  
template <class Type>  
int CLinkList<Type>::GetSize()  
{  
    /* 
    int iSize = 0; 
    CNode<Type> * pTmp = m_pHead->m_pNext; 
    while (pTmp) 
    { 
        iSize++; 
        pTmp = pTmp->m_pNext; 
    } 
     
    return iSize; 
    */  
      
    // 上面这种办法是可行的，但是有一个更简单的方法  
    return m_iSize;  
}  
  
// 以序号查找节点(运算符重载)  
template <class Type>  
CNode<Type> * CLinkList<Type>::operator [] (int iIndex)  
{  
    return GetNodeFromID(iIndex);  
}  
  
// 插入  
template <class Type>  
bool CLinkList<Type>::AddAt(int iIndex, Type data)  
{  
    CNode<Type> * p, * pLast;  
      
    pLast = GetNodeFromID(iIndex - 1);  
    assert(pLast);  
    if (!pLast)  
        return false;  
          
    p = new CNode<Type>();  
    p->m_data = data;  
    p->m_pNext = pLast->m_pNext;  
    pLast->m_pNext = p;  
      
    if (iIndex == GetSize())  
        m_pTail = p;  
      
    m_iSize++;   
    return true;  
}  
  
// 在末尾处加入   
template <class Type>  
bool CLinkList<Type>::AddBack(Type data)  
{  
    return AddAt(GetSize(), data);  
}  
  
// 删除  
template <class Type>  
bool CLinkList<Type>::Delete(int iIndex)  
{  
    CNode<Type> * pLast, * p;  
    pLast = GetNodeFromID(iIndex - 1);  
    assert(pLast);  
    if (!pLast)  
        return false;  
      
    p = pLast->m_pNext;  
    assert(p);  
    if (!p)  
        return false;  
      
    pLast->m_pNext = p->m_pNext;  
    delete p;  
      
    if (iIndex == GetSize())  
        m_pTail = pLast;  
      
    m_iSize--;  
    return true;  
}  
  
// 删除  
template <class Type>  
bool CLinkList<Type>::Delete(int iIndex, Type * data)  
{  
    *data = GetNodeFromID(iIndex) -> m_data;  
    return Delete(iIndex);  
}



///
// test1.cpp : 测试程序 
// 从A中去除B中已存在的元素，保存到C中
//

#include <iostream>
#include <cstdio>
#include "LinkList.h"
using namespace std;

int main()
{
	int arrA[] = {1, 2, 3, 4, 5, 6, 7};
	int arrB[] = {5, 7, 8, 9};
	
	CLinkList<int> linkA(arrA, sizeof(arrA) / sizeof(int));
	CLinkList<int> linkB(arrB, sizeof(arrB) / sizeof(int));
	
	linkA.Delete(4);
	linkB.AddAt(3, 2);
	
	printf("单链表 A 中的元素个数：%d\n", linkA.GetSize());
	printf("	");
	for (int i = 1; i <= linkA.GetSize(); i++)
		cout << linkA[i - 1]->m_data << "  ";
	cout << endl;
	
	printf("单链表 B 中的元素个数：%d\n", linkB.GetSize());
	printf("	");
	for (int i = 1; i <= linkB.GetSize(); i++)
		cout << linkB[i - 1]->m_data << "  ";
	cout << endl;
	
	CLinkList<int> linkC;
	for (int i = 1; i <= linkA.GetSize(); i++)
	{
		if (linkB.Find(linkA[i - 1]->m_data) == -1)
			linkC.AddBack(linkA[i - 1]->m_data);
	}
	
	printf("单链表 A - B 中的元素个数：%d\n", linkC.GetSize());
	printf("	");
	for (int i = 1; i <= linkC.GetSize(); i++)
		cout << linkC[i - 1]->m_data << "  ";
	cout << endl;
	
	return 0;
}


///
// test2.cpp : 测试程序 
// 合并链表 
//

#include <iostream>
#include <cstdio>
#include "LinkList.h"
using namespace std;

template <class Type>
void PrintList(const char str[], CLinkList<Type> * list)
{
	printf("链表 %s 共有 %d 个元素：\n", str, list->GetSize());
	cout << "	";
	for (int i = 1; i <= list->GetSize(); i++)
		cout << list->GetNodeFromID(i - 1)->m_data << " ";
	cout << endl;
}

int main()
{
	int arr[] = {1, 8, 3, 4, 5};
	CLinkList<int> list1(arr, 5);
	PrintList("list1", &list1);
	
	int iData;
	list1.Delete(1, &iData);
	cout << endl << "删除链表中的第二个节点：" << iData << endl;
	PrintList("list1", &list1);
	
	cout << endl << "在第一个元素值等于4的节点前插入一个元素值为7的节点。" << endl;
	list1.AddAt(list1.Find(4), 7);
	PrintList("list1", &list1);
	
	cout << endl;
	int arr2[] = {9, 8, 6, 5};
	CLinkList<int> list2(arr2, 4);
	PrintList("list2", &list2);
	
	cout << endl << "把两条链表合并" << endl;
	for (int i = 1; i <= list2.GetSize(); i++)
		list1.AddBack(list2[i - 1]->m_data);
	PrintList("list1 + list2", &list1);
}


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

下面是初始版本的代码：


不知道有没有错误。


///
// LinkList.h : CLinkList 单链表类 
// 

#include <assert.h>

// 节点类 
template <class Type>
class CNode {
// 方法
public :
	CNode()
	{
		m_pNext = 0;
	} 
	
// 属性 
public :
	Type m_data;
	CNode * m_pNext;
};

// 单链表类
template <class Type>
class CLinkList {
// 方法
public :
	// 构造 
	CLinkList();
	CLinkList(Type arrInitial[], int iLen);
	// 析构
	~CLinkList();
	
	// 销毁 
	void Destroy();
	
	// 是否为空
	bool IsEmpty();
	// 取链表长度
	int GetSize();
	
	// 以序号查找节点(-1表示根节点) 
	CNode<Type> * GetNodeFromID(int iIndex);
	CNode<Type> * operator [] (int iIndex);
	// 以内容查找节点 
	CNode<Type> * GetNodeFromData(Type data);
	// 以内容查找序号(失败返回-1)
	int Find(Type data);
	
	// 插入
	bool Insert(int iIndex, Type data);
	// 在末尾处加入 
	bool Add(Type data);
	// 删除
	bool Delete(int iIndex);
	bool Delete(int iIndex, Type * data); 
	
// 属性
private :
	// 头结点 
 	CNode<Type> * m_pHead; 
};

// 构造
template <class Type>
CLinkList<Type>::CLinkList()
{
	m_pHead = new CNode<Type>();
	m_pHead->m_pNext = 0;
}

// 构造
template <class Type>
CLinkList<Type>::CLinkList(Type arrInitial[], int iLen)
{
	m_pHead = new CNode<Type>();
	m_pHead->m_pNext = 0;
	
	for (int i = 1; i <= iLen; i++)
		Add(arrInitial[i - 1]);
}

// 析构
template <class Type>
CLinkList<Type>::~CLinkList()
{
	Destroy();
	delete m_pHead;
}

// 销毁 
template <class Type>
void CLinkList<Type>::Destroy()
{
	CNode<Type> * p, * q;
	p = m_pHead;
	while(p)
	{
		q = p;
		p = p->m_pNext;
		delete q;
	}
}

// 是否为空
template <class Type>
bool CLinkList<Type>::IsEmpty()
{
	return (m_pHead->m_pNext == 0);
}

// 以序号查找节点 
template <class Type>
CNode<Type> * CLinkList<Type>::GetNodeFromID(int iIndex)
{
	if (iIndex == -1)
		return m_pHead;
	
	assert(!IsEmpty());
	if (IsEmpty())
		return 0;
	
	assert(iIndex >= 0);
	assert(iIndex < GetSize());
	if (iIndex < 0 || iIndex >= GetSize())
		return 0;
		
	CNode<Type> * pTmp = m_pHead->m_pNext;
	while(pTmp && iIndex)
	{
		pTmp = pTmp->m_pNext;
		iIndex--;
	}
	
	return pTmp;
}

// 以内容查找节点 
template <class Type>
CNode<Type> * CLinkList<Type>::GetNodeFromData(Type data)
{
	assert(!IsEmpty());
	if (IsEmpty())
		return 0;
	
	CNode<Type> * pTmp = m_pHead->m_pNext;
	while (pTmp)
	{
		if (pTmp->m_data != data)
			pTmp = pTmp->m_pNext;
		else
			return pTmp;
	}
	
	return 0;
}

// 以内容查找序号
template <class Type>
int CLinkList<Type>::Find(Type data)
{
	assert(!IsEmpty());
	if (IsEmpty())
		return 0;
	
	CNode<Type> * pTmp = m_pHead->m_pNext;
	int i = 0;
	while (pTmp)
	{
		if (pTmp->m_data != data)
		{
			pTmp = pTmp->m_pNext;
			i++;
		} 
		else
			return i;
	}
	return -1;
} 

// 取链表长度
template <class Type>
int CLinkList<Type>::GetSize()
{
	int iSize = 0;
	CNode<Type> * pTmp = m_pHead->m_pNext;
	while (pTmp)
	{
		iSize++;
		pTmp = pTmp->m_pNext;
	}
	
	return iSize;
}

// 以序号查找节点(运算符重载)
template <class Type>
CNode<Type> * CLinkList<Type>::operator [] (int iIndex)
{
	return GetNodeFromID(iIndex);
}

// 插入
template <class Type>
bool CLinkList<Type>::Insert(int iIndex, Type data)
{
	CNode<Type> * p, * pLast;
	
	pLast = GetNodeFromID(iIndex - 1);
	assert(pLast);
	if (!pLast)
		return false;
		
	p = new CNode<Type>();
	p->m_data = data;
	p->m_pNext = pLast->m_pNext;
	pLast->m_pNext = p;
	
	return true;
}

// 在末尾处加入 
template <class Type>
bool CLinkList<Type>::Add(Type data)
{
	return Insert(GetSize(), data);
}

// 删除
template <class Type>
bool CLinkList<Type>::Delete(int iIndex)
{
	CNode<Type> * pLast, * p;
	pLast = GetNodeFromID(iIndex - 1);
	assert(pLast);
	if (!pLast)
		return false;
	
	p = pLast->m_pNext;
	assert(p);
	if (!p)
		return false;
	
	pLast->m_pNext = p->m_pNext;
	delete p;
	
	return true;
}

// 删除
template <class Type>
bool CLinkList<Type>::Delete(int iIndex, Type * data)
{
	*data = GetNodeFromID(iIndex) -> m_data;
	return Delete(iIndex);
}


（顺便说一句，那个 GetNodeFromID() 和 GetNodeFromData() 不能写成重载函数，因为后者的参数 data 的类型有可能是 int ）


测试代码（从A中去除B中已存在的元素，保存到C中）：

#include <iostream>
#include <cstdio>
#include "LinkList.h"
using namespace std;

int main()
{
	int arrA[] = {1, 2, 3, 4, 5, 6, 7};
	int arrB[] = {5, 7, 8, 9};
	
	CLinkList<int> linkA(arrA, sizeof(arrA) / sizeof(int));
	CLinkList<int> linkB(arrB, sizeof(arrB) / sizeof(int));
	
	linkA.Delete(4);
	
	printf("单链表 A 中的元素个数：%d\n", linkA.GetSize());
	printf("	");
	for (int i = 1; i <= linkA.GetSize(); i++)
		cout << linkA[i - 1]->m_data << "  ";
	cout << endl;
	
	printf("单链表 B 中的元素个数：%d\n", linkB.GetSize());
	printf("	");
	for (int i = 1; i <= linkB.GetSize(); i++)
		cout << linkB[i - 1]->m_data << "  ";
	cout << endl;
	
	CLinkList<int> linkC;
	for (int i = 1; i <= linkA.GetSize(); i++)
	{
		if (linkB.Find(linkA[i - 1]->m_data) == -1)
			linkC.Add(linkA[i - 1]->m_data);
	}
	
	printf("单链表 A - B 中的元素个数：%d\n", linkC.GetSize());
	printf("	");
	for (int i = 1; i <= linkC.GetSize(); i++)
		cout << linkC[i - 1]->m_data << "  ";
	cout << endl;
	
	return 0;
}


海浪SeaWave
关注
专栏目录
数据结构单链表的基本操作及实现(C/C++)
06-03
数据结构单链表的基本操作及实现(C/C++)，包括初始化、创建链表、插入元素、删除元素、获取指定位置的元素等
数据结构之线性表
CCDreamOldBoys的专栏
10-05 397
一、循顺序存储 #ifndef __MY_SEQLIST_H__ #define __MY_SEQLIST_H__ typedef void SeqList; typedef void SeqListNode; SeqList* SeqList_Create(int capacity); int SeqList_Create01(SeqList **handle, int
数据结构（C++）——单链表
Anna的博客
01-20 282
#include"AllHead.h" template class List; template class ListNode { template friend class List; private: T data; ListNode *next; public: ListNode(ListNode *ptr = NULL){next = ptr;} /
数据结构之单链表（C++）
Fay
05-04 612
#ifndef LIST_H #define LIST_H /************************************************************************/ /* C++实现单链表 /************************
数据结构之单链表(C++版)
diaoe3953的博客
11-04 160
#include <iostream>#include <stdlib.h>using namespace std; typedef string ElemType;typedef struct LNode{ ElemType data; //数据域 struct LNode *next; //指针域}LNode, *SLink; void InitList...
单链表-C++数据结构之单链表实现.zip
最新发布
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
C++数据结构之单链表实现
09-18
单链表是一种线性数据结构，其中每个元素（称为节点）包含两部分：数据域和指针域。数据域存储实际的数据，而指针域指向下一个节点。链表的最后一个节点的指针域通常为NULL，表示链表的结束。 接下来，我们将通过...
使用C++实现链表数据结构之单链表.zip
03-13
总的来说，理解和实现链表数据结构是学习数据结构和算法的基础，而C++提供了强大的工具来实现这些抽象概念。单链表是链表的一个简单但实用的形式，它能帮助你理解更复杂链表结构，如双向链表和循环链表。通过实践...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
C++数据结构单链表实验：学生信息管理系统，源代码+实验报告.zip
11-14
对学生信息的单链表已经实现以下操作： //初始化 Status InitList(LinkList& L);...包含实验目的，实验分析，实验源程序，实验结果，适合数据结构中单链表的作业提交和学习，注释较多，适合基础人群学习。
数据结构C++链表
03-04
基于C++的数据结构单链表，带主程序可运行，使用头文件可直接编程。
数据结构---单链表（C++实现）
江城的博客
06-20 5228
单链表 线性表由于在内存上顺序存储，在插入和删除元素时效率很低。单链表通过链式存储，适用于插入和删除频繁，储存空间不定的情形。 单链表的一个存储结点（node）包括两个部分：数据域（data）和指针域（link） 数据域：存储线性表的一个数据元素 指针域：存储下一个节点的首地址 只能通过头指针(pHead)进行操作：链表的第一个结点的地址可以通过链表的头指针找到，但是其他结点的...
数据结构----单链表（C++实现）
WYJ的博客
03-17 2764
111
数据结构：C++实现单链表
weixin_46191137的博客
04-29 107
c++单链表 #include<bits/stdc++.h>//单链表 using namespace std; struct Node { int data; Node *next; }; typedef Node* NODE; NODE p,head,tail; int n; void out()//输出函数 { p=head->next; while(p->next!=NULL) { cout<<p-&gt
数据结构（C++）实现单链表
qq_43656233的博客
09-18 712
#include<iostream> using namespace std; template<class T> struct Node { T data; Node<T>* next; }; template<class T> class Linklist { Node<T>* first; public: Linklist(...
C++数据结构之单链表（henu.hjy）
henu.hjy的博客
02-12 248
注重于程序健壮性的单链表，在学习单链表是我的方法是画图，当你理解所学，在写代码时画图是帮你梳理思路的一个很好方法 一下是我的代码，仅供参考，我写的有配套的实验报告——对于代码的解释以及一些我在学习中出现的问题，如有需要评论区留下邮箱（可能不会及时回复，望谅解） #include &lt;iostream&gt; #include &lt;stdlib.h&gt; #define TRUE ...
关于数据结构之单链表的C++实现
qq_27767337的博客
05-16 375
最近学习了数据结构的一些知识，了解的一下单链表的实现。本文中用类的方式构建节点和链表，未来以后方便使用，直接构建模板类。首先实现节点的构建template&lt;typename T&gt; class Node { public: T element; Node&lt;T&gt; *next; Node() { next = NULL; } Node(T element) ...
单链表c/c++ 数据结构
?_#的博客
09-12 272
  #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; /* struct node{}; node */ typedef struct node{ int data; struct node *next; }ListNode,*LinkList; //头插法建立单链表 LinkList CreateListOnHead(){ i...
C++ 数据结构——链表实现
zlb666的博客
08-23 3342
最近使用C++实现数据结构链表，记录一下方便以后复习，若有错误，敬请指正， 1、创建头结点 链表的基本节点是Node，首先手动创建一个Node struct Node { int data; Node *next; Node(const int&amp; da) :data(da), next(nullptr){} ...
C++实现数据结构单链表操作
"数据结构中单链表的程序实现" 在计算机科学中，数据结构是组织、管理和存储数据的方式，而单链表是一种基础且重要的数据结构。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值