1.使用C++封装一个链表类LinkList

简介:  使用C++封装一个链表类LinkList。写出相应一个测试用例 链表需要提供 添加 修改删除 除重 合并 排序创建 销毁等接口。 不能调用库函数或者使用STL等类库 题目延伸***********逆置链表********** LinkNode.h #ifndef LINKNOD


使用C++封装一个链表类LinkList。写出相应一个测试用例

链表需要提供 添加 修改删除 除重 合并 排序创建 销毁等接口。

不能调用库函数或者使用STL等类库

题目延伸***********逆置链表**********

LinkNode.h

#ifndef LINKNODE_H

#define LINKNODE_H

#include <iostream>

 

class LinkNode

{

public:

    int m_idata;

    LinkNode* m_pnext;

};

 

#endif // LINKNODE_H

LinkList.h

#ifndef LINKLIST_H
#define LINKLIST_H
#include <iostream>
#include "LinkNode.h"
 
using namespace std;
 
class LinkList
{
public:
    //作为头节点
    LinkNode *m_head;
    //作为尾节点
    LinkNode *m_tail;
public:
    LinkList();
    ~LinkList();
    void ListInsertIndex(int index,int value);
    //前插
    void ListInsertHead(int value);
    //尾插
    void ListInsertTail(int value);
//    int ListMerge(LinkList &srclist);
    //对链表进行排序
    void ListSort(bool flag);
    void ListRemove(int index);
    //显示所有
    void ListShow();
    LinkNode * ListFindIndex(int index);
    //查找第一个出现指定值的节点的地址
    LinkNode * ListFindValue(int value);
    void ListUpdate(int index,int value);
    //void ListRemoveSame();
};
 
#endif // LINKLIST_H

LinkList.cpp

#include "LinkList.h"

 

/**

 * @brief LinkList::LinkList

 */

LinkList::LinkList()

{

    //init m_head and m_tail

    this->m_head = NULL;

    this->m_tail = NULL;

    std::cout << "LinkNode constructor" << std::endl;

}

 

/**

 * @brief LinkList::~LinkList

 */

LinkList::~LinkList()

{

    std::cout << "~LinkNode" << std::endl;

}

 

/**

 * @brief LinkList::ListInsertIndex,这里方法默认是在节点的后面插入参数

 * @param value 要插入的值

 * @return 返回开始节点

 */

void LinkList::ListInsertIndex(int index,int value)

{

    //先查找到第一次出现value的位置

    LinkNode *pNode = this->ListFindIndex(index);

    LinkNode* pNewNode = new LinkNode;

    pNewNode->m_idata = value;

    pNewNode->m_pnext = NULL;

 

    if(pNode == this->m_head)

    {

        this->m_head->m_pnext = pNewNode;

        this->m_tail = pNewNode;

    }

    else

    {

        //新建一个节点

        pNewNode->m_pnext = pNode->m_pnext;

        pNode->m_pnext = pNewNode;

    }

}

 

/**

 * @brief LinkList::ListInsertHead 前插数据

 * @param value插入的值

 */

void LinkList::ListInsertHead(int value)

{

    //1.创建一个新的LinkNode节点

    LinkNode *pNode = new LinkNode();

    pNode->m_idata = value;

    pNode->m_pnext = NULL;

 

    //判断链表是否为空

    if(this->m_head == NULL && this->m_tail == NULL)

    {

        this->m_head = pNode;

        this->m_tail = pNode;

    }

    else

    {

        pNode->m_pnext = this->m_head;

        this->m_head = pNode;

    }

}

 

/**

 * @brief LinkList::ListInsertTail 尾部插入值

 * @param value 要插入的值

 */

void LinkList::ListInsertTail(int value)

{

    //1.创建一个新的LinkNode节点pNode

    LinkNode *pNode = new LinkNode();

    pNode->m_idata = value;

    pNode->m_pnext = NULL;

 

    //2.判断链表是否为空

    if(this->m_head == NULL && this->m_tail == NULL)

    {

        this->m_head = pNode;

        //m_tail表示最后一个节点

        this->m_tail = pNode;

    }

    else

    {

        //尾部节点的下一个节点是新创建的这个节点

        this->m_tail->m_pnext = pNode;

        this->m_tail = this->m_tail->m_pnext;

    }

}

 

