线性表顺序存储

  

#include<iostream>
using namespace std;
template<typename T>
class SqList
{
private:
  int count;//实际元素个数
  int Maxsize;//数组最大长度
  T *elem;
public:
  SqList(int size);//构造函数
  ~SqList();//析构函数

  int Length(){
    return count;
    };
   void Init(int size);//  初始化
   void Clear();
   void Travers();//遍历
   bool Full();
   bool Empty();
   bool GetElem(int position, T t);//获取指定位置元素
   bool SetElem(int position, T t);
   bool Insert(int position, const T &t);插入元素
   bool Delete(int position, T t);
   SqList(const SqList &copy);//拷贝构造函数

};
template<typename T>
SqList<T>::SqList(int size)
{
  Maxsize = size;
  elem = new T[Maxsize];
  count = 0;
}

template<typename T>
SqList<T>::SqList(const SqList &copy)
{
  count = copy.Length();
  if (elem != NULL) delete[]elem;
  Maxsize = copy.Maxsize;
  elem = new T[Maxsize];
  for (int i = 0; i < count; i++)
    elem[i] = copy.elem[i];
}

template<typename T>
SqList<T>::~SqList()
{
  delete[]elem;
}

template<typename T>
void SqList<T>::Init(int size)
{
  Maxsize = size;
  if (elem != NULL) delete[] elem;
    elem = new T [Maxsize];
  count= 0;
}

template<typename T>
void SqList<T>::Clear()
{
  count = 0;
}
template<typename T>
void SqList<T>::Travers()
{
  for (int i = 0; i < Length(); i++)
    cout << elem[i];
  cout << endl;
}

template<typename T>
bool SqList<T>::Full()
{
  return count == Maxsize;
}

template<typename T>
bool SqList<T>::Empty()
{
    return count == Maxsize;
}

template<typename T>
bool SqList<T>::GetElem(int position, T t)
{
    if (position<1 || position > Length())
      return false;
    else
    {
      t = elem[position - 1];
    return true;
    }
}

template<typename T>
bool SqList<T>::SetElem(int position, T t)
{
  if (position <1 || position > Maxsize)
    return false;
  else
  {
    elem[position - 1]=t;
    return true;
  }
}
template<typename T>
bool SqList<T>::Insert(int position,const T &t)
{
    if ( Full() || position <1 || position >Maxsize)
      return false;
    else
    {

    for (int i = Length() - 1; i >= position-1;i--)
      elem[i+1] =elem[i];
    elem[position - 1] = t;
    count++;
    return true;
  }
}

template<typename T>
bool SqList<T>::Delete(int position, T t)
{
  if (position <1 || position > Length())
    return false;
  else
  {
    t = elem[position - 1];
  for (int i = position- 1; i <= Length()- 1; i++)
    elem[i] = elem[i+1];
  count--;
  return true;
  }
}

#include"SqList.h"
using namespace std;
int main()
{
SqList<int> sq(5);

cout << sq.Length();
cout << sq.Empty();
cout << sq.Full();
sq.Insert(1, 1);
SqList<int> sqt = sq;
cout << sqt.Length();
sqt.Travers();
/*cout<<sq.Insert(1, 1);
cout<<sq.Insert(2, 1);
cout << sq.Insert(1, 1);
cout << sq.Insert(2, 1);
cout << sq.Insert(1, 1);
cout << sq.Insert(2, 1);
cout << sq.Insert(2, 1);
cout << sq.Insert(1, 1);
cout << sq.Insert(2, 1);*/
//sq.Travers();
cout << sq.Length();
cin.get();
return 0;
}

时间: 2024-11-25 19:50:50

线性表顺序存储的相关文章

数据结构——线性表顺序存储结构

 关于线性表 线性表是零个或者多个数据元素的集合.它主要有以下三个特征: 1:线性表的数据元素之间是有顺序的. 2:线性表中数据元素个数是有限的. 3:线性表中数据元素数据类型是相同的. 关于线性表的操作,主要有 创建线性表.销毁线性表.清空线性表.将元素插入线性表.将元素从线性表中删除.获取线性表中某个位置的元素.获取线性表的长度. 线性表主要有两种存储结构: 1:线性表的顺序存储结构,c语言中的数组及采用这种方式. 2:线性表的链式存储结构. 关于顺序存储结构 定义: 是指用一段地址连续的内

数据结构与算法-线性表顺序存储结构删除操作的实现

