数据结构——线性表

最新推荐文章于 2023-12-29 10:53:18 发布
原创 最新推荐文章于 2023-12-29 10:53:18 发布 · 208 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

                                  线性表

数据类型的概念

       我曾经问过我的一些非计算机专业朋友对“数据类型”这个概念怎么理解，他们的回答基本上都是说数据类型应该就是指数据的一种类型划分吧，就像把人分成白种人、黑种人和黄种人，或者把动物分成什么种属之类的。
      确实是这样，数据类型就是对数据的一种类型标注，比如最基本的一些数据类型，int型表示32位2进制的整数类型，double表示双精度浮点类型、char表示字符类型。在计算机世界中，所以的信息都是离散的，因为现代计算机只能处理二进制数据，数据必须编码成二进制后计算机才能理解以及处理。在信息储存时，也只能把数据编码成二进制后才能储存在一些物理介质中，现代的储存介质基本都是磁介质或者半导体材料的，都只能储存二进制数据，比如说磁介质，用阴极和阳级分别表示0和1。由于计算机世界只存在0和1两个数字，因而表示其他数据类型的时候就必须有个长度，如果没有长度限制的话，全是0和1的组合就不知道一个数据由哪一段0和1组合构造了，这样混乱的0和1数据也就失去了存在的意义。这是导致数据类型有长度属性的决定性原因。由于长度的问题，就导致了计算机数据必须都是一个一个的，在现实生活中，时间是连续的（就不考虑量子力学了），但在计算机世界中，要表示时间，就必须用一个一个时间点来表示。
       计算机世界由于都是0和1，不容易让人理解，所以就引入了抽象数据类型（ADT，Abstract Data Type)在计算机的数据世界中表示真实世界的万事万物，比如说现实世界中的一个人，有年龄、性别、姓名等等，那么就在计算机中也用一个People类型来表示人，这种People数据类型也有年龄，年龄用一个整数来表示，性别可以用一个字符来表示，'w'表示女性，'m'表示男性，姓名可以用一个字符串来表示，也就是一个字符的序列。人在现实世界中的属性不可以被完全描述的，而在用计算机来描述一个人的时候，都是有特定场景的，因而也只需要关注这个场景所需要人的哪些属性。比如说人在学生管理系统中，就只需要姓名、年龄、性别、身体证号等信息，而人有哪些爱好之类的属性就不需要被关注。
       简而言之，抽象数据类型就是在一个场景中，把现实世界中的某个事物的某些属性映射到计算机世界中，并用相应的更基本的数据类型来表示，以此来更方便地对信息数据进行处理。


