简单顺序表的实现

最新推荐文章于 2022-10-26 17:49:53 发布
最新推荐文章于 2022-10-26 17:49:53 发布
阅读量921 收藏 1
点赞数
分类专栏： 学习 文章标签： class iostream insert c++ delete 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lichengiggs/article/details/748752
版权
看了effective c++(第三版)的几个items,想试试.于是找回以前的数据结构课本,重新写了上课时候的第二个实验.居然花了两个小时......................惨了,速度已经降到这种地步了,需要不断strive阿.
代码如下(注释简单写了点,注释最多的地方是抄别人的........):
/*
* 程序命名规则参考林锐博士高质量c++/c编程指南
*
* -------------------------------------------
* 简单的Windows应用程序命名规则
* -------------------------------------------
*
* -------------------------------------------
* 1)类名和函数名用大写字母开头的单词组合而成。
*
* 例如：
*
* class Node;                 // 类名
*
* void Draw(void);           // 函数名
* -------------------------------------------
*
* -------------------------------------------
* 2)变量和参数用小写字母开头的单词组合而成。
*
* 例如：
*
* BOOL flag;
* int drawMode;
* -------------------------------------------
*
* -------------------------------------------
* 3)常量全用大写的字母，用下划线分割单词。
*
* 例如：
*
* const int MAX = 100;
* const int MAX_LENGTH = 100;
* -------------------------------------------
*
* -------------------------------------------
* 4)静态变量加前缀s_(表示static)
*
* 例如：
*
* static int s_initValue; // 静态变量
* -------------------------------------------
*
* -------------------------------------------
* 5)如果不得已需要全局变量，则使全局变量加前缀g_(表示global)
*
* 例如：
*
* int g_howManyPeople; // 全局变量
* -------------------------------------------
*
* -------------------------------------------
* 6)类的数据成员加前缀m_(表示member)
* 这样可以避免数据成员与成员函数的参数同名。
*
* 例如：
*
* void Object::SetValue(int width, int height)
* {
*            m_width = width;
*            m_height = height;
* }
* -------------------------------------------
*
* 更多命名规范参考:c++编码规范
*/
#include <assert.h>
#include <iostream>
using namespace std;
//顺序表默认大小
const int c_defaultSize = 128;
 
 
//简单的顺序表
template < class T >
class SeqList
{
       public:
              //使用explicit,避免隐私类型转换
              explicit SeqList(const int maxSize=c_defaultSize);     
              SeqList(const SeqList<T>& rhs);
              ~SeqList();
 
              SeqList<T>& operator=(const SeqList<T>& rhs);
              T& operator[](const int index);
 
 
              inline int Length(void) const;                      //计算表的长度    
 
              int           Find(const T& x) const;                            //查找x在表中的位置
              bool IsIn(const T& x) const;                      //判断x是否在表中
                                                                                           //成功返回true,失败返回false
              bool Insert(T x, const int index);          //插入x到第index个位置,从0开始
              bool Remove(const T& x);                                //删除x
                                                                                           //成功返回true,失败返回false
 
              int           Next(const T& x) const;                            //寻找x的后继
              int           Prior(const T& x) const;                    //寻找x的前驱
 
              bool IsEmpty(void) const;                          //判断表是否为空
              bool IsFull(void) const;                              //判断表是否满
                                                                                           //!!!可能用不到
 
              void print()
              {
                     for (int i=0; i<m_size; i++)
                            cout << m_data[i] <<"/t";
                     cout << endl;
              }
 
       private:
              T *m_data;            //存放数据的数组
 
              int m_maxSize;      //最大可容纳数,可自动增加
              int m_size;             //当前已经存放的数据个数
                                          //没有存放元素时为0
};
 
//构造函数
template< class T >
SeqList<T>::SeqList(const int maxSize=c_defaultSize)
: m_maxSize(maxSize), m_size(0)
{
       //检查参数合理性
       assert(m_maxSize>=0);
 
       m_data = new T[m_maxSize];
       //memcpy(m_data, T(), sizeof(T)*m_maxSize);
 
       assert(m_data);
}
 
