【数据结构】表ADT

已于 2024-03-29 21:18:49 修改
阅读量1.9k 收藏 36
点赞数 27
分类专栏： 数据结构与算法 文章标签： 数据结构 笔记 c++ 软件工程
于 2024-03-29 21:07:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62361897/article/details/137141222
版权

目录

1. 抽象数据类型（ADT）

  • 抽象数据类型（Abstract Data Type, ADT)： 带有一组操作的一些对象的集合。

2. 表 ADT

  • 表（list）：形如 A0, A1, A2, ···, A N-1，这个表的大小是N。
  • 大小为 0 的特殊的表称为空表（empty list）
  • 对于除空表外的任何表，称 Ai 后继Ai-1（或继 Ai-1 之后，i < N）并称 Ai-1 前驱 Ai（i > 0）。表中的第一个元素是A0，最后一个元素是AN-1。元素Ai在表中的位置（position）是 i 。
  • 表ADT的一些操作：
    • printList 和 makeEmpty 是常用的操作；
    • find 返回某一项第一次出现的位置；
    • insert 和 remove 一般是从表的某个位置插入和删除某个元素；
    • findKth 返回（作为参数而被指定的）某个位置上的元素

如果列表是34、12、52、16、12，则 find（52）返回2；insert（x、2）可以将表变成34、12、x、52、16、12（如果我们插入到给定的位置）；remove（52）可以将该表变成34、12、x、16、12。

2.1 表的简单数组实现

  • 虽然数组由固定容量所创建，但 vector 类（其内部存储一个数组）在需要的时候可以使其容量成倍地增长。
  • 数组实现可使 printList 以线性时间运行，而 findKth 操作则花费常数时间；插入和删除操作的最坏情况为 O(N)，平均情况需移动表的一半元素，需要线性时间，如果所有操作都发生在表的尾端（high end of the list），则花费 O (1) 时间。
  • 如果表是通过在尾端（high end）进行插入操作建成的，此后只发生对数组的访问（即只有 findKth 操作）。在这种情况下，数组是表的一种恰当的实现。

2.2 简单链表

为了避免插入和删除的线性开销，需保证表可以不连续存储，否则表的每个部分都可能需要整体移动。

一个链表

  • 链表（linked list）由一系列节点组成，这些节点不必在内存中相连。每一个节点均含有表元素和一个链（link），该链指向包含该元素后继元的另一个节点。我们称之为 next 链。最后一个单元的next链指向 nullptr。

从链表中删除：
从链表中删除

  • remove 方法可以通过修改一个 next 指针来实现。

向链表插入：
向链表插入

  • insert 方法使用 new 操作符创建一个新节点，再执行两次 next 指针操作。

原则上如果知道变动将要发生的地方，那么插入或从链表中删除一项的操作值涉及常数个节点链的改变。

典型的链表拥有到该表两端的链。

单向链表（每个节点均存储指向其下一节点的链）的局限性：在删除最后一项时，需要找出只想最后节点的项，将其 next 链改为 nullptr，但单向链表指向最后节点的链不提供关于最后节点的前驱节点的任何信息。

解决方案：
使用双向链表（doubly linked list），让每个节点持有一个指向它在表中的前驱节点的链。

双向链表

带有头节点和尾节点的双向链表：

带有头节点和尾节点的双向链表

带有头节点和尾节点的空的双向链表：

带有头节点和尾节点的空的双向链表

插入：

通过获取一个新节点然后以所指出的顺序修改指针而将新节点插入双向链表

删除：
从双向链表中删除由 p 所指定的节点

