數據結構--線性表的順序存儲結構

一 線性表的本質和操作

線性表的表現形式主要有以下幾個方面
1 零個或多個數據元素組成的集合
2 數據元素在位置上是有序排列的
3 數據元素的個數是有限的
4 數據元素的類型必須相同
線性表的抽象定義是具有相同的n(n>=0)個數據元素的優先序列(a0,a1......an)

二 線性表的性質

a0為線性表的i的一個元素，只有一個后繼
an-1為線性表的最后一個元素，只有一個前驅
除去這兩個元素外的其他元素ai既有前前驅，又有后繼
直接支持逐項訪問和順序存取

三線性表的一些常用操作

1將元素插入線性表
2將元素從線性表中刪除
3獲取目標位置處元素的值
4設置目標位置處元素的值
5獲取線性表的長度
6清空線性表

template <typename T>
class List :public Object
{//Object為頂層父類
  protected:
     List(const List&);
     List& operator=(const List&);//避免賦值操作
    public:
        List(){};
        virtual bool insert(int i,const T&e)=0;//插入
        virtual bool remove(int i)=0;//刪除
        virtual bool set(int i,const T&e)=0//設置值;
        virtual bool get(int i,const T&e)=0;//獲取值
        virtual int length()const=0;//獲取長度
        virtual void clear()=0;//清空操作
}

四 線性表的順序存儲結構的實現
思路：可以用一維數組來實現順序存儲結構
存儲空間 *T array
當前的長度 int length**

a.順序存儲結構的元素插入操作
1.判斷目位置是否合法
2.將目標位置之后的所有元素后移一個位置
3.將新元素插入目標位置
4.線性表的長度+1
簡單的圖示

代碼的實現部分

inset (int i,const T&e)
{
    bool ret=((0<=i)&&(i<length));
    ret=ret&&((length+1)<=capacity());//對位置進行判斷是否合法

    if(ret)
    {
        for(int p=length-1;p>i;p--)
        {
            array[p+1]=arrray[p];//將目標位置后的元素后移一位
        }
        array[i]=e;//將元素插入
        length++;//線性表長度加1
    }
    return ret;
}

b.順序存儲結構的元素刪除操作
1.對位置進行判斷是否合法
2.將目標位置后的所有元素前移一個位置
3.線性表的長度減1
實現代碼如下
簡單的圖示

remove(int i,const T&e)
{
    bool ret=((o<=i)&&(i<=length));
    ret=ret&&((length+1)<=capacity());//對位置進行判斷是否合法

    if(ret)
    {
        for(int p=i;p<length-1;p++)//在刪除處進行遍歷
        {
            array[p]=array[p+1];//將元素前移一個位置
        }
        length--;//線性表的長度減1
    }
        return ret;
}

c.元素的設置以及獲取
1判斷目標位置是否合法
2.將目標位置作為數組下標對元素進行操作
實現代碼如下

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

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

get(int  i,T&e)const
{
    bool ret=((0<=i)&&(i<=length))

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

d.其他的操作(清除及獲取長度)
實現代碼如下

        int length()const
        {
            return length;
        }

        void clear()
        {
            length=0;
        }

完整的代碼如下

include "List"
include "Object"

namespace MyLib
{
    template<typename T>
    class SeqList :public List<T>
    {
        protected:
            T* array;
            int 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);
        }

        /*刪除操作
         1.判斷目標是否合法
         2.將目標位置后的所有元素前移一個位置
         3.線性表長度減1
        */
        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(indexOutOfBoundsException,"Parameter i is invaild...");//i不合法，越界操作異常
           }
        }

        T operator [](int i)const
        {
            //去除當前對象的const屬性
            return (const_cast<SeqList<T>&>(*this))[i];
        }

        virtual int capacity()const=0;//純虛h函數，由子類重寫
    };
}