//拷贝构造函数
template< class T >
SeqList<T>::SeqList(const SeqList<T>& rhs)
{
       this->m_maxSize = rhs.m_maxSize;
       this->m_size = rhs.m_size;
 
       m_data = new T[m_maxSize];
 
       //检查
       assert(m_data);
       assert(m_size>=0 && m_maxSize>=m_size);
 
 
       for (int i=0; i<m_size; i++)
       {
              m_data[i] = rhs.m_data[i];
       }
 
}
 
//析构函数
template< class T>
SeqList<T>::~SeqList()
{
       delete []m_data;
       m_data = NULL;
}
 
//等号赋值
template< class T >
SeqList<T>& SeqList<T>::operator =(const SeqList<T>& rhs)
{
       this->m_maxSize = rhs.m_maxSize;
       this->m_size = rhs.m_size;
 
       delete []m_data;
       m_data = new T[m_maxSize];
 
       //检查
       assert(m_data);
       assert(m_size>=0 && m_maxSize>=m_size);
 
 
       for (int i=0; i<m_size; i++)
       {
              m_data[i] = rhs.m_data[i];
       }
 
       return *this;
}
 
template< class T >
T& SeqList<T>::operator [](const int index)
{
       assert(index>=0 && index<m_size);
 
       return m_data[index];
}
//返回表的长度
template< class T >
inline int SeqList<T>::Length(void) const
{
       return m_size;
}
 
//查找x在表中的位置
//找到x返回所在位置的下标(范围是0到m_size-1)
//找不到返回-1
template< class T >
int SeqList<T>::Find(const T& x) const
{
       int i = 0;
       while(i<m_size && m_data[i]!= x)
       {
              i++;
       }
      
       if (i == m_size)
       {
              return -1;
       }
       else
       {
              return i;
       }
}
 
//判断x是否在表中
//成功返回true,失败返回false
template< class T >
bool SeqList<T>::IsIn(const T& x) const
{
       if (Find(x))
       {
              return true;
       }
       else
       {
              return false;
       }
}
 
//在index位置插入x,index从0开始
template< class T >
bool SeqList<T>::Insert(T x, const int index)
{
       if (index<0 && index>=m_maxSize)
       {
              return false;
       }
 
       if (m_size == 0)
       {
              m_data[m_size++] = x;
              return true;
       }
 
       for (int i=m_size; i>index; i--)
       {
              m_data[i] = m_data[i-1];
       }
       m_data[index] = x;
       m_size++;
 
       return true;
}
 
template< class T >
bool SeqList<T>::Remove(const T& x)
{
       int index = Find(x);
 
       if (index == -1)
       {
              return false;
       }
 
       else
       {
              for (int i=index; i<m_size; i++)
              {
                     m_data[i] = m_data[i+1];
              }
              m_size--;
              return true;
       }
}
 
template< class T >
int SeqList<T>::Next(const T& x) const
{
       int index = Find(x);
 
       if (index>=0 && index<m_size-1)
       {
              return index+1;
       }
       else
       {
              return -1;
       }
}
 
template< class T >
int SeqList<T>::Prior(const T& x) const
{
       int index = Find(x);
 
       if (index>0 && index<m_size)
       {
              return index-1;
       }
       else
       {
              return -1;
       }
}
 
int main()
{
      
       SeqList< int > temp(10);
       SeqList< int > obj(temp);
 
       for (int i=0; i<10; i++)
       {
              temp.Insert(i, 0);
       }
       temp.print();
 
       temp.Remove(2);
       temp.print();
       temp.Remove(10);
      
 
       obj = temp;
       obj.print();
       obj.~SeqList();
       cout <<temp[ temp.Next(1) ] << endl << temp[ temp.Prior(1) ] << endl;
 
       return 0;
}
 