3. STL中的 vector 和 list

  • C++ 语言在其库中包含一些常用数据结构的实现。该语言这一部分通常叫作标准模板库（Standard Template Library, STL）。表 ADT（List ADT）是在 STL 中实现的数据结构之一。一般说来，这些数据结构被称为集合（collection）或容器（container）。

  • 表ADT 的两种流行实现方法：vector 和 list

    • vector 提供表 ADT 的一种可增长的数组实现。
      • 优点：以常数时间可索引（indexable）的
      • 缺点：插入新项和删除现有项的代价高昂，除非变化发生在vector的尾端。
    • list 提供表 ADT 的双向链表实现。
      • 优点：插入新项和删除现有项代价低廉，但假设变动的位置是已知的。
      • 缺点：list不容易被索引。
    • vector 和 list 两者在执行查找时都是低效的。

vector 和 list 两者均为类模板，它们用其所存储的项的类型来实例化而成为具体的类。二者有几个方法是共有的。前三种方法实际上对所有的 STL 容器都是可用的：

  • int size( ) const：返回容器中元素的个数。
  • void clear( )：从容其中删除所有元素。
  • bool empty( ) const：若容器不含有元素则返回 true，否则返回 false。

vector 和 list 两者都支持以常数时间向表的尾端添加和从表的尾端删除的操作。 vector 和 list 两者都支持以常数时间访问表的前端项。这些操作是：

  • void push_back(const Object & x)：把 x 添加到表的尾端。
  • void pop_back( ) ：删除位于表的尾端的对象。
  • const Object & back( ) const：返回位于表的尾端处的对象（还提供一个返回引用的修改函数）。
  • const Object & front( ) const：返回位于表的前端处的对象（还提供一个返回引用的修改函数）。

因为双向链表在其前端可以进行高效的改动，而 vector 不能，所以下列两个方法只对 list 是可用的：

  • void push_front( const Object & x)：把 x 添加到表的前端。
  • void pop_front( )：删除位于表的前端处的对象。

vector 有自己的方法集，这些方法 list 不具备。有两个方法可以进行高效的索引操作，而其余两个方法允许程序员查看和改变内部容量。这些方法是：

  • Object & operator[ ] ( int idx )：返回 vector 中下标为 idx 的对象，不带界限检验（还提供一个返回常量引用的访问函数）。
  • Object & at( int idx )：返回 vector 中下标为 idx 的对象，带有界限检验（还提供一个返回常量引用的访问函数）。
  • int capacity( ) const：返回 vector 的内部容量。
  • void reserve (int newCapacity)：设置新的容量。如果有好的估计可用，那么可用于避免扩展 vector。

4. vector 的实现

提供一个 第一类类型（first-class type） 的 vector 类模板，其含义为，不同于C++中的原始数组（primitive array），该 vector对象可以被复制，并且所用内存可以（通过其析构函数）被自动回收。

C++原始数组的一些重要特征：

  • 数组就是指向一块内存块的指针变量；数组的具体大小必须由程序员单独确定。
  • 内存块可以通过 new[ ] 分配，但此后必须通过 delete[ ] 释放。
  • 内存块不能重新调整大小（但可以获得一个新的、根据推测可能更大的内存块，并利用原来的内存块初始化，然后将原内存块释放）。

vector类：

#include<algorithm>

template<typename Object>
class Vector
{
	public:
//		构造函数，允许用户指定初始大小（默认值为0），
//      然后用比大小稍大的容量初始化数据成员 
		explicit Vector(int initSize = 0) : theSize{initSize},
			theCapacity{ initSize + SPARE_CAPACITY}
		{
			objects = new Object[theCapacity];
		}
		
//		拷贝构造函数 
		Vector(const Vector & rhs) : theSize{rhs.theSize},
			 theCapacity{ rhs.theCapacity }, objects{ nullptr }
		{
			objects = new Object[theCapacity];
			for(int k = 0; k < theSize; ++k)
				objects[k] = rhs.objects[k];
		}
		
//		拷贝赋值 
		Vector & operator= (const Vector & rhs)
		{
			Vector copy = rhs;
			std::swap(*this, copy);
			return *this;
		}
		
