数据结构系列之线性表（公式化描述）

最新推荐文章于 2025-08-06 19:21:58 发布
原创 最新推荐文章于 2025-08-06 19:21:58 发布 · 645 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #function #class #delete #insert #merge

本文介绍了一个基于C++实现的线性表类模板，包括构造、查找、删除、插入等基本操作，以及反序、减半、有序合并等高级功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最近在学习数据结构算法与应用-C++语言描述这本书，看着书写了一些代码。

 

LinearList.h：

 

#ifndef LINEARLIST_H_
#define LINEARLIST_H_

#include <iostream>
using namespace std;

template <class T>
class LinearList
{
public:
 LinearList();//构造函数，无参数
 LinearList(int nMaxListSize);//构造函数 
 LinearList(const LinearList<T>& llValue);//复制构造函数
 ~LinearList(){delete [] m_element;};//析构函数
 bool IsEmpty() const {return m_nLength == 0;};//是否为空
 int Length() const {return m_nLength;};//返回长度
 bool Find(int nIndex, T& nValue) const;//查找第nIndex个元素，放到nValue中
 int Search(T& nValue) const;//查找元素nValue，并返回其位置
 LinearList<T>& Delete(int nIndex,T& nValue);//删除第nIndex元素，并将其值放入nvalue中
 LinearList<T>& Insert(int nIndex,const T& nValue);//在nIndex后插入nValue
 void OutPut(ostream& out) const;//输出
 LinearList<T>& Reverse();//反序操作
 LinearList<T>& Half();//减半操作
 void Reset() { m_nCurrent = 1;};//重置当前位置为1
 int Current() const { return m_nCurrent;};//返回当前位置
 bool End() const;//当且仅当当前元素为表的最后一个元素时，返回true
 bool Front() const;//当且仅当当前元素为表的第一个元素时，返回true
 void Next();//移动current至表中的下一个元素，如果操作失败则引发一个异常
 void PreVious();//移动current至表中的前一个元素，如果操作失败则引发一个异常
 LinearList<T>& Alternate(const LinearList<T>& llValueA,const LinearList<T>& llValueB);//轮流合并
 LinearList<T>& Merge(const LinearList<T>& llValueA,const LinearList<T>& llValueB);//有序合并
 void Split(LinearList<T>& llValueA,LinearList<T>& llValueB);
 void InsertSort();

protected:
private:
 int m_nLength;//实际长度
 int m_nMaxSize;//最大可允许长度
 int m_nCurrent;//当前位置
 T* m_element;//一维动态数组
};
#endif

 

LinearList.cpp：

 

#include "LinearList.h"
#include "xcept.h"