这一章节我们来看一下线性表顺序存储结构删除操作的简单实现 package com.ray.testobject; public class Test { private Object[] list; public Object[] getList() { return list; } /** * 初始化list * * @param num * 元素个数 */ private void iniList(int num) { list = new Object[num]; for (int i =

数据结构与算法-总结线性表顺序存储结构的优缺点

这一章节主要总结线性表顺序存储结构的优缺点. 在总结之前,我们来讨论一下线性表顺序存储结构的执行方法的时间复杂度: 存储.读取:O(1) 插入.删除:O(n) 优点: 1.无需为表中的逻辑关系增加额外的存储空间 2.可以快速存取表中对象 缺点: 1.插入和删除需要移动大量的对象 2.存储设备的碎片化 3.当线性表过大的时候,很难确定长度 版权声明:本文为博主原创文章,未经博主允许不得转载.

数据结构例程——线性表顺序存储的应用

本文是数据结构基础系列网络课程(2):线性表中第6课时线性表顺序存储的应用中所讲的例程. 例:删除元素 问题:已知长度为n的线性表A采用顺序存储结构,设计算法,删除线性表中所有值为x的数据元素. 要求:时间复杂度为O(n).空间复杂度为O(1)的算法 解法0:用基本运算实现,不满足复杂度要求 (注:本文中所需要的list.h和list.cpp见点击参照-) #include "list.h" #include <stdio.h> void delnode1(SqList *

数据结构之线性表-顺序存储

本人文笔较差,语文从来不及格,基础不好,写此类文章仅供自己学习,理解队列及其他知识,高手大神请略过.参考书籍 <数据结构与算法分析-Java语言描述> 1.1 线性表简介 线性表是0个或多个元素的有限序列.即元素之间有顺序且有限.假设表中有元素A1,A2,A3,....,AN,若存在1<i<N,则 Ai 是 Ai-1的直接后继,Ai-1 是Ai的直接前驱.作为线性表,必须满足A1没有前驱,AN没有后继(有限性).N是线性表的长度.当N=0时,即表中没有任何元素也即空表. 1.2 线

线性表顺序存储结构的c语言实现

线性表顺序存储结构用C实现的操作 <1>声明一个线性表的顺序存储结构 <2> 初始化顺序线性表 <3>判断是否为空 <4>清空列表 <5>返回当前长度(线性表内元素个数) <6>返回L中第i个数据元素的值,注意i是指位置,第1个位置的数组是从0开始 <7>返回L中第1个与e满足关系的数据元素的位序.若这样的数据元素不存在,则返回值为0 <8>在L中第i个位置之前插入新的数据元素e,L的长度加1 <9>

线性表—顺序存储结构

线性表——顺序存储结构 我理解的顺序存储就是 存储的一组元素在内存中呈线性排列,地址相邻,就像火车一样,每个车厢都可以看做是一个元素,元素门内首尾相连且地址相邻,书看的是高一凡老师的书,学完后自己写一下总结和体会,一来加深印象,二来可以方便自己复习. 顺序存储结构似乎都是用数组来实现的,也就是以数组为核心,外面加了许多很方便的操作(函数)进行封装,然后就说这叫[顺序存储结构]——数组的深加工之后的产品 顺序存储结构的基本功能有以下几个: name:     sqlist private: T *

03.线性表顺序存储(动态数组)

以下是用动态数组实现的线性表顺序存储 #include <stdio.h> #include <stdlib.h> #define LIST_INIT_SIZE 5//符号常量,代表线性表存储空间初始分配量 #define LIST_INCREMENT 10//符号常量,代表线性表存储空间的分配增量 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType;//ElemType这

线性表 顺序存储 链式存储 ---java实现

首先抽象出一个线性表抽象类(包含基本的增删操作) public abstract class MyAbstractList<E> { public abstract void add(E t); public abstract void add(int index,E t); public abstract void remove(); public abstract void remove(int index); public abstract int getCount(); public

数据结构-线性表顺序存储(c++)

数据结构-线性表顺序存储(c++) 2018-09-06 List.h  //头文件 1 #define OK 1 2 #define ERRO0R 0 3 #define TRUE 1 4 #define FALSE 0 5 #define MAXSIZE 20 //存储空间初始分配量 6 7 typedef int Status; //Status 函数结果状态码 8 typedef int ElemType; //ElemType 据具体情况而定 9 10 class SqList 11