AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

单链表的C++实现（采用模板类）

2017-11-17 901
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

采用模板类实现的好处是，不用拘泥于特定的数据类型。就像活字印刷术，制定好模板，就可以批量印刷，比手抄要强多少倍！

此处不具体介绍泛型编程，还是着重叙述链表的定义和相关操作。 

 

 链表结构定义

定义单链表的结构可以有4方式。如代码所示。

本文采用的是第4种结构类型

复制代码
/* ************************************************************************
1、复合类：在Node类中定义友元的方式，使List类可以访问结点的私有成员
************************************************************************ */
class LinkNode
{
    friend  class LinkList;
private:
     int data;
    LinkNode *next;
};

class LinkList
{
public:
     // 单链表具体操作
private:
    LinkNode *head;
}; 

/* ************************************************************************
2、嵌套类：在List内部定义Node类，但是Node的数据成员放在public部分，使List
和Node均可以直接访问Node的成员
************************************************************************ */
class LinkList
{
public:
     // 单链表具体操作
private:
     class LinkNode
    {
     public:
         int data;
        LinkNode *next;
    };
    LinkNode *head;
}; 

/* ************************************************************************
3、继承：在Node类中把成员定义为protected，然后让List继承Node类，这样就可以
访问Node类的成员了。
************************************************************************ */
class LinkNode
{
protected:
     int data;
    LinkNode *next;
};

class LinkList :  public LinkNode
{
public:
     // 单链表具体操作
private:
    LinkNode *head;
}; 

/* ************************************************************************
4、直接用struct定义Node类，因为struct的成员默认为公有数据成员，所以可直接
访问（struct也可以指定保护类型）。
************************************************************************ */
struct LinkNode
{
     int data;
    LinkNode *next;
};

class LinkList
{
public:
     // 单链表具体操作
private:
    LinkNode *head;
}; 
复制代码

 

单链表的模板类定义

使用模板类需要注意的一点是template<class T>必须定义在同一个文件，否则编译器会无法识别。

如果在.h中声明类函数，但是在.cpp中定义函数具体实现， 会出错。所以，推荐的方式是直接在.h中定义。

复制代码
/*  单链表的结点定义  */
template< class T>
struct LinkNode
{
    T data;
    LinkNode<T> *next;
    LinkNode(LinkNode<T> *ptr = NULL){next = ptr;}
    LinkNode( const T &item, LinkNode<T> *ptr = NULL)    
     // 函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = item;
    }
};

/*  带头结点的单链表定义  */
template< class T>
class LinkList
{
public:
     // 无参数的构造函数
    LinkList(){head =  new LinkNode<T>;}
     // 带参数的构造函数
    LinkList( const T &item){head =  new LinkNode<T>(item);}
     // 拷贝构造函数
    LinkList(LinkList<T> &List);
     // 析构函数
    ~LinkList(){Clear();}
     // 重载函数:赋值
    LinkList<T>&  operator=(LinkList<T> &List);
     // 链表清空
     void Clear();
     // 获取链表长度
     int Length()  const;
     // 获取链表头结点
    LinkNode<T>* GetHead()  const;
     // 设置链表头结点
     void SetHead(LinkNode<T> *p);
     // 查找数据的位置，返回第一个找到的满足该数值的结点指针
    LinkNode<T>* Find(T &item);
     // 定位指定的位置，返回该位置上的结点指针
    LinkNode<T>* Locate( int pos);
     // 在指定位置pos插入值为item的结点，失败返回false
     bool Insert(T &item,  int pos);
     // 删除指定位置pos上的结点，item就是该结点的值，失败返回false
     bool Remove( int pos, T &item);
     // 获取指定位置pos的结点的值，失败返回false
     bool GetData( int pos, T &item);
     // 设置指定位置pos的结点的值，失败返回false
     bool SetData( int pos, T &item);
     // 判断链表是否为空
     bool IsEmpty()  const;
     // 打印链表
     void Print()  const;
     // 链表排序
     void Sort();
     // 链表逆置
     void Reverse();
private:
    LinkNode<T> *head;
};
复制代码

 

定位位置  

复制代码 
/* 返回链表中第pos个元素的地址，如果pos<0或pos超出链表最大个数返回NULL */
template<class T>
LinkNode<T>* LinkList<T>::Locate(int pos)
{
    int i = 0;
    LinkNode<T> *p = head;

    if (pos < 0)
        return NULL;

    while (NULL != p && i < pos)
    {
        p = p->next;
        i++;
    }
    
    return p;
}
复制代码

 

插入结点

单链表插入结点的处理如图 

 

 图：单链表插入操作