/************************************************************************
Function:构造函数，建造一个确定初始大小的线性表
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>::LinearList(int nMaxListSize /* = 10 */)
{
 m_nMaxSize = nMaxListSize;
 m_element = new T[m_nMaxSize];
 m_nLength = 0;
 m_nCurrent = 1;
}
/************************************************************************
Function:
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>::LinearList()
{
 m_nMaxSize = 1;
 m_element = new T[m_nMaxSize];
 m_nLength = 0;
 m_nCurrent = 1;
}
/************************************************************************
Function:复制构造函数
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>::LinearList(const LinearList<T>& llValue)
{
 int nIndex;
 m_nLength = llValue.m_nLength;
 m_nMaxSize = llValue.m_nMaxSize;
 m_element = new T[m_nMaxSize];
 for (nIndex = 0;nIndex < m_nLength; nIndex++) {
  llValue.Find(nIndex+1,m_element[nIndex]);
 }
 m_nCurrent = 1;
}
/************************************************************************
Function:查找第nIndex个元素，放到nValue中
Parameter:
Return:
************************************************************************/
template <class T>
bool LinearList<T>::Find(int nIndex, T& nValue) const
{
 if (nIndex<1||nIndex>m_nLength) {
  return false;//不存在
 }
 nValue = m_element[nIndex-1];
 return true;
}
/************************************************************************
Function:查找元素nValue，并返回其位置
Parameter:
Return:
************************************************************************/
template <class T>
int LinearList<T>::Search(T& nValue) const
{
 int nIndex;
 for (nIndex = 0;nIndex < m_nLength; nIndex++) {
  if (m_element[nIndex]==nValue) {
   return ++nIndex;
  }
 }
 return 0;
}
/************************************************************************
Function:删除第nIndex元素，并将其值放入nvalue中
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>& LinearList<T>::Delete(int nIndex,T& nValue)
{
 int i;
 if (Find(nIndex,nValue)) {
  for (i = nIndex;i < m_nLength; i++) {
   m_element[i-1] = m_element[i];
  }
  m_nLength--;
  if (m_nLength<m_nMaxSize/4) {//动态减小数组大小
   T* element;
   m_nMaxSize /=2;
   element = new T[m_nMaxSize];
   for (i = 0;i < m_nLength; i++) {
   element[i] = m_element[i];
  }
  delete m_element;
  m_element = element;
  }
  return *this;
 }else{
  throw OutOfBounds();
 }
}
/************************************************************************
Function:在nIndex后插入nValue
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>& LinearList<T>::Insert(int nIndex,const T& nValue)
{
 int i;
 T* element;
 if (nIndex < 0||m_nLength < nIndex) {
  throw OutOfBounds();
 }
 if (m_nLength == m_nMaxSize) {//动态增加数组大小
  m_nMaxSize *=2;
  element = new T[m_nMaxSize];
  for (i = 0;i < m_nLength; i++) {
   element[i] = m_element[i];
  }
  delete m_element;
  m_element = element;
 }
 for (i = m_nLength-1; i >= nIndex; i--) {
  m_element[i+1]  = m_element[i];
 }
 m_element[nIndex] = nValue;
 m_nLength++;
 return *this;
}
/************************************************************************
Function:输出
Parameter:
Return:
************************************************************************/
template <class T>
void LinearList<T>::OutPut(ostream& out) const
{
 int nIndex;
 for (nIndex = 0;nIndex < m_nLength;nIndex++) {
  out << m_element[nIndex] << " ";
 }
}
/************************************************************************
Function:反序操作
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>& LinearList<T>::Reverse()
{
 int nIndex;
 T temp;
 for (nIndex = 0;nIndex < m_nLength/2; nIndex++) {
  temp = m_element[nIndex];
  m_element[nIndex] = m_element[m_nLength-1-nIndex];
  m_element[m_nLength-1-nIndex] = temp;
 }
 return *this;
}
/************************************************************************
Function:减半操作
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>& LinearList<T>::Half()
{
 int nIndex,nLength;
 if (m_nLength==0) {//空表
  return *this;
 }
 if (m_nLength%2==0) {
  nLength = m_nLength/2;
 }else{
  nLength = m_nLength/2+1;
 } 
 for (nIndex = 0;nIndex < nLength;nIndex++) {
  m_element[nIndex] = m_element[2*nIndex];
 }
 m_nLength = nLength;
 return *this;
}
/************************************************************************
Function:是否结尾
Parameter:
Return:
************************************************************************/
template <class T>
bool LinearList<T>::End() const
{
 if (m_nCurrent == m_nLength) {
  return true;
 }else{
  return false;
 }
}
/************************************************************************
Function:是否表头
Parameter:
Return:
************************************************************************/
template <class T>
bool LinearList<T>::Front() const
{
 if (m_nCurrent == 1) {
  return true;
 }else{
  return false;
 }
}
/************************************************************************
Function:当前位置后移
Parameter:
Return:
************************************************************************/
template <class T>
void LinearList<T>::Next()
{
 if (m_nCurrent == m_nLength) {
  throw OutOfBounds();
 }else{
  m_nCurrent++;
 }
}
/************************************************************************
Function:当前位置前移
Parameter:
Return:
************************************************************************/
template <class T>
void LinearList<T>::PreVious()
{
 if (m_nCurrent == 1) {
  throw OutOfBounds();
 }else{
  m_nCurrent--;
 }
}
/************************************************************************
Function:轮流合并
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>& LinearList<T>::Alternate(const LinearList<T>& llValueA,const LinearList<T>& llValueB)
{
 int nIndex;
 m_nLength = llValueA.Length()+llValueB.Length();
 int nMin = min(llValueA.Length(),llValueB.Length());
 m_nMaxSize = m_nLength;
 delete m_element;
 m_element = 0;
 m_element = new T[m_nMaxSize];
 for (nIndex = 0;nIndex < nMin;nIndex++) {
  llValueA.Find(nIndex+1,m_element[2*nIndex]);
  llValueB.Find(nIndex+1,m_element[2*nIndex+1]);
 }
 if (llValueA.Length() < llValueB.Length()) {
  for (nIndex = nMin; nIndex < llValueB.Length();nIndex++) {
   llValueB.Find(nIndex+1,m_element[nIndex+nMin]);
  }
 }else{
  for (nIndex = nMin; nIndex < llValueA.Length();nIndex++) {
   llValueA.Find(nIndex+1,m_element[nIndex+nMin]);
  }
 }
 return *this;
}
/************************************************************************
Function:有序合并
Parameter:
Return:
************************************************************************/
template <class T>
LinearList<T>& LinearList<T>::Merge(const LinearList<T>& llValueA,const LinearList<T>& llValueB)
{
 int nIndex;
 int nIndexA = 0;
 int nIndexB = 0;
 T tempA,tempB;
 m_nLength = llValueA.Length()+llValueB.Length();
 m_nMaxSize = m_nLength;
 delete m_element;
 m_element =0;
 m_element = new T[m_nMaxSize];
 llValueA.Find(nIndexA+1,tempA);
 llValueB.Find(nIndexB+1,tempB);
 for (nIndex = 0;nIndex < m_nLength;nIndex++) {
  if (tempA < tempB) {
   m_element[nIndex] = tempA;
   nIndexA++;
   if (nIndexA < llValueA.Length()) {
    llValueA.Find(nIndexA+1,tempA);
   }else{
    llValueB.Find(llValueB.Length(),tempA);
   }
   
  }else{
   m_element[nIndex] = tempB;
   nIndexB++;
   if (nIndexB < llValueB.Length()) {
    llValueB.Find(nIndexB+1,tempB);
   }else{
    llValueA.Find(llValueA.Length(),tempB);
   }
  }
 }
 return *this;
}
/************************************************************************
Function:
Parameter:
Return:
************************************************************************/
template <class T>
void LinearList<T>::Split(LinearList<T>& llValueA,LinearList<T>& llValueB)
{
 int nIndex;
 for (nIndex = 0;nIndex < m_nLength;nIndex++) {
  if (nIndex%2==0) {
   llValueA.Insert(0,m_element[nIndex]);
  }else{
   llValueB.Insert(0,m_element[nIndex]);
  }
 }
}
/************************************************************************
Function:插入排序
Parameter:
Return:
************************************************************************/
template <class T>
void LinearList<T>::InsertSort()
{
 if (m_nLength<=1) {
  return;
 }
 int i,j;
 T temp;
 for (i = 1;i < m_nLength; i++) {
  temp = m_element[i];
  for (j = i-1; j>=0&&m_element[j]>temp;j--) {
   m_element[j+1] = m_element[j];
  }
  m_element[j+1] = temp;
 }
}
/************************************************************************
Function:重载操作符<<
Parameter:
Return:
************************************************************************/
template <class T>
ostream& operator<<(ostream& out,const LinearList<T>& llValue)
{
 llValue.OutPut(out);
 return out;
}

