数据结构-C++实现（二）：单向链表

最新推荐文章于 2023-08-18 14:25:09 发布
最新推荐文章于 2023-08-18 14:25:09 发布
阅读量594 收藏
点赞数
分类专栏： C++ 数据结构 文章标签： C++ 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/King_DJF/article/details/53765628
版权

和数组不同，链表的数据结构内部多了一个指针指针下一个位置，使得在链表中插入删除特定位置的元素效率很高，代码实现依旧分为三个部分，抽象类LinearList.h，模板类chain.h以及main函数源文件。

废话不多说，我们看代码，这次LinearList.h抽象类里面多了两个成员函数一个是push_back(),一个是clear():

//
// Created by djf on 2016/12/18 0018.
//

#ifndef INC_01_ARRAYLIST_LINEARLIST_H
#define INC_01_ARRAYLIST_LINEARLIST_H

#include 
   
   
    
    
template 
    
    
     
     
class LinearList {
public:
    virtual ~LinearList() {};
    virtual bool empty() const = 0;
    virtual int size() const = 0;
    virtual T& get(int index) const = 0;
    virtual int indexof(const T& theElement) const = 0;//first pos
    virtual void erase(int index) = 0;
    virtual void insert(int index, const T& theElement) = 0;
    virtual void output(std::ostream& out) const = 0;
    //extend
    virtual void clear() = 0;
    virtual void push_back(const T& theElement)  = 0;
};


#endif //INC_01_ARRAYLIST_LINEARLIST_H
然后是chain.h，单向链表的模板类： 

//
// Created by djf on 2016/12/20 0020.
//

#ifndef INC_02_CHAIN_CHAIN_H
#define INC_02_CHAIN_CHAIN_H

#include "LinearList.h"
using namespace std;
template 
   
   
    
    
struct chainNode{
    //data
    T element;
    chainNode
    
    
     
      *next;
    //method
    chainNode() {}
    chainNode(const T& e) { this->element=e;}
    chainNode(const T& e, chainNode
     
     
      
      * n) { this->element=e;this->next=n;}
};