线性表的基本特征

       线性表是一种由相同类型的数据元素组成的具有顺序的有限序列，每个线性表实例都有自己的类型，可能储存和自己类型相同或者继承于自己类型的数据元素才能添加到线性表中。线性表可以很方便地管理数据元素集合，可以添加、插入到特定位置，可以替换删除，当然还有最基本的取元素。线性表可以像数组那样按下标位置取元素。在真实的开发环境中，线性表应该是除了数组之外使用最多的一种集合类型，数组也许都不能称之为集合类型，因为数组是编程语言提供的一种数据类型，在C/C++中就是一个指针。线性表比数组的优势很明显，数组是固定长度的，而线性表可以动态扩容，当然在正常情况下线性表也会更耗内存，因为线性表要申请额外的内存来保证申请内存的次数尽量少，采用这样用空间来换时间的策略。但由于线性表可以扩容，在修改操作较频繁的系统中，使用线性表会比使用数组高效得多，因为如果采用链表实现的线性表，会比数组少元素移动和数组copy的操作。
       根据线性表的基本特性，可以发现线性表有两种实现方法，分别是顺序储存结构和链式储存结构。
       其中，顺序储存结构是充分利用了计算机硬件储存设备的顺序读写的特性。不管是硬盘还是内存条，计算机在读写数据的时候都是维持了一个读写指针，很多时候这个读写指针是物理存在的。如果采用顺序储存结构，那么在读写的时候就可以让读写指针按顺序地进行扫描了，不用来回地移动指针来寻找特定的位置，这样大大减少了物理寻址时间。
       而链式储存结构，就是把一个数据元素结点存放在任意的位置(当然，不可能是绝对的任意位置，操作系统会做相应的优化的限制),在数据集合中逻辑相邻的元素可以在储存中相隔很远，只是保存了相邻元素的地址。如果想到访问相邻元素的话，就根据这个地址再去查找就好了。这样的好处是在集合修改时，由于元素的物理位置是分散的，修改了集合的逻辑结构并不会破坏其物理结构，而如果使用顺序储存结构时，逻辑上的顺序结构被破坏就表示物理顺序结构也被破坏了，就要做相应的补救措施。比如在线性表的插入操作时，使用顺序储存结构，向表中间插入一个元素，就需要把插入位置之后所有元素都向后移动一位，让待插入元素放在移动后空出来的这个位置。而如果使用链式储存结构的话，就像一条铁链要在中间加一节一样，只需要在中间把两节断开，然后让待加入的前端连上断开的前面的那一节的后端，让待加入那节的后端连上断开的后面那一节的前端。这样其实只操作了原数据的两个元素，操作过程少了，所用的时间也相应的就少了，效率就相应高了。而如果要顺序遍历的话，链式储存结构就要不断地根据当前元素中存储的下一元素的位置去找下一个元素，在物理存储中就需要读写指针不断地回来移动查找，因为就算两个元素逻辑上相邻，它们物理上也不一定相邻，但是采用顺序储存结构的话，指针就只需要从一端顺序移向另一端了。
       从顺序储存结构和链式储存结构的特点可以看出，没有绝对好的存储结构的选择，只能在特定的场景中选择更适合场景的储存方式。比如在查找操作频繁的情况下，就采用顺序储存结构，如果是在修改操作频繁的情况下，就采用链式存储结构。

      为了方便选择和操作，可以使用C++面向对象的特性，定义线性表的基本操作，而把具体的储存结构延迟到子类中去实现。这样，我们在使用时就面向的是线性表，而不是具体的哪种存储结构，不需要关心底层是如何实现的，这样会大大提高工程式开发的效率。还可以使用C++支持泛型的特性来把线性表设计成模板类，做成真正的抽象数据类型，这样可以让元素不同类型时可以使用同一套线性表实现，这样在工程开发时可以减少开发代码量，而且更方便管理与维护。以上两点在计算机软件设计中表现为针对抽象而不是针对细节编程以及抽象具有更低的耦合性的两个原则。

下面是用C++实现的基于顺序储存结构和链式储存结构的线性表实现

#pragma once
#ifndef LIST_H
#define LIST_H
#include <iostream>
using namespace std;
namespace dataStructure 
{
	template<typename T>
	class List
	{
	public:
		List() {};
		virtual ~List() {};
		virtual int Length()const = 0;
		virtual bool Empty()const = 0;
		virtual void Clear() = 0;
		virtual void Traverse(void(*visit)(T &t))const = 0;
		virtual void GetElem(const int position, T &t) = 0;
		virtual bool SetElem(const int position, const T &t) = 0;
		virtual bool Delete(const int position, T &t) = 0;
		virtual bool Insert(const int position, const T &t) = 0;
		virtual void Add(const T &t) = 0;
	};
}
#endif
#pragma once
#pragma once
#ifndef ARRAYLIST_H
#define ARRAYLIST_H
#include "list.h"
namespace dataStructure
{
	template<typename T>
	class ArrayList :public List<T>
	{
	public:
		ArrayList();
		~ArrayList();
		int Length()const;
		bool Empty()const;
		void Clear();
		void Traverse(void(*visit)(T &t))const;
		void GetElem(const int position, T &t);
		bool SetElem(const int position, const T &t);
		bool Delete(const int position, T &t);
		bool Insert(const int position, const T &t);
		void Add(const T &t);
	private:
		const int DEFAULT_SIZE = 1000;//初始大小
		const int INCRE_SIZE = 100;//扩容大小
		int maxSize = DEFAULT_SIZE;//初始最大容量
		T* data;
		int size;
	};
	template<class T>
	ArrayList<T>::ArrayList()
	{
		data = new T[DEFAULT_SIZE];
	}
	template<class T>
	ArrayList<T>::~ArrayList()
	{
		delete data;
	}
	template<class T>
	int ArrayList<T>::Length()const
	{
		return size;
	}