		~Vector()
		{ delete [ ] objects; }
		
//		移动构造函数 
		Vector (Vector && rhs) : theSize{ rhs.theSize },
			theCapacity{ rhs.theCapacity }, objects{ rhs.objects }
		{
			rhs.objects = nullptr;
			rhs.theSize = 0;
			rhs.theCapacity = 0;
		}	
		
//		移动 operator= 
		Vector & operator= (Vector && rhs)
		{
			std::swap(theSize, rhs.theSize)
			std::swap(theCapacity, rhs.theCapacity);
			std::swap(objects,rhs.objects);
			
			return *this;
		}
		
		void resize(int newSize)
		{
			if(newSize > theCapacity)
				reserve(newSize*2);
			theSize = newSize;
		}
		
//		扩展容量 
		void reserve(int newCapacity)
		{
			if(newCapacity < theSize)
				return;
				
			Object *newArray = new Object[ newCapacity ];
			for(int k = 0; k < theSize; ++k)
				newArray[k] = std::move(objects[k]);
				
			theCapacity = newCapacity;
			std::swap(objects, newArray);
			delete [ ] newArray;
		}
		
		
		Object & operator[](int index)
		{ return objects[ index ]; }	
		const Object & operator[](int index) const
		{ return objects[ index ];}
		
		bool empty() const
		{ return size()==0; }
		int size() const
		{ return theSize; }
		int capacity() const
		{ return capacity; }
		
		void push_back(const Object & x)
		{
			if(theSize == theCapacity)
				reserve(2 * theCapacity + 1);
			objects[theSize++] = x;
		}
		
		void push_back(Object && x)
		{
			if(theSize == theCapacity)
				reserve(2*theCapacity + 1);
			object[theSize++] = std::move(x);
		}
		
		void pop_back()
		{
			--theSize;
		}
		
		const Object & back() const
		{
			return objects[theSize - 1];
		}
		
		
		/**
		 * iterator 和 const_iterator 内嵌类型的声明
		 * begin 返回第一个数组位置的内存地址 
		 * end 返回第一个非法数组位置的内存地址 
		 */ 
		typedef Object* iterator;
		typedef const Object * const_iterator;
		
		iterator begin()
		{ return &objects[0]; }
		const_iterator begin() const
		{ return &objects[0]; }
		iterator end()
		{ return &objects[size()]; }
		const_iterator end() const
		{ return &objects[size()]; }
		
		static const int SPARE_CAPACITY = 16;
		
	private:
		int theSize;		// 大小 
		int theCapacity;	// 容量 
		Object * objects;	// 原始数组 
};

5. list 的实现

list类：

template<typename Object>
class List
{
	private:
		struct Node
		{
			Object data;	// 所存储的项 
			Node   *prev;	// 指向前一节点的指针 
			Node   *next;	// 指向下一节点的指针 
		
			Node(const Object & d = Object{}, Node *p = nullptr, Node *n = nullptr)
				: data{d}, prev{p}, next{n} { }
			
			Node(Object && d, Node *p = nullptr, Node *n = nullptr)
				: data{std::move(d)}, prev{p}, next{n} { }
		};
		
	public:
		class const_iterator
		{
			public:
				const_iterator() : current{ nullptr }
				{ }
				
				const Object & operator* ( ) const
				{ return retrieve(); }
				
				const_iterator & operator++( )
				{
					current = current->next;
					return *this;
				}
				
				const_iterator operator++(int)
				{
					const_iterator old = *this;
					++(*this);
					return old;
				}
				
				bool operator==(const const_iterator & rhs) const
				{ return current == rhs.current; }
				bool operator!=(const const_iterator & rhs) const
				{ return !(*this==rhs); }
				
			protected:
				Node *current;
				
				Object & retrieve() const
				{ return current->data; }
				
				const_iterator(Node *p) : current{p}
				{ }
				
				//friend声明，赋予了 List 类访问 const_iterator 的非公有成员的权利 
				friend class List<Object>; 
			
		};
		
//		继承（inheritance）：iterator 类继承了 const_iterator 的所有数据和方法 
		class iterator : public const_iterator
		{
			public:
				iterator()
					{ }
					