template 
      
      
       
       
class chain: public LinearList
       
       
         { public: //one direction iterator class iterator{ public: // typedefs required by C++ for a forward iterator typedef forward_iterator_tag iterator_category; typedef T value_type; typedef ptrdiff_t difference_type; typedef T* pointer; typedef T& reference; //construct iterator(chainNode 
        
          * theNode = nullptr) { node = theNode;} //operator T& operator*() const { return node->element;} T* operator&() const { return &node->element;} iterator& operator++() { node = node->next;return *this;} iterator operator++(int) { iterator old = *this; node = node->next; return old;} bool operator==(const iterator rhl) const { return node == rhl.node;} bool operator!=(const iterator rhl) const { return node != rhl.node;} //other protected: chainNode 
         
           * node; }; public: //consturct copy destory chain(int initCapacity=10); chain(const chain 
          
            &); ~chain(); //ADT method from LinearList.h bool empty() const override { return listSize==0;}; int size() const override { return listSize;} T& get(int index) const override; int indexof(const T&) const override; void erase(int index) override; void insert(int index,const T& theElement) override; void output(ostream& out) const override; void push_back(const T& theElement) override ; void clear() override ; //other void removeRange(int fromIndex,int toIndex); int lastIndexOf(const T& theElement); T& operator[](int index) const; void reverse(); protected: void checkIndex(int index) const; chainNode 
           
             * headNode; int listSize; }; template 
            
              void chain 
             
               ::removeRange(int fromIndex, int toIndex) { checkIndex(fromIndex);checkIndex(toIndex); if(toIndex 
              
                * p = headNode; if(fromIndex!=0) { chainNode 
               
                 * q; for(int i = 0;i 
                
                  next; else { q = p->next; p->next = q->next; delete q; } } } else { for(int i = 0;i<=toIndex;++i) { headNode = headNode->next; delete p; p = headNode; } } } template 
                 
                   chain 
                  
                    ::chain(int initCapacity) { //chain中无capacity，这么写为了和LinearList兼容 if(initCapacity<1) cerr << "----!initSize must be >=1 !----"; listSize = 0; headNode = nullptr; } template 
                   
                     chain 
                    
                      ::chain(const chain 
                     
                       & theList) { listSize = theList.listSize; if(listSize==0) { headNode = nullptr; return; } chainNode 
                      
                        * sourceNode = theList.headNode; headNode = new chainNode 
                       
                         (sourceNode->element); sourceNode = sourceNode->next; chainNode 
                        
                          * targetNode = headNode; while(sourceNode!= nullptr) { targetNode->next = new chainNode 
                         
                           (sourceNode->element); sourceNode = sourceNode->next; targetNode = targetNode->next; } targetNode->next = nullptr; } template 
                          
                            chain 
                           
                             ::~chain() { wsnippet_file_0hile(headNode!= nullptr) { chainNode 
                            
                              * nextNode = headNode->next; delete headNode; headNode = nextNode; } } template 
                             
                               T &chain 
                              
                                ::get(int index) const { checkIndex(index); chainNode 
                               
                                 * currNode = headNode; for(int i=0;i 
                                
                                  next; return currNode->element; } template 
                                 
                                   void chain 
                                  
                                    ::checkIndex(int index) const { if(index<0 || index>=listSize) { cerr << "----! index outrange !----" << endl; return; } } template 
                                   
                                     int chain 
                                    
                                      ::indexof(const T & theElement) const { chainNode 
                                     
                                       * currNode = headNode; for(int i = 0;i 
                                      
                                        element==theElement) return i; currNode = currNode->next; } return -1; } template 
                                       
                                         void chain 
                                        
                                          ::erase(int index) { checkIndex(index); chainNode 
                                         
                                           * deleteNode; if(index==0) { deleteNode = headNode; headNode = headNode->next; } else { chainNode 
                                          
                                            *p = headNode; for(int i=0;i 
                                           
                                             next; deleteNode = p->next; p->next = p->next->next; } --listSize; delete deleteNode; } template 
                                            
                                              void chain 
                                             
                                               ::insert(int index, const T &theElement) { if(index<0 || index>listSize) { cerr << "---! insert index error !----" << endl; return; } if(index ==0) { headNode = new chainNode 
                                              
                                                (theElement,headNode); } else { chainNode 
                                               
                                                 *p = headNode; for (int i = 0; i < index - 1; ++i) p = p->next; p->next = new chainNode 
                                                
                                                  (theElement, p->next); } listSize++; } template 
                                                 
                                                   void chain 
                                                  
                                                    ::output(ostream &out) const { for(chainNode 
                                                   
                                                     * p = headNode;p != nullptr;p=p->next) out << p->element << " "; } template 
                                                    
                                                      void chain 
                                                     
                                                       ::push_back(const T &theElement) { chainNode 
                                                      
                                                        * currNode = headNode; for(int i=0;i 
                                                       
                                                         next; currNode->next = new chainNode 
                                                        
                                                          (theElement, nullptr); ++listSize; } template 
                                                         
                                                           void chain 
                                                          
                                                            ::clear() { chainNode 
                                                           
                                                             * p; while(headNode!= nullptr) { p = headNode->next; delete headNode; headNode = p; } listSize = 0; } template 
                                                            
                                                              int chain 
                                                             
                                                               ::lastIndexOf(const T& theElement) { int pos = -1;int i = 0; chainNode 
                                                              
                                                                * p = headNode; while (p != nullptr) { if (p->element == theElement) pos = i; else { ++i; p = p->next; } } } template 
                                                               
                                                                 T& chain 
                                                                
                                                                  ::operator[](int index) const { checkIndex(index); chainNode 
                                                                 
                                                                   * currNode = headNode; for(int i = 0;i 
                                                                  
                                                                    next; return currNode->element; } template 
                                                                   
                                                                     void chain 
                                                                    
                                                                      ::reverse() { if(listSize==0 || listSize==1) return; else if(listSize == 2) { chainNode 
                                                                     
                                                                       * p = headNode; headNode = headNode->next; headNode->next = p; p->next = nullptr; } else { chainNode 
                                                                      
                                                                        * p = headNode; chainNode 
                                                                       
                                                                         * q = headNode->next; chainNode 
                                                                        
                                                                          * r = headNode->next->next; headNode->next = nullptr; while(r->next != nullptr) { q->next = p; p = q; q = r; r = r->next; } q->next = p; r->next = q; headNode = r; } } template 
                                                                         
                                                                           ostream& operator<<(ostream& out, const chain 
                                                                          
                                                                            &a) { a.output(out); return out; } #endif //INC_02_CHAIN_CHAIN_H
随便写的测试： 

#include <iostream>
#include "chain.h"
int main()
{
    chain<int> ic;
    ic.insert(0,1);ic.insert(0,2);ic.push_back(3);ic.push_back(4);
    chain<int> ic1(ic);ic1.reverse();
    cout << ic1 << endl;
    return 0;
}
我发现写这个还是很锻炼人的，一个完善的数据结构轻轻松松几百行代码，每天一发，感觉很酸爽，C++简直写上瘾。

不废话了，我们回归头来看看链表的头文件里都定义了啥：

chainNode类定义了节点类，包含数据成员以及指向下一个节点的指针。包含构造、拷贝以及析构函数。

chan类继承自LinearList抽象类，包含节点类的成员变量，以及一个嵌套类iterator。

成员函数分为几个部分，首先是构造、拷贝以及析构函数，值得注意的是在构造函数中有一个参数initCapacity,实际是无作用的，仅仅为了和之前的ArrayList一致。

然后是继承自抽象类的方法，和ArrayList中的区别不大。

最后是我做的几个习题，void removeRange(int fromIndex,int toIndex)的作用是将参数限定范围内的节点删除的操作。int lastIndexOf(const T& theElement)是返回与函数参数相等的最后一个位置的索引。T& operator[](int index) const 是对[]运算符进行重载，返回指定索引的节点的数据的引用。void reverse()是将整个链表进行反转的操作，要求不开辟多余的空间。



King_DJF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验2：C++实现单链表类
u25th_engineer的博客
11-10 1932
太简单了，没啥可说的，代码意义明白如话。 题目与要求： 实验2 2.1 实验目的 熟练掌握线性表的链式存储结构。 熟练掌握单链表的有关算法设计。 根据具体问题的需要，设计出...
c++数据结构—单向链表
qq_67972375的博客
03-14 1535
由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为NULL,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。
C++的一些小记录
Aewil的专栏
03-23 956
STL容器 vector vector< int > vec的push_backvec.push_back( things )操作是按值/对象拷贝，而非按址拷贝。Object things; vector< Object > vec; vec.push_back( things ); // vec中的things 是 外面things的拷贝，两者不是同一个东西！ set/unordered_set中
数据结构实验 2 单链表的实现
Inneverleft的博客
05-21 1426
一、实验目的 1．掌握链表的定义。 2．理解线性表的链式存储结构。 3．掌握链表的初始化、头插法、尾插法、打印、判断空表、清空链表、求表长、按址查找、按值查找、插入、删除等基本操作。 二、实验要求 1. 写出链表的操作的详细算法步骤； 2. 属性使用C/C++实现链表，并编译运行。 三、实验过程 实验环境：visual studio 2017 实验步骤： 1.初始化链表L，定义函数名为Init_List; 2.头插法创建链表L，定义函数名为Create_Head; 3.尾插法创建链表
两个单向循环链表的连接
NBDR_YL的博客
05-31 1996
已知尾结点的两个单向循环链表的合并    合并后的结果为b头 -&gt;11-&gt;22-&gt;33-&gt;A-&gt;B -&gt;b的头第一步，得先确定需要删除的结点。那么我们可以选择a链表的头节点        要删除就用pDel   a的头结点 的地址在pRa中    所以 pDel = pRa-&gt;pNext;第二步 保护后面的结点    用pRa指向b链表的头    pRa-...
亲测解决c++/cpp 20 sequence not ordered
上海菁数信息技术
05-06 1619
问题定义 情景说明，在使用c++ 20特性并进行2个数组merge的操作 #include <iostream> #include <algorithm> #include <iterator> int main() { std::cout << "Hello, World!" << std::endl; int a1[...
数据结构3：单向链表实现及图解
m0_53607711的博客
10-03 1353
头删的逻辑也不算困难，理解了二级指针之后就非常容易了。
【数据结构】-- C++怎样在单向链表尾部插入节点
qq_54223524的博客
11-05 1638
template<class T> void ListTemp<T>::AddTail(const T& newData) { //please implement this Node* temp = new Node; Node* current = head; temp->data = newData; temp->next = NULL; if (head == NULL) { head = temp; } else { ..
C++数据结构之--单向链表（SingleList）
who_I_am__的博客
08-18 736
C++单向链表, 查找,头部添加,尾部添加,删除反转等功能.
数据结构--不带头的单向链表
qq_43570634的博客
06-01 1671
不带头的单向链表 链表的结构 注意点（贯穿于整个链表的注意事项） 结点类型的定义 申请新结点函数 链表的打印 链表的尾插 链表的头插 链表的尾删 链表的头删 链表的查找和修改 在pos之前插入 在pos位置删除 在pos之后插入（通过交换值，达到在pos之前插入的目的）--没有头指针 在pos位置后面删除（通过交换值，达到删除pos位置的目的）--没有头指针 全部代码
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C/C++实现单向链表
01-16
分别用C和C++实现了单向链表（创建链表，插入数据、获取指定位置的数据、删除指定位置的数据...），如果在使用中觉得api不够用可以进行扩展；其中包含测试。
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
用单向链表实现栈（C++源代码）
04-07
栈是基本的数据结构。其特点是添加和访问数据都在线性表的一端（头端）。数据访问遵循先进后出（FILO）的原则。...本程序用单向链表实现栈。是C++、数据结构及算法学习的一个小小练习。供大家参考。
课程大作业基于easyx的使用单向链表的数据结构C++源码(带详细注释+exe可执行文件).zip
最新发布
06-06
课程大作业基于easyx的使用单向链表的数据结构C++源码(带详细注释+exe可执行文件).zip课程大作业基于easyx的使用单向链表的数据结构C++源码(带详细注释+exe可执行文件).zip课程大作业基于easyx的使用单向链表的数据...
音乐检索（听歌识曲）实现过程
热门推荐
King_DJF的博客
11-13 1万+
序言 需要实现的功能 算法原理 实现 准备 效果 Code序言 由于需要做无人机的声音识别，但是现有的做无人机声识别的成果不是很多，机缘巧合下在一篇论文中看到了一篇有关音乐识别的论文，就是这个shazam论文 ，该算法提出的时间比较早，也不是很复杂，而且已经商用了很久：shazam网站 ,当然，这个论文里面的是算法的初级版。所以，就萌生了想要实现它的想法，等复现后，视效果再考虑移植到对无人机声识别的
C++模板类的成员函数定义与声明必须在一个头文件中
King_DJF的博客
12-19 4152
今天编写数组链表的程序，出现了一个问题，我在ArrayList.h中定义了一个模板类ArrayList，然后按照原来的习惯，在另一个源文件ArrayList.cpp中对模板类的成员函数进行定义，编译也通过了，但是当我在main函数对模板类进行实例化时，编译器报错，显示为成员函数undefined，就是说我的成员函数未定义，这就让我纳闷了。 我试着将构造函数的定义移到头文件里去，再编译，运行，成功
ISODATA聚类分析算法原理与C++实现
King_DJF的博客
01-14 3442
文章目录Kmeans聚类算法的原理ISODATA聚类算法的原理ISODATA算法的基本步骤关键步骤原理代码实现代码结构主要类实现代码使用代码地址聚类效果分析内容参考 最近在填之前的坑，尝试用C++实现一个ISODATA的聚类分析算法，目前代码已经码完了，就慢慢的把文档给补上，记录一下自己零零碎碎做的工作；给自己立的flag画一个句号吧。 Kmeans聚类算法的原理 在分析一些数据前，我们需...
听歌识曲C++程序说明
King_DJF的博客
01-17 3233
听歌识曲C++程序说明 本工程在VS2015下编译运行；运行时，机器上需要已经安装有MySql软件，我使用的是MySql 5.7版本的，MySql C++ connector用的是1.19版本的; 直接拿过来编译肯定是编译不过的，详情见下描述 工程目录说明 3rd_party : 第三方库 boost_1_62_0 : boost库 Eigen : 矩阵与FFT maximili
约瑟夫问题C++单向循环链表分文件数据结构
06-07
好的，我可以帮你解答这个问题。 首先，让我们来了解一下约瑟夫问题的背景。约瑟夫问题是一个经典的问题，据传是由古代历史学家约瑟夫斯(Josephus)提出的。问题的具体描述如下： 有n个人围成一圈，从第一个人开始报数，报到m的人出圈，剩下的人继续从1开始报数，直到剩下最后一个人。求出最后一个出圈的人的编号。 为了解决这个问题，我们可以使用单向循环链表来实现。下面是一个简单的C++单向循环链表的实现，包含了三个文件：Node.h、List.h和List.cpp。 首先是Node.h文件，用来定义节点类： ```cpp // Node.h #ifndef NODE_H #define NODE_H class Node { public: int data; Node* next; Node(int data) { this->data = data; next = nullptr; } }; #endif ``` 然后是List.h文件，用来定义链表类： ```cpp // List.h #ifndef LIST_H #define LIST_H #include "Node.h" class List { public: List(); ~List(); void insert(int data); void remove(Node* node); Node* getHead(); Node* getNext(Node* node); private: Node* head; }; #endif ``` 最后是List.cpp文件，用来实现链表类的方法： ```cpp // List.cpp #include "List.h" List::List() { head = nullptr; } List::~List() { Node* curr = head; while (curr != nullptr) { Node* temp = curr; curr = curr->next; delete temp; } } void List::insert(int data) { Node* node = new Node(data); if (head == nullptr) { head = node; head->next = head; } else { Node* curr = head; while (curr->next != head) { curr = curr->next; } curr->next = node; node->next = head; } } void List::remove(Node* node) { Node* curr = head; if (node == head) { head = head->next; } else { while (curr->next != node) { curr = curr->next; } curr->next = node->next; } delete node; } Node* List::getHead() { return head; } Node* List::getNext(Node* node) { return node->next; } ``` 现在我们就可以使用这个单向循环链表来解决约瑟夫问题了。下面是一个简单的解决方案： ```cpp #include <iostream> #include "List.h" int josephus(int n, int m) { List list; for (int i = 1; i <= n; i++) { list.insert(i); } Node* curr = list.getHead(); while (n > 1) { for (int i = 1; i < m; i++) { curr = list.getNext(curr); } Node* temp = curr; curr = list.getNext(curr); list.remove(temp); n--; } return list.getHead()->data; } int main() { int n = 5; int m = 3; int result = josephus(n, m); std::cout << "The last person is " << result << std::endl; return 0; } ``` 这个程序将输出： ``` The last person is 4 ``` 这就是使用C++单向循环链表解决约瑟夫问题的一个简单的例子。希望能对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值