	template<class T>
	bool ArrayList<T>::Empty()const
	{
		return size == 0;
	}
	template<class T>
	void ArrayList<T>::Clear()
	{
		size = 0;//只需要将数量清空即可，因为删除或查询时要先验证数量
	}
	template<class T>
	void ArrayList<T>::Traverse(void(*visit)(T &t))const
	{
		for (int i = 0;i < size;i++)
		{
			visit(data[i]);
		}
	}
	template<class T>
	void ArrayList<T>::GetElem(const int position, T &t)
	{
		if (position >= 0 || position < size)
		{
			t = data[position];
		}
	}
	template<class T>
	bool ArrayList<T>::SetElem(const int position, const T &t)
	{
		if (position < 0 || position >= size)
		{
			return false;
		}
		data[position] = t;
		return true;
	}
	template<class T>
	bool ArrayList<T>::Delete(const int position, T &t)
	{
		if (position <0 || position >= size)
		{
			return false;
		}
		for (int i = position;i < size - 1;i++) {
			data[i] = data[i + 1];
		}
		size--;
		return true;
	}
	template<class T>
	bool ArrayList<T>::Insert(const int position, const T &t)
	{
		if (position < 0 || position > size) //插入的位置非法
		{
			return false;
		}
		if (size >= maxSize)//扩容
		{
			maxSize += INCRE_SIZE;
			T *temp = new T[maxSize];
			memcpy(temp, data, sizeof(data));
			delete data;//释放原来的数组内存
			data = temp;
		}
		if (position == size)//插入到末尾
		{
			data[position] = t;
		}
		else//插入在中间或开头
		{
			for (int i = position;i < size;i++)
			{
				data[i + 1] = data[i];
			}
			data[position] = t;
		}
		size++;
		return true;
	}

	template<typename T>
	void ArrayList<T>::Add(const T &t)
	{
		if (size >= maxSize)//扩容
		{
			maxSize += INCRE_SIZE;
			T *temp = new T[maxSize];
			memcpy(temp, data, sizeof(data));
			delete data;//释放原来的数组内存
			data = temp;
		}
		data[size++] = t;
	}
}
#endif


#pragma once
#pragma once
#ifndef LINKLIST_H
#define LINKLIST_H
#include "list.h"
namespace dataStructure
{
	template<typename T>
	struct Node
	{
		T data;
		Node<T> *next = NULL;
		Node<T> *pre = NULL;
	};
	template<typename T>
	class LinkList :public List<T>
	{
	public:
		LinkList();
		~LinkList();
		int Length()const;
		bool Empty()const;
		void Clear();
		void Traverse(void(*visit)(T &t))const;
		void GetElem(const int position, T &t);
		bool SetElem(const int position, const T &t);
		bool Delete(const int position, T &t);
		bool Insert(const int position, const T &t);
		void Add(const T &t);
	private:
		Node<T> *header;//头节点不储存数据
		int size;
	};
	template<class T>
	LinkList<T>::LinkList()
	{
		header = new Node<T>;
		header->pre = NULL;
		header->next = NULL;
	}
	template<class T>
	LinkList<T>::~LinkList()
	{
		Node<T>* node = header;
		Node<T>* next = node->next;
		while (node) 
		{
			delete node;
			node = next;
			next = node->next;
		}
	}
	template<class T>
	int LinkList<T>::Length()const
	{
		return size;
	}

	template<class T>
	bool LinkList<T>::Empty()const
	{
		return size == 0;
	}
	template<class T>
	void LinkList<T>::Clear()
	{
		size = 0;//只需要将数量清空即可，因为删除或查询时要先验证数量
	}
	template<class T>
	void LinkList<T>::Traverse(void(*visit)(T &t))const
	{
		Node<T> *node = header->next;
		int index = 0;
		while (node && index++ < size) 
		{
			visit(node->data);
			node = node->next;
		}
	}
	template<class T>
	void LinkList<T>::GetElem(const int position, T &t)
	{
		if (position >= 0 && position < size)
		{
			Node<T> *node = header->next;
			int index = 0;
			while (node && (index++) != position)
			{
				node = node->next;
			}
			if (node)
			{
				t = node->data;
			}
		}
	}
	template<class T>
	bool LinkList<T>::SetElem(const int position, const T &t)
	{
		if (position < 0 || position >= size)
		{
			return false;
		}
		Node<T> *node = header->next;
		int index = 0;
		while(node && (index++) != position)
		{
			node = node->next;
		}
		if(node)
		{
			node->data = t;
		}
		else {
			return false;
		}
		return true;
	}
	template<class T>
	bool LinkList<T>::Delete(const int position, T &t)
	{
		if (position <0 || position >= size)
		{
			return false;
		}
		Node<T> *node = header->next;
		int index = 0;
		while(node && (index++) != position)
		{
			node = node->next;
		}
		if(node)
		{
			if(node->pre)
			{
				node->pre->next = node->next;//将当前节点的前一个节点的后驱指针指向后一个节点
			}
			if(node->next)
			{
				node->next->pre = node->pre;//将当前节点的后一个节点的前驱指针指向前一个节点
			}
			delete node;
			size--;
		}else
		{
			return false;
		}
		return true;
	}
	template<class T>
	bool LinkList<T>::Insert(const int position, const T &t)
	{
		if (position < 0 || position > size) //插入的位置非法
		{
			return false;
		}
		Node<T> *newNode = new Node<T>;
		newNode->data = t;
		//找到要插入位置的前一个节点
		Node<T> *node = header;
		if (size != 0 && position > 0)//列表不为空并且不是插在首个位置上
		{
			int index = 0;
			node = header->next;
			while (node && (index++) != position - 1)
			{
				node = node->next;
			}

		}
		newNode->pre = node;
		newNode->next = node->next;
		node->next = newNode;
		size++;
		return true;
	}

