精华内容
下载资源
问答
  • 线性表顺序存储,此程序主要实现线性表顺序存储,有C++语言实现,还是比较轻易看得懂的!
  • 顺序存储线性表实现

    千次阅读 多人点赞 2018-10-08 21:15:35
    计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表顺序存储结构。   顺序存储结构的主要优点是节省存储空间,因为分配给数据的存储单元全用存放结点的数据(不考虑c/c++语言数组需...

    在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构。

     

    顺序存储结构的主要优点是节省存储空间,因为分配给数据的存储单元全用存放结点的数据(不考虑c/c++语言中数组需指定大小的情况),结点之间的逻辑关系没有占用额外的存储空间。采用这种方法时,可实现对结点的随机存取,即每一个结点对应一个序号,由该序号可以直接计算出来结点的存储地址。但顺序存储方法的主要缺点是不便于修改,对结点的插入、删除运算时,可能要移动一系列的结点。

    优点:随机存取表中元素。缺点:插入和删除操作需要移动元素。

     

    线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意,这句话只适用大部分线性表,而不是全部。比如,循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储),但是把最后一个数据元素的尾指针指向了首位结点)。

    给出两种基本实现:

    /*
    静态顺序存储线性表的基本实现
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define LIST_INITSIZE 100
    #define ElemType int
    #define Status int
    #define OK     1
    #define ERROR  0
    
    typedef struct
    {
    	ElemType elem[LIST_INITSIZE];
    	int length;
    }SqList;
    
    //函数介绍
    Status InitList(SqList *L); //初始化
    Status ListInsert(SqList *L, int i,ElemType e);//插入
    Status ListDelete(SqList *L,int i,ElemType *e);//删除
    void ListPrint(SqList L);//输出打印
    void DisCreat(SqList A,SqList *B,SqList *C);//拆分(按正负),也可以根据需求改
    //虽然思想略简单,但是要写的没有错误,还是需要锻炼coding能力的
    
    Status InitList(SqList *L)
    {
        L->length = 0;//长度为0
        return OK;
    }
    
    Status ListInsert(SqList *L, int i,ElemType e)
    {
        int j;
        if(i<1 || i>L->length+1)
            return ERROR;//判断非法输入
        if(L->length == LIST_INITSIZE)//判满
        {
            printf("表已满");//提示
            return ERROR;//返回失败
        }
        for(j = L->length;j > i-1;j--)//从后往前覆盖,注意i是从1开始
            L->elem[j] = L->elem[j-1];
        L->elem[i-1] = e;//在留出的位置赋值
        (L->length)++;//表长加1
        return OK;//反回成功
    }
    
    Status ListDelete(SqList *L,int i,ElemType *e)
    {
        int j;
        if(i<1 || i>L->length)//非法输入/表空
            return ERROR;
        *e = L->elem[i-1];//为了返回值
        for(j = i-1;j <= L->length;j++)//从前往后覆盖
            L->elem[j] = L->elem[j+1];
        (L->length)--;//长度减1
        return OK;//返回删除值
    }
    
    void ListPrint(SqList L)
    {
        int i;
        for(i = 0;i < L.length;i++)
            printf("%d ",L.elem[i]);
        printf("\n");//为了美观
    }
    
    void DisCreat(SqList A,SqList *B,SqList *C)
    {
        int i;
        for(i = 0;i < A.length;i++)//依次遍历A中元素
        {
            if(A.elem[i]<0)//判断
                ListInsert(B,B->length+1,A.elem[i]);//直接调用插入函数实现尾插
            else
                ListInsert(C,C->length+1,A.elem[i]);
        }
    }
    
    int main(void)
    {
        //复制的
    	SqList L;
    	SqList B, C;
    	int i;
    	ElemType e;
    	ElemType data[9] = {11,-22,33,-3,-88,21,77,0,-9};
    	InitList(&L);
    	InitList(&B);
    	InitList(&C);
    	for (i = 1; i <= 9; i++)
    		ListInsert(&L,i,data[i-1]);
        printf("插入完成后L = : ");
    	ListPrint(L);
        ListDelete(&L,1,&e);
    	printf("删除第1个后L = : ");
    	ListPrint(L);
        DisCreat(L , &B, &C);
    	printf("拆分L后B = : ");
    	ListPrint(B);
    	printf("拆分L后C = : ");
    	ListPrint(C);
    	printf("拆分L后L = : ");
    	ListPrint(L);
    }

    静态:长度固定

    动态:不够存放可以加空间(搬家)

     

    /*
    子任务名任务:1_2 动态顺序存储线性表的基本实现
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define LIST_INIT_SIZE 100
    #define LISTINCREMENT 10
    #define Status int
    #define OVERFLOW -1
    #define OK 1
    #define ERROR 0
    #define ElemType int
    
    typedef struct
    {
    	ElemType * elem;
    	int length;
    	int listsize;
    }SqList;
    //函数介绍
    Status InitList(SqList *L); //初始化
    Status ListInsert(SqList *L, int i,ElemType e);//插入
    Status ListDelete(SqList *L,int i,ElemType *e);//删除
    void ListPrint(SqList L);//输出打印
    void DeleteMin(SqList *L);//删除最小
    
    Status InitList(SqList *L)
    {
        L->elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//申请100空间
    	if(!L->elem)//申请失败
    		return ERROR;
    	L->length = 0;//长度0
    	L->listsize = LIST_INIT_SIZE;//容量100
    	return OK;//申请成功
    }
    
    Status ListInsert(SqList *L,int i,ElemType e)
    {
        int j;
        ElemType *newbase;
        if(i<1 || i>L->length+1)
            return ERROR;//非法输入
            
        if(L->length >= L->listsize)//存满了,需要更大空间
        {
            newbase = (ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));//大10的空间
            if(!newbase)//申请失败
                return ERROR;
            L->elem = newbase;//调指针
            L->listsize+= LISTINCREMENT;//新容量
        }
        
        for(j=L->length;j>i-1;j--)//从后往前覆盖
            L->elem[j] = L->elem[j-1];
        L->elem[i-1] = e;//在留出的位置赋值
        L->length++;//长度+1
        return OK;
    }
    
    Status ListDelete(SqList *L,int i,ElemType *e)
    {
        int j;
        if(i<1 || i>L->length)//非法输入/表空
            return ERROR;
        *e = L->elem[i-1];//为了返回值
        for(j = i-1;j <= L->length;j++)//从前往后覆盖
            L->elem[j] = L->elem[j+1];
        (L->length)--;//长度减1
        return OK;//返回删除值
    }
    
    void ListPrint(SqList L)
    {
        int i;
        for(i=0;i<L.length;i++)
            printf("%d ",L.elem[i]);
        printf("\n");//为了美观
    }
    
    void DeleteMin(SqList *L)
    {
        //表空在Listdelete函数里判断
        int i;
        int j=0;//最小值下标
        ElemType *e;
        for(i=0;i<L->length;i++)//寻找最小
        {
            if(L->elem[i] < L->elem[j])
                j=i;
        }
        ListDelete(L,j+1,&e);//调用删除,注意j要+1
    }
    
    int main(void)
    {
    	SqList L;
    	int i;
    	ElemType e;
    	ElemType data[9] = {11,-22,-33,3,-88,21,77,0,-9};
    	InitList(&L);
    	for (i = 1; i <= 9; i++)
    	{
    		ListInsert(&L,i,data[i-1]);
    	}
    	printf("插入完成后 L = : ");
    	ListPrint(L);
        ListDelete(&L, 2, &e);
    	printf("删除第 2 个后L = : ");
    	ListPrint(L);
        DeleteMin(&L);
    	printf("删除L中最小值后L = : ");
    	ListPrint(L);
    	DeleteMin(&L);
    	printf("删除L中最小值后L = : ");
    	ListPrint(L);
    	DeleteMin(&L);
    	printf("删除L中最小值后L = : ");
    	ListPrint(L);
    }

     

    展开全文
  • 顺序存储线性表的分析 性能分析 和 功能分析 顺序存储线性表的插入和删除操作存在重大效率隐患 效率分析 下面的O(n)是最坏情况下的 问题 长度相同的两个SeqList,插入和删除操作的平均耗时是否相同? 顺序存储...

    顺序存储线性表的分析

    • 性能分析 和 功能分析

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

    效率分析

    下面的O(n)是最坏情况下的
    image-20201119163738450

    问题 长度相同的两个SeqList,插入和删除操作的平均耗时是否相同?

    顺序存储结构的线性表里面存储的类型要是很大,这个时候插入操作非常耗时,要复制拷贝

    线性表作为容器类,应该避免拷贝构造和拷贝赋值

    练习1

    下面的代码正确吗?为什么?

    image-20201119163944214

    赋值操作使得s2和s1里面的元素指向同一堆空间

    同一个堆空间释放两次,行为未定义的,bug什么时候表现出来,我们是未知的。

    练习2

    下面的代码正确吗?为什么?

    image-20201119164352777

    插入时,d2的插入会影响d1的插入,把值覆盖了,调用结束后d1和d2都会被析构,堆空间又被释放两次

    问题解决:

    image-20201119164607700

    容器类型的类可以考虑禁止禁止拷贝和赋值构造

    template < typename T >
    class List : public Object
    {
    protected:
        List(const List&); //需要手工添加一个public的
        List& operator=(const L);
    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, T& e) const = 0;
        virtual int length() const = 0;
        virtual void clear() = 0;
    
    };
    

    改进insert在末尾插

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

    顺序存现线性表可能被当成数组误用

    练习3

    image-20201119165021164
    list[i]首先会检查i这个位置存不存在,不存在就越界了

    问题分析

    顺序存储结构线性表提供了数组操作符重载,通过重载能够快捷方便的获取目标位置处的数据元素,在具体的使用形式上类似数组,但是由于本质不同,不能替代数组使用。

    小结

    • 顺序存储线性表的插入和删除操作存在重大效率隐患
    • 线性表作为容器类,应该避免拷贝构造和拷贝赋值
    • 顺序存现线性表可能被当成数组误用
    • 工程开发中可以考虑使用数组类代替原生数组使用
    展开全文
  • 数据结构实战开发中类继承关系图中总体概括了数据结构实战开发中所有类的继承关系,本文分析线性表中顺序表的实现,下一篇实现包括静态顺序表StaticList和动态顺序表DynamicList。 线性表的顺序存储结构 ...

    数据结构实战开发中类继承关系图中总体概括了数据结构实战开发中所有类的继承关系,本文分析线性表中顺序表的实现,下一篇实现包括静态顺序表StaticList和动态顺序表DynamicList。
    这里写图片描述

    线性表的顺序存储结构

    顺序存储的定义:线性表的顺序存储结构,指的是用一段地址连续的存储单元依次存储线性表中的数据元素。
    这里写图片描述

    List实现

    既然是线性表,那么首先需要线性表抽象类List,主要是一些对线性表的操作:

    #ifndef _LIST_H_
    #define _LIST_H_
    
    #include "Object.h"
    
    namespace DTLib
    {
        // 对于容器类型的类,可以考虑禁用拷贝构造和赋值操作
        template <typename T>
        class List : public Object
        {
        private:
            List(const List&);
            List& operator= (const List&);
        public:
            List() {} // 已经添加了拷贝构造函数,编译器就不会提供默认的构造函数,需要自己手工添加默认构造函数
            virtual bool insert(const T& e) = 0; // 从尾部插入
            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, T& e) const = 0;
            virtual int find(const T& e) const = 0;
            virtual int length() const = 0;
            virtual void clear() = 0;
        };
    
    } 
    
    #endif
    

    SeqList实现

    其次要实现SeqList,实现要点:
    (1)抽象类模板 , 存储空间的位置和大小由子类完成;
    (2)实现顺序存储结构线性表的关键操作(增、删、改、查等);
    (3)提供数组操作符,方便快速获取元素。

    #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:
            // 重写父类List的成员函数
            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 - 1; 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 invalid...");
                }
            }
    
    
            T operator[] (int i) const
            {
                return (const_cast<SeqList<T>&>(*this))[i];
            }
    
            // 顺序存储空间的容量
            virtual int capacity() const = 0;
        };
    }
    #endif
    展开全文
  • 数据结构——浅谈顺序存储线性表 一、线性表 线性表可以说是最常用最简单的一种数据结构,自然掌握线性表是数据结构最重要的一环了。 线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素...

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


    一、线性表

    线性表可以说是最常用最简单的一种数据结构,自然掌握线性表是数据结构最重要的一环了。

    线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意,这句话只适用大部分线性表,而不是全部。比如,循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储),但是把最后一个数据元素的尾指针指向了首位结点)。

    我们说"线性"和"非线性",只在逻辑层次上讨论,而不考虑存储层次,所以双向链表和循环链表依旧是线性表。

    二、从顺序存储谈起

    顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素,称为线性表的顺序存储结构。它以"物理位置相邻"来表示线性表中数据元素间的逻辑关系,可随机存取表中任一元素。

    			存储位置                    内存状态            数据元素在线性表中的位序
    

    线性表顺序存储结构示意图

    三、代码实现

    对于顺序表示线性表,定义表结构时首先应该明白,需要找到表的位置那么在定义时就要有表的地址,所以在申请存储空间时就应该将存储空间基址赋予,而且还需要考虑到如果在插入时空间是否还足够,所以需要将当前表分配的存储容量表示,当然对于当前表的长度也是可以定义在其中的

    //静态定义
    #define maxsize 线性表可能达到的最大长度
    typedef  struct
    {
     ElemType  elem[maxsize];
     // 在这里采用记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1
     int  last;//表的最后一位元素位置,也相当于表长
    }SeqList; /*对于顺序表示线性表,我这样进行定义的话自然就直接可以略去创建一个空链表函数的操作了
    但是自然也有弊端,这样是一个静态的,适合事先知道线性表的最大值时,由于使用频率还是统一以动态的进行分析*/
    
    //动态定义
    #define maxsize 线性表可能达到的最大长度
    #define addsize 空间不足时需要增加的量
    typedef  struct
    {
       ElemType  *elem;//存储空间基址
       int  length;//当前表长
       int  listsize;//当前分配的存储容量
    }SeqList; //如果这样进行结构体的定义那么在进行操作前建立一个空的线性表
    //建立空表
    status InitList_Sq(SqList &L)
    {
       L.elem=(ElemType*)malloc(addsize*sizeof(ElemType));/*申请将addsize个ElemType数据需要的大小
       并返回一个ElemType类型的指针,指向一段可用内存的起始地址赋给L.elem*/
       if(!L.elem) 
       {
          printf("空间分配失败");
          return -1;
       } 
       L.length=0;
       L.listsize=maxsize;
       return 0;
    }
    

    对于线性表需要达到的最基本操作大致有

    • 查找操作
    • 插入操作
    • 删除操作
    • 顺序表合并算法

    查找操作 :

    对于顺序表示线性表的查找分为两种

    • 按序号查找
    • 按内容查找

    顺序表示线性表按序号查找是很好理解的
    要求查找线性表L中第i个数据元素,其结果是L.elem[i-1]或L->elem[i-1]
    当然也可以麻烦点写成函数:

    status GetData(SeqList L,int i)
    {
        printf("%d位置上的数是%d",i, L.elem[i - 1]);
    }
    

    如果要求查找线性表L中与给定值e相等的数据元素,即按内容查找:

    status Locate(SeqList L,ElemType e)
    {
    	int i = 0; //i为扫描计数器,初值为0,即从第一个元素开始比较
    	while ((i <= L.length) && (L.elem[i] != e))     i++;
    	//顺序扫描表,直到找到值为key的元素,或扫描到表尾而没找到
    	if (i <= L.length)
    		return(i);  //若找到值为e的元素,则返回其序号
    	else
    		return(-1);  //若没找到,则返回空序号
    }
    

    插入操作 :

    线性表的插入运算是指在表的第i (1≤i≤n+1)个位置,插入一个新元素e,使长度为n的线性表 (e1,…,ei-1,

    ei,…,en) 变成长度为n+1的线性表(e1,…,ei-1,e,ei,…,en)。

    对于顺序表示线性表需要进行插入操作需要在结点的物理顺序必须和结点的逻辑顺序保持一致其实简单

    的理解就是原表中位置n, n-1,…, i上的结点, 依次后移到位置n+1,n,…,i+1上,空出第i个位

    置,然后在该位置上插入新结点e,当然当i=n+1时, 是指在线性表的末尾插入结点,所以无需移动结点,直

    接将e插入表的末尾即可,不过既然是建立的一个动态表那么就必须考虑到当原来分配的空间不够用的情况,

    在这个时候就需要在原来的空间上增加空间,可以利用realloc来实现。
    在这里插入图片描述

    status  InsList(SeqList* L, int i, ElemType e)
    {
    	int k;
    	if ((i < 1) || (i > L->length + 2))//首先判断插入位置是否合法
    	{
    		printf("插入位置i值不合法");
    		return -1;
    	}
    	if (L->length >= L->listsize)
    	{
    		L->elem = (ElemType*)realloc(L->elem,(L->listsize+addsize) * sizeof(ElemType));
    		/*从基址开始申请扩大addsize个ElemType数据需要的大小并返回一个ElemType类型的指针,
    		指向一段可用内存的起始地址重新赋给L.elem*/
    		if (!L->elem)
    		{
    			printf("空间分配失败");
    			return -1;
    		}
    		L->listsize += addsize;//将表的当前分配空间更新
    	}
    	for (k = L->length; k >= i - 1; k--) //为插入元素而移动位置
    		L->elem[k + 1] = L->elem[k];
    	L->elem[i - 1] = e; //C语言数组第i个元素下标为i-1
    	L->length++;
    	return 1;
    }
    

    删除操作
    删除操作其实和插入思想相同也需要进行数据段的移动,其实也还是物理顺序
    必须和结点的逻辑顺序保持一致
    只不过删除是从删除的位置起将后面的元素向前挪一位

    算法大致是若i=L->last+1, 则移位语句L->elem[k-1]= L->elem[k]不执行,
    因为循环变量的初值大于终值,此时不需要移动元素,仅将表长度减1即可。

    status  DelList(SeqList* L, int i, ElemType* e)
    {
    	int k;
    	if ((i < 1) || (i > L->length + 1)) {
    		printf("删除位置不合法!");
    		return -1;
    	}
    	*e = L->elem[i - 1]; //将删除的元素存放到e所指向的变量中   
    	for (k = i; i <= L->length; k++)
    		L->elem[k - 1] = L->elem[k];//后面的元素依次前移
    	L->length--;
    	return 1;
    }
    

    顺序表合并算法
    将两个元素均为非递减有序排列的顺序表合并成一个非递减有序排列顺序表LC,可以根据下面的算法进行操作

    1. 设表LC是一个空表,为使LC也是非递减有序排列,可设两个指针i、j分别指向表LA和LB中的元素
    2. 若LA.elem[i]>LB.elem[j],则当前先将LB.elem[j]插入到表LC中
    3. 若LA.elem[i]≤LB.elem[j] ,当前先将LA.elem[i]插入到表LC中
    4. 如此循环,直到其中一个表被扫描完毕,然后再将未扫描完的表中剩余的所有元素放到表LC中。

    代码实现如下:

    void merge(SeqList* LA, SeqList* LB, SeqList* LC)
    {
    	int i = 0,j = 0, k = 0;
    	while (i <= LA->length && j <= LB->length)
    		if (LA->elem[i] <= LB->elem[j])
    		{
    			LC->elem[k] = LA->elem[i]; i++; k++;
    		}
    		else
    		{
    			LC->elem[k] = LB->elem[j]; j++; k++;
    		}
    	while (i <= LA->length)	//当LA长,则将表LA余下元素赋给表LC
    	{
    		LC->elem[k] = LA->elem[i]; i++; k++;
    	}
    	while (j <= LB->length)  //当LB长,则将表LB余下的元素赋给表LC  
    	{
    		LC->elem[k]= LB->elem[j];
    		j++;
    		k++;
    	}
    	LC->length = LA->length + LB->length;
    }
    

    四、顺序存储结构的优缺点
    优点

    无需为表示结点间的逻辑关系而增加额外的存储空间;

    可方便地随机存取表中的任一元素。

    缺点

    插入或删除运算不方便,除表尾的位置外,在表的其它位置上进行插入或删除操作都必须移动大量的结点,其效率较低;

    由于顺序表要求占用连续的存储空间,存储分配只能预先进行静态分配。因此当表长变化较大时,难以确定合适的存储规模。

    展开全文
  • //C语言--数据结构--线性表 顺序表 线性表顺序存储结构 //其实顺序表就相当于一个数组 #include #include #include #include #include using namespace std; #define MAXSIZE 10//定义顺序表的长度 ...
  • 顺序线性表概念 ...线性表存储结构最常见的有两大类,一个是用一维数组,一个使用链表,本篇演示一维数组实现的线性,即顺序线性表;链表实现的线性表可以称之链式线性表。 有哪些操作 显示线性表元素个数...
  • 分析:顺序存储结构线性表提供了数组操作符的重载,通过重载能够快捷方便的获取目标位置处的数据元素,具体的使用形式上类似数组,但是由于本质不同,不能代替数组使用 小结 — 顺序存储线性表的插入和删除操作...
  • * 文件名:顺序存储线性表 * 基本操作: * InitList(&L) //构造一个空的线性表L * DestoryList(&L) //删除一个线性表 * ClearList(&L) //将线性表重置为空表 * ListEmpty(L) //线性表的探空操作 ...
  • 线性表顺序存储线性表顺序存储线性表顺序存储线性表顺序存储线性表顺序存储线性表顺序存储线性表顺序存储
  • 1,线性表的顺序存储结构,指的是用一段地址连续的存储单元依次存储线性表中的数据元素; 2, C++ 中可以用一个数组作为介质来存储数据元素; 3,设计思路: 1,可以用一维数组实现顺序存储结构:  1,...
  • 顺序结构线性表

    2017-04-18 16:32:20
    线性表的顺序存储结构将线性表中的所有元素,按照逻辑顺序从指定存储位置开始,依次存储到计算机的存储器中一块连续的存储空间中。 优点:存取速度快。 缺点:插入和删除操作慢。假定,线性表的元素类型为ElemType...
  • 顺序存储线性表

    2020-11-28 18:49:59
    本关任务:实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数,以实现线性表中数据的插入、删除与查找等功能。 相关知识 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中,...
  • 线性表顺序存储

    2016-10-11 18:21:52
    线性表顺序存储
  • 线性表顺序存储

    千次阅读 2019-05-03 23:46:34
    线性表顺序存储 线性表顺序存储结构:用一段地址连续的存储单元依次存储线性表的数据元素。 线性表的元素类型相同,用一段连续的地址存储,可以使用数组来存储实现线性表顺序存储线性表的存储结构...
  • 数据结构 实验1 顺序存储线性表 数据结构 实验1 顺序存储线性表 数据结构 实验1 顺序存储线性表 数据结构 实验1 顺序存储线性表
  • 顺序存储结构线性表

    2019-10-30 20:54:25
    线性表顺序存储结构,存、读数据时,不管是哪个位置,时间复杂度都是O(1); 而插入或删除时,时间复杂度都是O(n)。 线性表顺序存储结构优缺点 优点 无须为表示表元素之间的逻辑关系而增加额外的存储...
  • 数据结构的线性表实现,顺序线性表的建立,输入,输出,排序,以及归并。可以参考一下
  • 本文实例讲述了Go语言实现顺序存储线性表的方法。分享给大家供大家参考。具体如下: 代码如下: 代码如下:///////// // 顺序存储线性表 //////// package main import “fmt” const MAXSIZE = 20 //定义数组长度...
  • 线性表顺序存储demo

    2016-07-30 10:42:25
    线性表顺序存储demo,实现了线性表顺序存储的基本操作
  • 顺序线性表

    2017-09-05 10:03:00
    只要确定了存储线性表的起始位置,线性表中任一数据元素都可随机存取,所以线性表的顺序存储结构是一种随机存取的存储结构。 数组类型有随机存取的特性,因此通常都用数组来描述数据接哦故中的顺序...
  • 顺序构建线性表线性表实训)

    千次阅读 2020-04-28 18:41:25
    按照数据输入的顺序构建一个线性表。即如果输入的333个结点数据分别为1、2、3...线性表中元素的个数n即为线性表的长度,当n=0时称为空表。线性表的相邻元素之间存在着序偶关系。如用(a[0],…,a[i-1],a[i],a[i+1...
  • 数据结构课程重要知识点,顺序存储结构线性表基本操作。
  • 线性表顺序存储结构

    2019-04-22 18:59:23
    顺序存储定义 线性表的顺序存储结构,指的是用一段地址连续的存储单元依次存储线性表的数据元素 顺序存储结构需要的三个属性 存储空间的起始位置:数组data,它的存储位置...线性表的长度是线性表中数据元素的个数...
  • 顺序存储线性表基本算法实现。运行环境为VS2012,仅提供代码。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,088
精华内容 22,035
关键字:

在顺序存储的线性表中