数据结构与算法学习笔记——List ADT C++实现

最新推荐文章于 2023-04-26 13:50:16 发布
最新推荐文章于 2023-04-26 13:50:16 发布
阅读量1k 收藏 10
点赞数 2
分类专栏： 数据结构与算法分析学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46574339/article/details/113795824
版权

数据结构与算法学习笔记——List ADT C++实现

List ADT

 

1 特点

List的数据结构为线性结构
 
线性结构的特点：各结点元素间存在顺序关系，每个元素（除了头部和尾部）都有唯一的前驱和后继
 

2 包含的操作

  • 插入一个元素：insert()
  • 删除一个元素：remove()
  • 查找第k个元素：findKth()
  • 顺序打印List：print()
  • 反转List：invert()
     

3 实现方式

 

3.1 基于数组实现

基于数组实现的List做查找操作比较简单，但做插入和删除操作时会产生大量元素移动

做插入操作时，移动元素要从后往前；做删除操作时，移动元素要从前往后

实际上这里结点元素的总数不能超出定义数组时数组的大小，避免超出范围时再插入元素的程序没有写

List.h

#include <iostream>
const int N = 12;       // 数组大小

template <typename T>
class List
{
public:
    List();
    ~List();
    T array[N] = {0};     // 数组
    T findKth(int);
    void insert(int, T);
    void remove(int);
    void invert();
    void print();
private:
    int _number;       // 记录链表元素总数(从1开始计)
protected:
};

List.cpp

#include "List.h"

/*
 * 创建链表，以-1为结束标志
 */
template <typename T>    
List<T>::List()    
{
    _number = 0;
    for(int i = 0; i < N; i++)
    {
        std::cout << "input the num:" << std::endl;
        std::cin >> array[i];
        if(array[i] == -1)
            break;
        _number++;
    }
}
/*
 * 清空List
 */
template <typename T>
List<T>::~List()
{

}
/*
 * 查找第k个元素（k从0开始）
 */ 
template <typename T>
T List<T>::findKth(int k)       
{
    return array[k];
}
/*
 * 在第k位置插入一个元素，插入元素的成员num值为a
 */
template <typename T>            
void List<T>::insert(int k, T a)
{
    for(int i = _number - 1; i >= k; i--)
    {
        array[i + 1] = array[i];
    }
    array[k] = a;
    _number++;
}
/*
 * 删除第k位置的元素
 */ 
template <typename T>            
void List<T>::remove(int k)
{
    for(int i = k; i < _number - 1; i++)
    {
        array[i] = array[i + 1];
    }
	_number--;
}
/*
 * 将链表逆序
 */ 
template <typename T>           
void List<T>::invert()
{
    for(int i = 0; i < _number / 2; i++)
    {
        T temp;
        temp = array[i];
        array[i] = array[_number - 1 -i];
        array[_number - 1 -i] = temp;
    }
}
/*
 * 打印链表所有元素
 */
template <typename T>       
void List<T>::print()
{
    for(int i = 0; i < _number; i++)
    {
        std::cout << array[i] << '\t';
    }
    std::cout << std::endl;
}

template class List<int>;
template class List<float>;
template class List<double>;

main.cpp

#include <iostream>
#include "List.h"

int main()
{
    List<int> list1;
    list1.print();
    int n, num;
    std::cout << "you want to insert to node n:" << std::endl;
    std::cin >> n;
    std::cout << "input the num:" << std::endl;    
    std::cin >> num;
    list1.insert(n, num);
    list1.print();
    std::cout << "you want to delete node n:" << std::endl;
    std::cin >> n;
    list1.remove(n);
    list1.print();
    list1.invert();
    list1.print();
    std::cout << "the 6th node's data is: " << list1.findKth(6) << std::endl;
    return 0;
}

运行结果：
在这里插入图片描述

3.2 基于单链表实现

基于单链表实现时做插入、删除操作比较简单，但查找操作比基于数组的List复杂

结点元素的创建和清除分别写在了List类构造函数和析构函数中。清空List时要注意，delete之后要给对应指针赋值为NULL，以避免出现野指针

在插入和删除操作中，要注意插入/删除的是否为表头/尾部

List.h

#include <iostream>

template <typename T>   // 节点
struct Node     
{
    T data;
    Node *next;
};

template <typename T>
class List
{
public:
    List();
    ~List();
    Node<T> *head;      // 头指针
    Node<T> *findKth(int);
    void insert(int, T);
    void remove(int);
    void invert();
    void print();
private:
    int _number;       // 记录链表元素总数(从1开始计)
protected:
};