	template<typename T>
	void LinkList<T>::Add(const T &t)
	{
		//查找最后一个节点
		Node<T> *node = header;
		while(node->next)
		{
			node = node->next;
		}
		Node<T> *newNode = new Node<T>;
		newNode->data = t;
		newNode->pre = node;
		node->next = newNode;
		size++;
	}
}
#endif



#include "stdafx.h"
#include "arraylist.h"
#include "linklist.h"
using namespace dataStructure;
void visit(int &t) 
{
	cout << t << ",";
}
int main()
{
	List<int> *list = new ArrayList<int>;
	list->Add(30);
	cout << list->Empty() << endl;
	list->Add(10);
	list->Insert(1, 20);
	list->Traverse(visit);
	cout << endl;
	list->Clear();
	cout << list->Empty() << endl;
	list->Traverse(visit);
	system("pause");
	return 0;
}


在main函数中，可以直接把ArrayList替换成LinkList，程序可以执行相同的逻辑，而底层使用的数据结构是不同的。
     
408数据结构——线性表之C++实现顺序表
long99920的博客
05-22 623
可修改main函数内的注释，测试相应的顺序表操作。 #include <iostream> using namespace std; #define initSize 10 // 顺序表初始容量 // 创建顺序线性表(顺序表),动态分配内存空间地址 typedef struct { int *array; // 指向顺序表的指针 int maxSize,length; // 顺序表最大容量,顺序表当前长度 }sqList;
阿里内推总结
Benson的博客
04-04 9587
                                  阿里内推总结       先说说结果吧，阿里挂了，嗯，和很多小伙伴一样，我也是挂在阿里的HR手里了，阿里的HR是真的恐怖，希望将来要面阿里的小伙伴们，千万要当心HR面。不过，就像我们一个老师铁帅说的，有时候吧，真的要看缘分，可能我和阿里，真的是缘分未到吧，HR挂人肯定也是有她的考量的。今天晚上，收到了头条HR的offer通知，做A...