				Object & operator*()
				{ return const_iterator::retrive(); }
				const Object & operator*() const
				{ return const_iterator::operator*();}
				
				iterator & operator++()
				{
					this->current = this->current->next;
					return *this;
				}
				
				iterator operator++(int)
				{
					iterator old = *this;
					++( *this );
					return old;
				}
			
			protected:
				iterator(Node *p) : const_iterator{ p }
				{ }
				
				friend class List<Object>; 
		};
		
	public:
		List()
		{ init(); }
		
		~List()
		{
			clear();
			delete head;
			delete tail;
		} 
		
		List(const List & rhs)
		{
			init();
			for(auto & x : rhs)
				push_back(x);	
		}
		
		List & operator= (const List & rhs)
		{
			List copy = rhs;
			std::swap(*this,copy);
			return *this;
		} 
		
		List(List && rhs)
			: theSize{rhs.theSize}, head{rhs.head}, tail{rhs.tail}
		{
			rhs.theSize = 0;
			rhs.head = nullptr;
			rhs.tail = nullptr;
		} 
		 
		List & operator= (List && rhs)
		{
			std::swap(theSize, rhs.theSize);
			std::swap(head, rhs.head);
			std::swap(tail, rhs.tail);
			
			return *this;
		}
		

		
		iterator begin()
		{ return {head->next}; }
		const_iterator begin() const
		{ return {head->next}; }
		iterator end()
		{ return {tail}; }
		const_iterator end() const
		{ return {tail}; }
		
		int size() const
		{ return theSize; }
		bool empty() const
		{ return size() == 0; }
		
//		clear方法，通过反复删除成员项直至 List 为空来完成清除工作 
		void clear()
		{
			while(!empty())
				pop_front();
		}
		
		Object & front()
		{ return *begin();}
		const Object & front() const
		{ return *begin();}
		Object & back()
		{ return *--end();}
		const Object & back() const
		{ return *--end();}
		
		void push_front(const Object & x)
		{ insert(begin(), x); }
		void push_front(Object && x)
		{ insert(begin(), std::move(x)); }
		void push_back(const Object & x)
		{ insert(endd(), x); }
		void push_back(Object && x)
		{ insert(end(), std::move(x)); }
		void pop_front()
		{ erase(begin()); }
		void pop_back()
		{ erase(--end()); }
		
		// 在 itr 前插入 x 
		iterator insert(iterator itr, const Object & x)
		{
			Node *p = itr.current;
			theSize++;
			return { p->prev = p->prev->next = new Node{x, p->prev, p}};

//			对节点指针的赋值具体步骤 
//			Node *newNode = new Node{x, p->prev, p};
//			p->prev->next = newNode;
//			p->prev = newNode;
//			合并为： 
//			p->prev = p->prev->next = new Node{x, p->prev, p}	
		}
		// 在 itr 前插入 x 
		iterator insert(iterator itr, Object && x)
		{
			Node *p = itr.current;
			theSize++;
			return { p->prev = p->prev->next = new Node{std::move(x), p->prev, p}};
		}
		
		// 删除在 itr 处的项 
		iterator erase(iterator itr)
		{
			Node *p = itr.current;
			iterator retVal{p->next};
			p->prev->next = p->next;
			p->next->prev = p->prev;
			delete p;
			theSize--;
			
			return retVal;
		}
		iterator erase(iterator from, iterator to)
		{
			for(iterator itr = from; itr != to;)
				itr = erase(itr);
				
			return to;
		}
		
	private:
		int theSize;	// 大小 
		Node *head;		// 指向头节点的指针 
		Node *tail;		// 指向尾节点的指针 
		