riyueming184
关注
公式化描述的线性表
greenland1020的专栏
09-10 759
//****************************************************************************************/ // 抽象数据类型LinearList { // 实例 // 0或多个元素的有序集合 // 操作 // Create (): 创建一个空线性表 // Destroy (): 删除表 // IsEmpty(): 如果表
[C++]数据结构：线性表的公式化描述和链式描述的结构特点与基本操作
汪海的实验室
01-05 3872
线性表的公式化描述的基本特点： 关于线性表的概念，可以简单的理解成按照一定顺序排列的列表。但是这里的顺序并不是指元素内容的有序，而是指元素的位置的有序。就好像是有一个队伍，不一定按照高矮胖瘦进行排列，但是在队伍中每个人按照前后站着谁，都有自己相对固定的位置。 再介绍一下公式化描述的概念。公式化描述是采用数组来表示一个对象的实例，数组中的每个位置为单元或者节点，每个数组单元需要足够大以便能容纳数
公式化描述线性表
09-10
线性表的公式化描述实现,只上传无错误无BUG的代码，编译环境vs2012,因版本系统引起的问题需要自行解决
线性表 - 公式化描述实现线性表
weixin_30564785的博客
09-12 188
List.h /******************************************************************** purpose: 公式化描述实现线性表 author: xianyun1230 QQ: 836663997 e-mail: xianyun1230@163.com created: 2014/02/16 *******...
线性表的公式化描述
bob_hu924的专栏
04-17 811
//基于公式的类LinearList template class LinearList{ public: LinearList(int MaxListSize = 10);//构造函数 ~LinearList() {delete [] element;}//析构函数 bool IsEmpty() const { return length ==
数据结构（四）——线性表的公式化描述小结
夜的第七章
06-11 917
本文为公式化描述的抽象小记，不涉及基础知识。 公式化线性表的核心操作：插入、删除、合并和搜索 解题时可能用到的技巧：元素逆置、二分搜索、int类型模拟指针 时间空间复杂度要求：时间复杂度O(n),空间复杂度大部分为O(1），最差为O(n)。时间复杂度为logn的题目较少，且最优解需要耗费时间。 练习（仅供参考，部分题目非最优解） //从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值，空出的位置 //由最后一个元素填补，若顺序表为空则显示出错信息并退出运行 ElemType delete
线性表的公式化描述与链表描述
weixin_42601547的博客
02-12 192
线性表的公式化描述： 线性表是有限个数据元素的有顺序的集合，其元素具有相同类型，并可通过一个唯一标识符索引。 链表的描述： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接构成的。每个数据元素(结点)存储数据本身以及指向下一个数据元素的指针，最后一个数据元素的指针为NULL，表示链表的结束。 ...
数据结构线性表解析：公式化、链接、间接寻址与模拟指针
"C++数据结构线性表003" 在C++中，数据结构是编程中的一个重要概念，它涉及到如何有效地组织和管理数据。线性表是数据结构中最基础且常用的一种，本章主要探讨了四种描述线性表的方法，以及它们在实现常见操作（如...
数据结构与算法：C++描述之线性表解析
"数据结构与算法C++语言描述的第三章，主要讲解数据描述，特别是线性表的四种描述形式：公式化描述、链接描述、间接寻址和模拟指针。这一章还涵盖了抽象数据类型、单向链表、循环链表和双向链表，并通过链表的应用来...
探索数据结构：线性表的四种描述与应用
首先，数据描述方法是理解数据结构的关键，包括公式化描述、链接描述、间接寻址和模拟指针。公式化描述通过数学公式精确指定每个元素在存储空间中的位置，比如连续线性表中元素连续存储。链接描述则是每个元素包含一...
公式化描述
char_c的博客
07-03 939
公式化描述采用数组来表示一个对象的实例，数组中的每个位置被称之为单元或节点。可用一个数学公式来确定每个元素在数组中的位置。实现一个线性表类#pragma once #include <iostream> using namespace std; template<class T> class LinearList { public: LinearList(int MaxListSize =
[C++]数据结构：公式化描述的线性表LinearList的创建与使用
汪海的实验室
11-21 2882
//基于公式的类LinearList #include #include #include using namespace std; template class LinearList{ public: LinearList(int MaxListSize=10); //构造函数，默认最大值为10 ~LinearList(){delete []element;}
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 649
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
LI1109hd的博客
08-05 273
/队列: 先进先出。
数据结构——图及其C++实现 多源最短路径 FloydWarshall算法
学习日记
08-06 952
前两篇学习的Dijkstra算法和Bellman-Ford算法都是用来求解图的单源最短路径，即从图中指定的一个源点出发到图中其他任意顶点的最短路径。Dijkstra算法不能求解带有负权重的图的最短路径，而Bellman-Ford算法弥补了这个缺点。本篇文章再来见识一下一个求解多源最短路径的算法——Floyd-Warshall算法。多源最短路径–Floyd-Warshall算法Floyd-Warshall算法是一种解决多源最短路径问题（任意两点间的最短路径）的算法。
嵌入式 - 数据结构：循环链表和内核链表
m0_74911141的博客
08-05 503
/ 数据域// 前驱指针// 后继指针} linknode;// 首尾自环Linux 内核中通过// 后继指针// 前驱指针初始化初始化头节点，使其首尾自环；插入（头插）、（尾插）；删除从链表中移除节点；遍历遍历数据元素，其中member为数据结构中成员的名称；数据定位通过节点指针ptr找到数据结构的首地址（核心宏，通过指针运算实现）。使用内核链表时，需在自定义数据结构中嵌入// 示例：定义一个包含内核链表节点的进程结构int pid;// 进程ID// 进程名。
C语言的数组与字符串练习题2
最新发布
HW-BASE的博客
08-06 957
数组与字符串
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值