线性表的顺序实现:顺序表
m0_52902391的博客
04-30 202
博客简介 本博客参考了<<C++17从入门到精通>>的实战例子，在本文中将会对例子进行理解上的补充以及写一写自己的感悟 数据结构包括两种:逻辑结构和物理结构 1.逻辑结构:指的是数据对象中数据元素之间的交互关系，比如集合结构，线性结构，树形结构，图形结构，它们有着比如一对一，一对多，多对多这样的关系 2.物理结构:指的就是数据的逻辑结构在计算机中的存储形式，分为顺序存储和链式存储 这篇博客所要讲述的就是物理结构中的顺序存储方式，在后续的博客中我会更新数据的链式存储方式 如
线性表：顺序表的实现以及遍历扩容
最新发布
12-29 1139
Java学习手册+面试指南：https://javaxiaobear.cn顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。
数据结构——线性表(选择题).docx
07-11
线性表是数据结构中的一种基础类型，它是由n（n>=0）个相同类型元素构成的有限序列。在这个序列中，每个元素都有一个直接前驱（除了第一个元素）和一个直接后继（除了最后一个元素），并且这个序列可以为空。线性表...
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
数据结构——哈夫曼编码
Benson的博客
02-02 8898
哈夫曼编码        在计算机世界中，任何事物都是二进制的，比如说数字、字符、颜色、声音等等，都是以二进制的形式存的，而在物理设备中用磁极或者电极来表示0或1，并通过电流的形式来传输，传输的过程中有数-模和模-数的转换。由于只有0和1两种数字，因而不同的数据就会用0和1不同的编排来表示，这种编排就叫作编码。编码是计算机中一个非常重要的概念，如果没有编码，就不会有计算机，因为只能处理0和1对于
数据结构——2-3树
Benson的博客
02-04 8410
2-3树 2-3树的概念        前面讲到了二叉搜索树(BST)和二叉平衡树(AVL)，二叉搜索树在最好的情况下搜索的时间复杂度为O(logn)，但如果插入节点时，插入元素序列本身就是有序的，那么BST树就退化成一个线性表了，搜索的时间复杂度为O(n)。之所以会变成O(n)，是因为树的高度变大了，BST的比较次数最大是等于树的高度的。因此，如果想要减少比较次数，就需要降低树的高度。在插入
Netty学习——用Netty实现一个简单的Http服务器
Benson的博客
01-26 5990
用Netty实现一个简单的Http服务器       Netty默认实现了Http的请求解析与响应封装，可以很方便地利用这些已经利用好的处理器来实现一个简单的Http服务器，或者自己实现更加复杂的Http服务器逻辑。下面是我用Netty实现的一个可以接收Http get或post请求的http服务器，并且可以解析出请求参数，然后生成一个页面，显示出请求参数。 package study.net
算法——个人对算法的一些理解
Benson的博客
02-05 5552
个人对算法的一些理解       在学校的同学们之间，算法总是被放在一个非常高的位置，有多高呢？嗯...就是非常非常高啦，高到有人只要能说出几个非常牛掰的和算法有关的名词，比如NP完全问题啦、模拟退火啦就觉得自己是大神了(其实有些人连快排都写不出来，或者写个快排还要先翻翻书)。其实我觉得算法跟数据结构、设计模式一样，都只是一种工具，用这样的工具能快速有效地解决一些实际问题，如果只知道算法，而不懂
Spring源码学习－spring data jpa源码分析
Benson的博客
09-07 3553
我先从spring project的git上下载了Spring的源码 Spring data jpa的源码在Spring project的spring-orm/src/main/java/org/springframework/orm/jpa里 这是jpa文件夹结构 最基础的一个接口是org.springframework.data.repository.Re
Java网络编程——网络通信安全与加密
Benson的博客
01-24 3109
网络通信安全与加密        在网络数据传输时，传输双方的数据可能会被第三方非法监听获取。因此，在真实网络环境中，通常会使用一些加密技术对网络数据进行保护。加密技术一般使用SSL加密和TLS加密。这两种加密是基于TCP/IP协议的，IP协议在网络层，TCP协议在传输层，SSL和TLS在安全套接字层，应用层是一些HTTP、Telnet、FTP之类的面向用户的协议。        SS
Spring Security学习——基于角色的权限验证
Benson的博客
01-29 3094
基于角色的权限验证        在现实世界中，不能的角色对应着不同的权限，比如说用户可以访问用户的模板，但不能访问到后台，管理员可以访问到后台的管理模板，而只有数据库管理员才能直接访问到数据底层管理，比如说一些登录日志和私密数据。Spring Security框架支持基于角色的权限验证，可以在系统中添加多种角色，用户权限验证登陆时，就可以根据输入的登陆信息，判断出输入的用户需要哪个角色，然后根
Netty学习——基于Netty的WebSocket协议开发
Benson的博客
01-27 2718
基于Netty的WebSocket协议开发 WebSocket简介         Java的Socket是Java网络编程的基础，Java的Socket是在应用层的，这和C/C++的Socket不同，C/C++的Socket是可以获取TCP头数据的。Socket是一种全双工的通信方式，也就是说通信双方可以同时互发消息，也叫CS模式，而HTTP协议是一种无状态协议，是基于BS模式的，服务器不能
今日头条内推一面
Benson的博客
04-05 2491
                                今日头条内推一面       大半夜的，清明节放假，一室友回家了，一室友在旁边吃鸡，还有一个在玩csgo，用putty连云服务器老是连接失败，很气，还是用virtualbox安装一个centos虚拟机算了，虽然内存有点不够烧，老是爆到70%，但只要不开flash其实也还好。安装期间刚好抽个空来写写头条内推面，也算是回报广大爱技术爱分享...
python基础学习-按值传递和按引用传递
Benson的博客
08-17 2291
按值传递和按引用传递在java和以c++中很常见，Java对待对象是按引用传递和，对待基本数据类型是按值传递的。 这里一定要注意java的String，因为java的String虽然是一个类，但是如果直接写成String str0="abc"的话，这里的str其实是指向常量池中的一个字符串，整个常量池只会有一个“abc”,如果再写一个str1="abc"的话，str0和str1其实是指向的同一个
哈夫曼树构建及数据结构基础——线性表、栈和队列
- **线性表**：线性表是数据结构中最基础的一种，它由若干个相同类型元素构成的有限序列。线性表可以采用顺序存储结构（如数组）或链接存储结构（如链表）。 - **栈**：栈是一种只能在一端进行插入和删除的线性表，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值