List.cpp

#include "List.h"

/*
 * 创建链表，以-1为结束标志
 */
template <typename T>    
List<T>::List()    
{
    // 注释掉的内容是另一种创建链表的方法，仅用一个指针即可实现，缺点是无法把结束标志元素“-1”去除出链表
    // Node<T> *head, *p;
    // head = p = new Node<T>;
    // std::cout << "input the num:" << std::endl;
    // std::cin >> p->data;
    // _number = 0;
    // for(;p->data != -1;)
    // {
    //     p->next = new Node<T>;
    //     p = p->next;
    //     std::cout << "input the num:" << std::endl;
    //     std::cin >> p->data;     
    //     _number++;   
    // }
    // p->next = NULL;
    Node<T> *p1, *p2;
    this->head = p1 = p2 = new Node<T>;
    std::cout << "input the num:" << std::endl;
    std::cin >> this->head->data;
    _number = 1;
    for(;;)
    {
        p1->next = new Node<T>;
        p1 = p1->next;
        std::cout << "input the num:" << std::endl;
        std::cin >> p1->data;
        if(p1->data == -1)
            break;
        p2 = p1;
        _number++;
    }
    delete p2->next;
    p2->next = NULL;
}
/*
 * 清空List
 */
template <typename T>
List<T>::~List()
{
    Node<T> *p1 = this->head;
    Node<T> *p2 = p1;
    for(;p1 != NULL;)
    {
        p1 = p1->next;
        delete p2;
        p2 = p1;
    }
    p2 = NULL;      // 要记住delete后面要有 p=NULL 以避免出现野指针
}
/*
 * 查找第k个元素（k从0开始）
 */ 
template <typename T>
Node<T> *List<T>::findKth(int k)       
{
    Node<T> *p = this->head;
    for(int i = 0; i < k; i++)
        p = p->next;
    return p;
}
/*
 * 在第k位置插入一个元素，插入元素的成员num值为a
 */
template <typename T>            
void List<T>::insert(int k, T a)
{
    Node<T> *pre = this->head;
    Node<T> *p = new Node<T>;
    if(k == 0)
    {
        this->head = p;
        p->next = pre;
    }
    else
    {
        pre = findKth(k - 1);
        p->next = pre->next;
        pre->next = p;        
    }
    p->data = a;
	_number++;
}
/*
 * 删除第k位置的元素
 */ 
template <typename T>            
void List<T>::remove(int k)
{
    Node<T> *pre = this->head;
    Node<T> *p = new Node<T>;
    if(k == 0)
    {
		delete this->head;
        this->head = pre->next;
    }
    else
    {
        pre = findKth(k - 1);
		p = pre->next;
		pre->next = pre->next->next;
		delete p;
		p = NULL;       
    }
	_number--;
}
/*
 * 将链表逆序
 */ 
template <typename T>           
void List<T>::invert()
{
    Node<T> *pre, *cur, *next;
	pre = this->head;
	cur = this->head->next;
	next = this->head->next->next;
	this->head->next = NULL;
	for(;next != NULL;)
	{
		cur->next = pre;
		pre = cur;
		cur = next;
		next = next->next;
	}
    cur->next = pre;
	this->head = cur;
}
/*
 * 打印链表所有元素
 */
template <typename T>       
void List<T>::print()
{
    Node<T> *p = this->head;
    for(; p != NULL; p = p->next)
        std::cout << p->data << '\t';
    std::cout << std::endl;
}

template class List<int>;
template class List<float>;
template class List<double>;

main.cpp

#include <iostream>
#include "List.h"

int main()
{
    List<int> list1;
    list1.print();
    int n, num;
    std::cout << "you want to insert to node n:" << std::endl;
    std::cin >> n;
    std::cout << "input the num:" << std::endl;    
    std::cin >> num;
    list1.insert(n, num);
    list1.print();
    std::cout << "you want to delete node n:" << std::endl;
    std::cin >> n;
    list1.remove(n);
    list1.print();
    std::cout << "the inverted List is:" << std::endl;   
    list1.invert();
    list1.print();
    std::cout << "the 6th node's data is: " << list1.findKth(6)->data << std::endl;
    return 0;
}

运行结果（结果同上）：
在这里插入图片描述

3.3 基于双向链表实现