/**

 * @brief LinkList::ListSort 对链表进行排序

 * @param flag 当表示true的时候降序,当false的时候升序

 * @return

 */

void LinkList::ListSort(bool flag)

{

    if(!flag)

    {

        //升序

        for(LinkNode* p1 = this->m_head;p1!=NULL;p1=p1->m_pnext)

        {

            for(LinkNode *p2 = this->m_head;p2!=NULL;p2=p2->m_pnext)

            {

                if(p1->m_idata > p2->m_idata)

                {

                    LinkNode pNode;

                    pNode.m_idata = p1->m_idata;

                    p1->m_idata = p2->m_idata;

                    //交换数据

                    p2->m_idata = pNode.m_idata;

                }

            }

        }

    }

    else

    {

        //降序

        for(LinkNode *p1 = this->m_head;p1!=NULL;p1=p1->m_pnext)

        {

            for(LinkNode *p2 =this->m_head;p2!=NULL;p2=p2->m_pnext)

            {

                if(p1->m_idata < p2->m_idata)

                {

                    LinkNode pNode;

                    pNode.m_idata = p1->m_idata;

                    p1->m_idata = p2->m_idata;

                    p2->m_idata = pNode.m_idata;

                }

            }

        }

    }

}

 

/**

 * @brief LinkList::ListRemove 删除指定的元素

 * @param index 要删除的节点

 */

void LinkList::ListRemove(int index)

{

    //找到要删除的节点

    LinkNode* pNode = this->ListFindIndex(index);

 

    //如果没有找到要删除节点,则直接返回

    if(pNode == NULL)

    {

        return;

    }

    else

    {

        if(pNode == this->m_head)

        {

            this->m_head = this->m_head->m_pnext;

            delete pNode;

            pNode = NULL;

            return ;

        }

        //遍历链表

        LinkNode* pTemp = this->m_head;

        while(pTemp->m_pnext != NULL)

        {

            //如果这个节点的下一个节点恰好是要删除的节点

            if(pTemp->m_pnext == pNode)

            {

                pTemp->m_pnext = pNode->m_pnext;

                //删除节点

                delete pNode;

                pNode = NULL;

                break;

            }

            //这个临时的节点向下移动

            pTemp = pTemp->m_pnext;

        }

 

        //如果是最后一个节点

        if(pTemp == pNode)

        {

             pTemp->m_pnext = pNode->m_pnext;

             delete pNode;

             pNode = NULL;

             return ;

        }

    }

}

 

/**

 * @brief LinkList::ListShow 遍历链表

 */

void LinkList::ListShow()

{

    //判断头节点是否也是空,如果也是空,则返回

    if(this->m_head == NULL)

    {

        return;

    }

    else

    {

        //1.定义一个临时的节点

        LinkNode *pTemp = this->m_head;

 

        //2.循环,直到最后一个节点

        while(pTemp->m_pnext != NULL)

        {

            //输出参数值

            std::cout << pTemp->m_idata << "  ";

            //将临时节点指针向后移

            pTemp = pTemp->m_pnext;

        }

        std::cout << pTemp->m_idata << std::endl;

    }

}

 

/**

 * @brief ListFindIndex 查找第index个元素的值

 * @param index 这里的index表示第index这个元素

 * @return 返回第index个元素的地址

 */

LinkNode * LinkList::ListFindIndex(int index)