lichengiggs
关注
专栏目录
使用顺序表实现奇偶排序
09-25
【顺序表实现奇偶排序】 在给定的问题中，我们需要对一个整数顺序表进行特殊排序，即把所有的奇数移到偶数的前面。这里我们使用C++编程语言来实现这个算法。首先，顺序表是一种数据结构，它将元素存储在连续的内存...
数据结构实验报告1-顺序表实现简易的学生信息管理系统(C语言)
04-07
本实验报告主要探讨了如何使用C语言中的顺序表来实现一个简易的学生信息管理系统。该系统能够对学生的学号、姓名和成绩等信息进行管理，具体实现了以下功能： 1. **根据指定的学生个数逐个输入学生信息；** 2. **...
顺序表（实现）
weixin_40805072的博客
06-23 348
一、顺序表 因为系统没直接给提供数据结构，所以需要先定义对应数据结构的结构体 有了结构体，需要初始化该数据结构 初始化完毕，然后可以定义自己需要的操作 二、代码解释 1.初始化 void list_init(List *L) //初始化 { L->elem=(Elemtype *)malloc(MAXSIZE*sizeof(Elemtype));//开辟空间 ...
顺序表的实现
weixin_72068014的博客
07-28 267
实现顺序表
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
在本文中，我们将深入探讨如何使用C语言实现一个顺序表来统计单词的出现频率。顺序表是一种基础的数据结构，它将元素存储在一个连续的内存区域中，通过索引来访问元素，具有简单直观的操作方式。 首先，我们需要...
学生信息管理系统的顺序表实现
10-29
### 学生信息管理系统的顺序表实现 #### 案例背景与目标 在教育领域，班级不仅是学生学习和生活的基础单位，也是管理和组织教学活动的重要载体。因此，设计一个有效的班级管理系统对于提升学校的管理水平至关重要...
顺序表实现
11-05
在Java中，数组是最直接的顺序表实现方式，数组的索引范围通常是0到数组长度减1。 实现Java顺序表时，我们通常创建一个泛型类，允许存储任何类型的数据。例如： ```java public class SeqList<T> { private T[] ...
【数据结构】实现顺序表
gwPersevere的博客
04-23 342
目录 一、 顺序表的概念及结构 二、实现顺序表 1.初始化 2.打印 3.扩容 4.尾插 5.头插 6.头插 7.尾删 8.头删 9.删除在pos位置的数 9.1改进后的头删 9.2改进后的尾删 10.在pos处插入一个数 10.1改进后的头插 10.2 改进后的尾插 11.修改数据 12.查找数据 13销毁数组 一、 顺序表的概念及结构 顺序表示用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般采用数组储存，在数组上增删查改。 ......
【数据结构】顺序表的实现
最新发布
m0_59292239的博客
10-26 2969
【数据结构】顺序表的实现
顺序表（C语言实现）
trqii_的博客
04-26 5596
顺序表 文章目录顺序表一、**顺序表的基本概念**二、动态顺序表的具体实现1. 顺序表初始化2. 顺序表尾插3. 顺序表头插4. 顺序表尾删5. 顺序表头删6. 顺序表任意位置插入7. 顺序表任意位置删除8. 顺序表查找9. 顺序表修改10. 顺序表打印11. 顺序表销毁三、完整代码 一、顺序表的基本概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表分为以下二类： 1.静态顺序表：使用定长数组存储元素。 #define N
数据结构之用顺序表实现线性表
m0_58356862的博客
11-19 978
1、首先创建一个接口 public interface ILinarList<E> { boolean add(E item); boolean add(int i,E item); E remove(int i); int indexOf(E item); E get(int i); int size(); void clear(); boolean isEmpty(); } 2、实现线性表 import java..
c语言实现顺序表
Never_Dawn的博客
10-18 416
c语言实现顺序表 数据结构实验 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #define maxsize 10 typedef struct { char no[20]; char name[20]; int price; }Student; t...
数据结构之【顺序表的实现（详解）】
cls的博客
10-06 4863
线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在**逻辑上是线性结构，也就说是连续的一条直线。**但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 本质就是一个数组，但它是动态增长的，并且要求里面存储的数据必须是从左往右连续的。 顺序表的物理结构和逻辑结构是一致的都是连续的。 顺序表存在着一定的缺陷： 1.0 动态增容存在性能消
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值