基于双向链表的List同样具有基于单链表List插入删除简单的优势，同时比单链表List更方便查找

在插入/删除操作时，也要考虑要操作的是否为表头或尾部，要注意的情况比单链表时稍多

添加了函数inv_print()，功能是逆序打印，写这个函数的目的是测试元素与其前一个元素的连接关系是否正常建立

List.h

#include <iostream>
template <typename T>
struct Node
{
    T data;
    Node *pre, *next;
};

template <typename T>
class List
{
public:
    List();
    ~List();
    Node<T> *head;
    Node<T> *findKth(int);
    void insert(int, T);
    void remove(int);
    void invert();
    void print();
    void inv_print();
private:
    int _number = 0;       // 记录链表元素总数(从1开始计)
protected:
};

List.cpp

#include "List.h"

/*
 * 创建链表，以-1为结束标志
 */
template <typename T>    
List<T>::List()    
{
    Node<T> *p1, *p2;
    head = p1 = p2 = new Node<T>;
    head->pre = NULL;
    std::cout << "input the num:" << std::endl;
    std::cin >> head->data; 
    for(;p1->data != -1;)
    {
        p2 = p1;
        _number++;
        p1->next = new Node<T>;
        p1 = p1->next;
        std::cout << "input the num:" << std::endl;
        std::cin >> p1->data; 
        p1->pre = p2;
    }
    delete p2->next;
    p2->next = NULL;
}
/*
 * 清空List
 */
template <typename T>
List<T>::~List()
{
    Node<T> *p1, *p2;
    p1 = head;
    for(;p1 != NULL;)
    {
        p2 = p1;
        p1 = p1->next;
        delete p2;
    }
    p2 = NULL;
}
/*
 * 查找第k个元素（k从0开始）
 */ 
template <typename T>
Node<T> *List<T>::findKth(int k)       
{
    Node<T> *p = head;
    for(int i = 0; i < k; i++)
        p = p->next;
    return p;
}
/*
 * 在第k位置插入一个元素，插入元素的成员num值为a
 */
template <typename T>            
void List<T>::insert(int k, T a)
{
    Node<T> *p = new Node<T>;
    if(k == 0)
    {
        p->pre = NULL;
        p->data = a;
        p->next = head;
        head = p;
    }
    else if(k == _number)
    {
        p->pre = findKth(k - 1);
        p->data = a;
        p->next = p->pre->next;
        p->pre->next = p;
    }
    else
    {
        p->pre = findKth(k - 1);
        p->data = a;
        p->next = p->pre->next;
        p->pre->next = p;
        p->next->pre = p;
    }
    _number++;
}
/*
 * 删除第k位置的元素
 */ 
template <typename T>            
void List<T>::remove(int k)
{
    Node<T> *p;
    if(k == 0)
    {
        p = findKth(k);
        head = p->next;
    }
    else if(k == (_number - 1))
    {
        p = findKth(k);
        p->pre->next = NULL;
    }
    else
    {
        p = findKth(k);
        p->pre->next = p->next;
        p->next->pre = p->pre;
    }
    delete p;
    p = NULL;    
	_number--;
}
/*
 * 将链表逆序
 */ 
template <typename T>           
void List<T>::invert()
{
    Node<T> *p;
    for(p = head->next; p->next != NULL; p = p->pre)
    {
        Node<T> *temp;
        temp = p->pre;
        p->pre = p->next;
        p->next = temp;
    }
    head->pre = head->next;
    head->next = NULL;
    p->next = p->pre;
    p->pre = NULL;
    head = p;
}
/*
 * 打印链表所有元素
 */
template <typename T>       
void List<T>::print()
{
    Node<T> *p = head;
    for(;p != NULL; p = p->next)
        std::cout << p->data << '\t';
    std::cout << std::endl;
}
/*
 * 逆序打印链表所有元素
 */
template <typename T>
void List<T>::inv_print()
{
    Node<T> *p = findKth(_number - 1);
    for(; p != NULL; p = p->pre)
        std::cout << p->data << '\t';
    std::cout << std::endl;
}

template class List<int>;
template class List<float>;
template class List<double>;

main.cpp

#include <iostream>
#include "List.h"