要在p结点后插入一个新结点node，（1）要让node的next指针指向p的next结点；（2）再让p的next指向node结点（即断开图中的黑色实线，改成红色虚线指向node）

接下来：node->next = p->next; p->next = node; 

复制代码 
template<class T>
bool LinkList<T>::Insert(T &item, int pos)
{
    LinkNode<T> *p = Locate(pos);
    if (NULL == p)
        return false;

    LinkNode<T> *node = new LinkNode<T>(item);
    if (NULL == node)
    {
        cerr << "分配内存失败!" << endl;
        exit(1);
    }
    node->next = p->next;
    p->next = node;
    return true;
}
复制代码

 

删除结点

删除结点的处理如图：

 

图：单链表删除 

删除pos位置的结点，如果这个位置不存在结点，则返回false；

如果找到对应结点，则通过实参item输出要删除的结点的数值， 然后删除结点并返回true。

复制代码 
template<class T>
bool LinkList<T>::Remove(int pos, T &item)
{
    LinkNode<T> *p = Locate(pos);
    if (NULL == p || NULL == p->next)
        return false;

    LinkNode<T> *del = p->next;
    p->next = del->next;
    item = del->data;
    delete del;
    return true;
}
复制代码

 

清空链表 

遍历整个链表，每次head结点的next指针指向的结点，直到next指针为空。

最后保留head结点。 

复制代码 
template<class T>
void LinkList<T>::Clear()
{
    LinkNode<T> *p = NULL;

    //遍历链表，每次都删除头结点的next结点，最后保留头结点
    while (NULL != head->next)
    {
        p = head->next;
        head->next = p->next;   //每次都删除头结点的next结点
        delete p;
    }
}
复制代码

 

求链表长度和打印链表

着两个功能的实现非常相近，都是遍历链表结点，不赘述。 

复制代码 
template<class T>
void LinkList<T>::Print() const
{
    int count = 0;
    LinkNode<T> *p = head;
    while (NULL != p->next)
    {
        p = p->next;
        std::cout << p->data << " ";
        if (++count % 10 == 0)  //每隔十个元素，换行打印
            cout << std::endl;
    }
}

template<class T>
int LinkList<T>::Length() const
{
    int count = 0;
    LinkNode<T> *p = head->next;
    while (NULL != p)
    {
        p = p->next;
        ++count;
    }
    return count;
}
复制代码

 

单链表倒置

单链表的倒置处理如图： 

图：单链表倒置 

（1）初始状态：prev = head->next; curr = prev->next;

（2）让链表的第一个结点的next指针指向空

（3）开始进入循环处理，让next指向curr结点的下一个结点；再让curr结点的next指针指向prev。即：next = curr->next; curr->next = prev; 

（4）让prev、curr结点都继续向后移位。即：prev = curr; curr = next;

（5）重复(3)、（4）动作，直到curr指向空。这时循环结束，让haed指针指向prev，此时的prev是倒置后的第一个结点。即：head->next = prev;

复制代码 
template<class T>
void LinkList<T>::Reverse()
{
    LinkNode<T> *pre = head->next;
    LinkNode<T> *curr = pre->next;
    LinkNode<T> *next = NULL;

    head->next->next = NULL;
    while (curr)
    {
        next = curr->next;
        curr->next = pre;
        pre = curr;
        curr = next;
    }

    head->next = pre;
}
复制代码

 本文转自静默虚空博客园博客，原文链接：http://www.cnblogs.com/jingmoxukong/p/3827011.html，如需转载请自行联系原作者

文章标签：
C++
编译器
关键词：
C++类
C++模板
C++模板类
C++单链表
单链表C++
文艺小青年
目录
相关文章
ephemerals__
|
7天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
21 2
ephemerals__
|
13天前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
40 5
ephemerals__
|
19天前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
49 4
ephemerals__
|
20天前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
46 4
白子寰
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
28 4
白子寰
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
25 4
白子寰
|
2月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
白子寰
22 1
白子寰
|
2月前
|
编译器 程序员 C++
【C++打怪之路Lv7】-- 模板初阶
【C++打怪之路Lv7】-- 模板初阶
白子寰
18 1
努力学习的小廉
|
2月前
|
存储 编译器 C++
【C++类和对象（下）】——我与C++的不解之缘（五）
【C++类和对象（下）】——我与C++的不解之缘（五）
努力学习的小廉
21 1
努力学习的小廉
|
2月前
|
编译器 C++
【C++类和对象（中）】—— 我与C++的不解之缘（四）
【C++类和对象（中）】—— 我与C++的不解之缘（四）
努力学习的小廉
22 1