{

    //1.判断index是否是小于0的,如果是则肯定没有,直接返回NULL

    if(index <= 0)

    {

        std::cout << "index is out of range" << std::endl;

        return NULL;

    }

    else

    {

        //判断链表是否是空的,如果是空的,输出结果提示结果然后返回

        if(this->m_head == NULL)

        {

            std::cout << "The lenght of LinkList is zero!!" << std::cout << std::endl;

            return NULL;

        }

        else

        {

            LinkNode *pTemp = this->m_head;

            int _tempIndex = 1;

            while (pTemp->m_pnext != NULL)

            {

                //当进来了之后先判断,如果查的标记刚好是这个,则直接返回

                if(index == _tempIndex)

                {

                    return pTemp;

                }

                pTemp = pTemp->m_pnext;

                //临时计数加1

                _tempIndex++;

            }

            //这里表示恰好这个是最后一个节点

            if(index == _tempIndex)

            {

                return pTemp;

            }

            else

            {

               std::cout << "index is out of range!!" << endl;

               return NULL;

            }

        }

    }

}

 

/**

 * @brief LinkList::ListFindValue

 * @param value 要查找的值

 * @return 要查找的值地址

 */

LinkNode* LinkList::ListFindValue(int value)

{

    //判断头节点是否为空,如果为空,则直接返回

    if(this->m_head == NULL)

    {

        return NULL;

    }

    else

    {

        //定义一个临时的节点

        LinkNode *pTemp = this->m_head;

 

        //循环遍历链表,直到最后一个节点

        while(pTemp->m_pnext != NULL)

        {

            // 判断要查找的值和当前值是否相等,如果相等直接返回

            if(pTemp->m_idata == value)

            {

                return pTemp;

            }

            else

            {

                //指针向后移动

                pTemp = pTemp->m_pnext;

            }

        }

 

        //判断最后一个节点的值是否和要查找的值相等

        if(pTemp->m_idata == value)

        {

            return pTemp;

        }

    }

}

 

/**

 * @brief LinkList::ListUpdate

 * @param index 要更改的值

 * @param value

 */

void LinkList::ListUpdate(int index, int value)

{

    LinkNode *pNode = this->ListFindIndex(index);

    //如果是空,表示没有找到要修改的值

    if(pNode == NULL)

    {

        return;

    }

    else

    {

        pNode->m_idata = value;

    }

}

#include <iostream>
#include "LinkList.h"
 
using namespace std;
 
int main()
{
    LinkList* linkList = new LinkList();
 
    //向链表的尾部插入值
    linkList->ListInsertTail(1);
    linkList->ListInsertTail(2);
    linkList->ListInsertTail(3);
    //向链表的头部插入值
    linkList->ListInsertHead(34);
    linkList->ListInsertHead(105);
    linkList->ListInsertIndex(5,125);
 
    linkList->ListShow();
 
    //显示链表中的值
    linkList->ListShow();
    std::cout << endl;
 
    //查找节点值为34的节点的地址
    LinkNode* pTargetNode = linkList->ListFindValue(3);
    //显示出地址
    printf("address = %p,data = %d \n",pTargetNode,*pTargetNode);
    linkList->ListShow();
 
    LinkNode* pTargetNode2 = linkList->ListFindIndex(4);
    printf("pTargetNode2 address = %p,data = %d \n",pTargetNode2,*pTargetNode2);
 
    linkList->ListUpdate(1,30);
    linkList->ListShow();
    linkList->ListUpdate(3,30);
    linkList->ListShow();
 
    linkList->ListRemove(5);
    linkList->ListShow();
 
    linkList->ListSort(false);
    linkList->ListShow();
    return 0;
}
运行结果:

 

目录
相关文章
|
6月前
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
162 0
|
6月前
|
存储 编译器 程序员
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
254 0
|
8月前
|
编译器 C++ 容器
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
296 12
|
9月前
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
177 16
|
9月前
|
编译器 C++
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
|
9月前
|
存储 编译器 C++
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
|
9月前
|
编译器 C++
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
|
存储 SQL 算法
LeetCode力扣第114题:多种算法实现 将二叉树展开为链表
LeetCode力扣第114题:多种算法实现 将二叉树展开为链表
|
存储 SQL 算法
LeetCode 题目 86:分隔链表
LeetCode 题目 86:分隔链表
|
存储 算法 Java
【经典算法】Leetcode 141. 环形链表(Java/C/Python3实现含注释说明,Easy)
【经典算法】Leetcode 141. 环形链表(Java/C/Python3实现含注释说明,Easy)
155 2