int main()
{
    List<int> list1;
    list1.print();
    int n, num;
    std::cout << "you want to insert to node n:" << std::endl;
    std::cin >> n;
    std::cout << "input the num:" << std::endl;    
    std::cin >> num;
    list1.insert(n, num);
    list1.print();
    std::cout << "you want to delete node n:" << std::endl;
    std::cin >> n;
    list1.remove(n);
    list1.print();
    std::cout << "the inverted List is:" << std::endl;
    list1.invert();
    list1.print();
    std::cout << "the List printed in reverse order is:" << std::endl;
    list1.inv_print();
    std::cout << "the 6th node's data is: " << list1.findKth(6)->data << std::endl;
    return 0;
}

运行结果：
在这里插入图片描述

weixin_46574339
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法C++1
08-03
数据结构与算法是计算机科学的基础，C++是实现这些概念的强大工具。本课程主要涵盖了数据结构和算法的基本概念，以及如何使用C++进行实现。以下是根据标题、描述和部分内容提炼的相关知识点： 1. **数据结构**： -...
数据结构与算法案例合集
06-24
3. **C语言实现**：C语言是一种底层、高效的编程语言，适合实现数据结构和算法。C语言中的指针操作使得直接操控内存成为可能，这对于理解数据结构内部工作原理非常有帮助。例如，用C语言实现链表时，需要理解如何...
数据结构与算法学习笔记——栈ADT C++实现
weixin_46574339的博客
02-12 938
数据结构与算法学习笔记——栈ADT C++实现1 特点2 包含的操作3 实现方式3.1 基于数组实现（应用较多）3.2 基于单链表实现 1 特点 栈的数据结构为线性结构 栈只能在同一位置进行插入和删除，这个位置叫做栈顶。后进先出（LIFO），生活中的例子有坐电梯、去西红门绞肉机坐地铁 2 包含的操作 入栈（压栈） 出栈（弹出） 读栈顶元素 3 实现方式 3.1 基于数组实现（应用较多） 基于数组实现（非vector）的空间是静态的，空间不能再扩展，因此会出现空间不够的情况；但是从ADT角度出发不会有空
《数据结构与算法基础》学习笔记——第二章 线性表 List
鱼_丸 的 博客
08-15 1163
内容摘要：2.1线性表的定义和特点、2.2案例引入、2.3线性表的类型定义、2.4线性表的顺序表示和实现、2.5链表、2.6顺序表和链表的比较、2.7线性表的应用
1.数据结构C++学习笔记——线性表（顺序储存）
qq_46417568的博客
04-26 1071
● 线性表是是一种线性结构具有相同特性的数据元素的一个有限序列，数据元素之间的关系是线性。线性表中的数据元素类型可以为简单类型，也可以为复杂类型。● 数据元素的个数n定义为表的长度，当n=0时，称为空表。● 将非空的线性表（n>0）记作，这里的数据元素只是一个抽象的符号，其具体含义在不同的情况下可以不同。
数据结构与算法分析笔记（c++）_栈ADT
qq_35990574的博客
01-05 264
3.6 栈ADT 栈（stack）是限制插入和删除操作只能在一个位置上进行的表，该位置是表的末端，称为栈的顶（top）。对栈的基本操作是push（进栈）和pop（出栈），前者相当于插入，后者则是删除最后插入的元素。最后插入的元素可以通过使用top例程在执行pop之前进行访问。栈有时又称为LIFO（后进先出）表。普通的清空栈的操作和判断是否空栈的测试都是栈的操作指令系统的一部分，但是，对栈所能够做的所有操作基本上就是push和pop操作 一般的模型是，存在某个元素位于栈顶，而该元素是唯一的可见元素。 3.
数据结构与算法分析笔记（c++）_抽象数据类型（ADT）、表ADT、STL中的向量和表
qq_35990574的博客
12-22 1002
第三章 表、栈和队列 本章讨论最简单和最基本的三种数据结构。实际上，每一个有意义的程序都将明晰地至少使用一个这样的数据结构，而栈则在程序中总是要间接地用到，而不管你在程序中是否进行了声明。本章将： 介绍抽象数据类型（ADT）的概念。 阐述如何对表进行高效的操作。 ●介绍栈ADT及其在实现递归方面的应用。 ●介绍队列ADT及其在操作系统和算法设计中的应用。 在本章中，给出了两个库类 vector和1ist的重要子集的实现代码。 3.1抽象数据类型（ADT） 抽象数据类型（abstract data type，
数据结构与算法——图（二） 学习笔记
提小莫的寂寥的博客
03-06 537
二、ADT&邻接矩阵 2.1 Graph模板类 书上给出了Graph模板类的具体定义，太长了这里不贴了。主要记一下图的操作接口。图的操作接口分为边和顶点两类： 图支持的边操作接口： 操作接口 功能描述 e() 边总数 exist(v, u) 判断联边(v, u)是否存在 insert(v, u) 引入从顶点v到u的联边 remove(v, u) 删除从顶点v到u...
数据结构与算法——栈与队列（三） 学习笔记
提小莫的寂寥的博客
02-29 191
二、队列 队列（queue）仍为一种线性序列。与栈类似，队列也是受限的序列，其中一端只能够出，另一端只能够进。（联想排队时的情况） 只能在队尾插入（查询）：enqueue(), rear() 只能在队首删除（查询）：dequeue(), front() 图片摘自清华大学《数据结构（C++语言版）》 与栈结构恰好相反，队列中各对象的操作次序遵循先入先出（FIFO） 的规律。在社会资源或是各种计...
数据结构与算法——栈与队列（一） 学习笔记
提小莫的寂寥的博客
02-29 389
最近正在学清华大学的那门DSA，从现在开始就把学习笔记，以及过程中感悟、遇到的问题、解决方法都记录在博客里。就从今天学习的开始记录吧，之前用word记录的学习笔记后面有时间再慢慢往博客上面搬 一、栈 ADT接口 栈，stack，线性序列，但只能访问栈中的特定元素（栈的一端），其中开放的一端称为栈顶（top），不开放的另一端称为栈底（bottom）。 三个基本操作 入栈——将元素作为最顶部的元素插入...
数据结构（c++）学习笔记--列表
VaIOReTto1的博客
01-20 1557
数据结构学习笔记的一部分，主要用于个人记忆和复习，在代码和编辑习惯上也倾向于本人特点，主要专注于能读性和简便性。
数据结构与算法笔记-线性表定义和特点
01-07
线性表的定义和特点 # 定义： 由n (n>0)个数据特性相同的元素构成的有限序列称为线性表。 # 对于非空线性表或者线性结构，其特点是： 存在唯一的一个被称作...ADT 线性表 （list） Data 线性表的数据对象集合为{a1,a
青岛大学王卓数据结构与算法课程PPT截图
02-17
数据结构与算法是计算机科学中的核心课程，它们是理解和解决复杂计算问题的基础。青岛大学的王卓教授的这门课程，通过PPT的形式，深入浅出地讲解了这些关键概念。 首先，我们从"绪论"开始。绪论部分通常会介绍数据...
数据结构与算法PPT
04-17
在学习数据结构与算法的过程中，不仅要理解这些概念，还要通过实践来加深理解，如编写代码实现各种数据结构和算法，解决实际问题。同时，熟悉常见的算法分析技巧，如大O符号表示法，可以帮助我们评估和优化算法性能...
基于Springboot和Vue的图书借还管理系统源码 图书借还管理系统代码（高分毕设）
07-28
图书借还管理系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
C语言内存管理：静态与动态分配的较量
07-28
C语言是一种通用的编程语言，由丹尼斯·里奇（Dennis Ritchie）在20世纪70年代早期于美国电话电报公司（AT&T）的贝尔实验室开发。C语言以其高效性、灵活性和可移植性而闻名，它是一种过程式编程语言，提供了对底层硬件的直接访问能力。 C语言的特点包括： 1. **简洁高效**：C语言的语法简洁，执行效率高，适合编写系统软件。 2. **接近硬件**：C语言提供了对内存地址和位操作的直接控制，使其非常适合硬件级编程。 3. **可移植性**：C语言编写的程序可以在不同的操作系统和硬件平台上编译和运行，具有很好的可移植性。 4. **丰富的库支持**：C语言拥有大量的标准库，如标准输入输出库（stdio.h）、数学库（math.h）等。 5. **结构化编程**：C语言支持结构化编程，允许使用循环、条件判断和函数等控制结构。 6. **指针**：C语言的指针功能强大，可以操作内存地址，实现复杂的数据结构和算法。 7. **编译型语言**：C语言是一种编译型语言，源代码需要通过编译器转换成机器码才能运行。 C语言广泛应用于操作系统（如Unix和Linux）、嵌入式系统、高性能
通讯协议规范-命令包格式
07-28
提供一份通讯协议规范，包含命令包、格式等，在上下位机调试的时候可参考该文档，制定对应的通讯协议。
四足宠物机器狗动态步行规划与仿真.pdf
最新发布
07-28
四足宠物机器狗动态步行规划与仿真
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值