第15课 - 线性表的顺序存储结构和抽象实现(SeqList)

版权声明:课程笔记内容整理于狄泰软件 https://blog.csdn.net/qq_39654127/article/details/79948787

1、顺序存储的定义 

线性表的顺序存储结构,指的是用—段地址连 

续的存储单元依次存储线性表中的数据元素。

  

                           这片空间可能是栈空间也可能是堆空间

 

2、设计思路 

可以用一维数组来实现顺序存储结构SeqList

SeqList设计要点 

       -抽象类模板,存储空间的位置和大小由子类完成 

template <typename T>
class SeqList : public List<T>
{
protected:
    T* m_array;     //存储空间的位置和大小由子类完成 
    int m_length;   
public:
    bool insert(const T& e)
    bool insert(int i,const T& e);
    bool remove(int i);
    bool set(int i,const T& e);
    bool get(int i,T& e) const;  //因为i可能不合法,所以用过引用返回值
    int find(const T& e) const
    int length() const;
    void clear();

    //顺序存储线性表的数组访问方式
    T& operator[] (int i);
    T operator[] (int i) const; //考虑只读对象

    //顺序存储空间的长度
    virtual int capacity() const = 0; 
};

 

3、编程实验 

顺序存储线性表     SeqList.h

#ifndef SEQLIST_H
#define SEQLIST_H

#include "List.h"
#include "Exception.h"

namespace DTLib
{

template <typename T>
class SeqList : public List<T>
{
protected:
    T* m_array; //存储空间的位置和大小由子类完成 
    int m_length;
public:
    bool insert(int i,const T& e) //顺序存储结构的元素插入操作 
    {
        bool ret = (0 <= i) && (i <= m_length);

        ret = ret && (m_length < capacity());

        if( ret )
        {
            for(int p=m_length-1; p>=i; p--)
            {
                m_array[p+1] = m_array[p];
            }

            m_array[i] = e;
            m_length++;
        }

        return ret;
    }
    bool insert(const T& e)
    {
        return insert(m_length,e);
    }

    bool remove(int i) //顺序存储结构的元素删除操作 
    {
        bool ret = (0 <= i) && (i < m_length);
        if(ret)
        {
            for(int p = i; p <= m_length; p++)
            {
                m_array[p] = m_array[p+1];
            }

            m_length--;
        }


        return ret;
    }

    bool set(int i,const T& e)
    {
        bool ret = (0 <= i) && (i < m_length);

        if( ret )
        {
            m_array[i] = e;
        }

        return ret;
    }

    bool get(int i,T& e) const //顺序存储结构的元素获取操作 
    {
        bool ret = (0 <= i) && (i < m_length);

        if( ret )
        {
            e = m_array[i];
        }

        return ret;
    }
    int find(const T& e) const
    {
        int ret = -1;

        for(int i=0; i<m_length; i++)
        {
            if(m_array[i] == e)
            {
                ret = i;
                break;
            }
        }

        return ret;
    }
    int length() const
    {
        return m_length;
    }
    void clear()
    {
        m_length = 0;
    }


    T& operator[] (int i)
    {
        if((0 <= i)&&(i < m_length))
        {
            return m_array[i];
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsExpception,"Parameter i is invalid...");
        }
    }

    T operator[] (int i) const
    {
        return (const_cast<SeqList<T>&>(*this))[i];       //代码复用
    }

    virtual int capacity() const = 0; //子类实现
};

}


#endif // SEQLIST_H

main.cpp

#include<iostream>  
#include"SeqList.h"  
  
using namespace std;  
using namespace DTLib;  
  
int main()  
{  
    SeqList<int>* l;  
  
    return 0;  
}  

 

4、顺序存储线性表的分析 

效率分析 

template <typename T>
class SeqList : public List<T>
{ 
public:
    bool insert(const T& e)
    bool insert(int i,const T& e); //O(n)
    bool remove(int i);            //O(n)
    bool set(int i,const T& e);    //O(1)
    bool get(int i,T& e) const;    //O(1)
    int find(const T& e) const     //O(n)
    int length() const;            //O(1)
    void clear();                  //O(1)
 
    
    T& operator[] (int i);         //O(1)
    T operator[] (int i) const;    //O(1)
 
    virtual int capacity() const = 0; 
};

 

                  顺序存储线性表的插入和删除操作存在重大效率隐患 

 

问题:

           长度相同的两个SeqList , 插入删除 

                             操作的平均耗时是否相同?

答:取决于线性表存储数据元素类型,如插入字符串和整形差距很大

 

5、下节课实现子类

 

 

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页