		void init()
		{
			theSize = 0;
			head = new Node;
			tail = new Node;
			head->next = tail;
			tail->prev = head;
		}
		
}
turtleSteps
关注
  • 27
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【数据结构】ST表
Rainfoo的博客
01-15 184
题目链接，洛谷P3865 https://www.luogu.com.cn/problem/P3865 模板代码： #include<iostream> #define ll long long #define endl '\n' #define IO ios::sync_with_stdio(false);cin.tie(0); using namespace std; const ...
链表ADT数据结构代码
12-02
在本项目中，我们关注的是“链表ADT（抽象数据类型）”的实现，它遵循了ADT的基本原则，即将数据结构与操作这些数据结构的算法分离。以下是对每个文件和相关知识点的详细解释： 1. **SqList.h**：这是链表的头文件...
表ADT（抽象数据类型）
thdwx的博客
09-18 540
表ADT（抽象数据类型） 抽象数据类型是指一系列操作的集合。抽象数据类型是数学上的抽象，在ADT的定义中并没有指出这些操作的具体实现，只给出了操作的功能。当需要使用ADT时，由程序员根据所需要的操作来进行编写，需要进行ADT中的操作时只需要调用已经写好的函数即可。 一般处理的是形如 A1,A2...An 的表，这个表的大小为n，大小为0的表称为空表。对除空表外的表，称 Ai+1 为 Ai 的后继，称 Ai-1 为 Ai 的前驱，不定义 A1 的前驱，也不定义 An 的后继。表ADT中有：PrintList（
表ADT的两种实现
白茶
10-28 785
表的简单数组实现 对表的所有操作都可以通过数组来实现，它可以使得printList以线性时间被执行，而findKth操作则花费常数时间，不过，插入和删除的花费却潜藏着昂贵的开销，这取决于插入和删除发生在什么地方。 最坏的情况下，插入和删除发生在数组的最前端，那么整个数组的元素都将后移或者是前移一个位置。 最好的情况下，即插入和删除发生在数组的末端，那么就没有元素需要移动。 所以，在很少对表进行插入...
数据结构：顺序表ADT的实现
Viadimir的博客
09-23 3034
线性结构是简单且常用的数据结构，而线性表是一种典型的数据结构。 一般情况下，如果需要在程序中存储数据，最简单、最有效的方法是把它们存放在线性表中。只有当需要组织和搜索大量数据时，才会考虑使用更复杂的数据结构。 在所有的数据结构中，最简单的是线性表。通常，定义线性表为n(n>=0)个数据元素的一个有限的序列。记为： ...
数据结构与算法分析初学2——表ADT的实现
最新发布
m0_74075257的博客
01-17 209
数据结构的初学者对链表的一些自我总结（有误欢迎指正）
数据类型ADT 表的编程与实现
timerring的博客
07-10 2万+
一 、目的： 1.加深对抽象数据类型ADT表的理解； 二 、环境： operating system version：Win11 CPU instruction set: x64 Integrated Development Environment：Viusal Studio 2022 三 、内容： 编写程序实现ADT表的定义，及常用操作： 1) 判断表是否为空； 2) 获取第i个节点的内容 3) 删除 4) 插入 四 、步骤： 1.程序2.程序结果： （1）运行，先调用Cre.
哈希表数据结构ADT实现代码
12-02
哈希表（Hash Table）是一种高效的数据结构，用于存储和检索键值对。它通过将键（Key）映射到数组的索引位置来实现快速访问。哈希表的实现通常涉及两个主要部分：哈希函数和冲突解决策略。在这个项目中，我们将深入...
广义表数据结构ADT实现代码
12-02
对于广义表ADT，我们通常会定义以下操作：创建空表、插入元素、删除元素、查找元素、输出广义表、获取表长度以及转换为其他数据结构（如树或图）。 在给定的文件中，`GList.h`头文件应该包含了ADT的接口定义，包括...
单链表双向链表ADT_C语言项目
04-04
Singly Linked List： 1. DestroyList 2. InsertList 3. DeleteList 4. TraverseList 5. SearchList 6. ReverseList 7. IsLoopList 8. ReverseEvenList 9. FindMidNode ...5. TraverseList_DuL
顺序栈ADT数据结构代码
12-02
顺序栈（Sequential Stack）是计算机科学中一种基本的数据结构，它是线性表的一种特殊形式，具有后进先出（LIFO）的特点。在顺序栈中，元素存储在一块连续的内存区域，通常通过数组来实现。本文将详细介绍顺序栈的...
数据结构：链式表ADT的实现
Viadimir的博客
09-23 1436
链表适用于插入或删除操作频繁，存储空间需求不定的情形。链表分很多种，有单链表、双链表、循环链表等，这里我以单链表为例，实现单链表的ADT。 单链表是一种最简单的链表表示，也叫作线性链表。用它来表示线性表时，用指针表示节点间的逻辑关系。因此单链表的一个存储节点包含两部分： ...
基础的表ADT -数据结构（C语言实现）
weixin_30477293的博客
09-08 410
读数据结构与算法分析 表的概述 形如A1,A2,A3... 操作合集 PrintList MakeEmpty Find Insert Delete 表的简单数组实现 分析： PrintList和Find操作线性时间 Find操作常数时间 Insert和Delete操作效率低下 所以一般不用数组实现 链表的指针实现 设计思路 在内存中不必相连 每个结构包含表元素和指向该元素后继...
抽象数据类型——表ADT(一)
little_nine的博客
07-28 1160
（一）表的相关定义 大小为N,形如A1A1A_{1}, A2A2A_{2}, A3A3A_{3}, ········, ANANA_{N}。大小为0的表成为空表。 对于除空表外的任何表，我们 Ai+1Ai+1A_{i+1} 后继 AiAiA_i（或继AiAiA_i之后）并称 Ai−1Ai−1A_{i-1}（i &amp;amp;amp;amp;amp;lt; N ）前驱 AiAiA_i(i &amp;amp;amp;amp;amp;gt; 1)。 （二）表的实现 1.
表ADT
char_c的博客
04-19 321
表ADT（Abstract Data Type）
【数据结构】回顾表ADT
weixin_34032621的博客
05-07 115
1.对于表的所有操作来说，都可以使用数组来实现，而且数组虽然是静态分配的，但内部存储数组的vector类却允许在需要时将数组的大小增加一倍。 2.正是因为数组的实现，使得printList以线性时间来执行，而findkth甚至是通过常数时间。最不济的是插入和删除了，如果位置不好，比如说在0号位置插入就需要将整个数组的所有元素都向后移，...
Eclipse中离线安装ADT插件详细教程
热门推荐
Dr.Neo的专栏
07-18 7万+
在搭建Android开发环境的时候，我们需要为Eclipse安装ADT（Android Development Tools）插件，这个插件可以为用户提供一个强大的Android集成开发环境。通过给Eclipse安装ADT插件，用户才能够完成快速新建Android项目、创建界面、调试程序、导出apk等一系列的开发任务。 一般论坛或博客上关于Android开发环境搭建的帖子在讲Eclipse安装ADT插件的时候，都是通过在线安装的方式。不过这种方法有几大缺陷，一是由于ADT插件是从http://dl-ssl.g
java表 ADT
jm_wang的博客
01-09 584
实现方法： 1. 简单数组 2. 简单链表 数组 对于表的所有操作都可通过简单数组来实现，虽然数组是固定容量的，但在需要时我们可通过创建一个新数组来扩大容量。使用数组实现其遍历输出时间是线性的，查找花费常数时间。但插入和删除将花费大量开销，当然要看插入删除所发生的位置。最坏情况为在位置0操作，最好情况则为在末尾操作。 链表 与数组相比链表的输出和查找时间都将增大，
数据结构：ADT概念与C语言实现示例
在严蔚敏的数据结构讲义中，首先...总结起来，严蔚敏的课程内容涵盖了数据结构的基本概念、C语言应用、抽象数据类型的设计原则以及具体数据结构（如链表和顺序表）的优缺点，这些都是学习数据结构时不可或缺的知识点。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

turtleSteps

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值