精华内容
下载资源
问答
  • 数据结构线性表

    2014-12-29 23:38:27
    关于数据结构线性表的课件,线性表的逻辑结构、线性表的顺序存储结构及实现、线性表的链式存储结构及实现、线性表的典型应用。
  • 数据结构线性表详细代码,写得很不错 拿出来和大家分享~
  • 数据结构;第二章 线性表 ; 基本内容 1 线性表的概念 2 线性表两类存储结构和它们的类型定义 3 在这些存储结构下线性表的基本操作的算法 学习要点 1 了解线性表逻辑结构的特征; 2 重点掌握线性表的顺序存储结构和链式...
  • 数据结构 线性表

    2014-09-11 07:04:14
    数据结构 中很重要的线性表,很有帮助,线性表是学好数据结构的基础。
  • c++数据结构线性表结构,根据《数据结构与算法分析》而写
  • 数据结构 线性表 代码 数据结构 线性表 代码 数据结构 线性表 代码
  • 数据结构线性表知识总结 201797 第2章线性表 2.3线性表的链式存储 2.4一元多项式的表示及相加 20179/7 2.1线性表的概念及运算 2.1.1线性表的逻辑结构 2,1,2线性表的抽象数据类型定义 3 20179/7 线性表的定义 线性表...
  • C++数据结构线性表003

    2010-04-29 17:45:24
    C++数据结构线性表003C++数据结构线性表003
  • 数据结构 线性表 插入 删除

    千次阅读 2020-04-22 22:03:17
    数据结构线性表的插入,删除 任务描述 本关任务:实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数,以实现线性表中数据的插入、删除与查找等功能。 相关知识) 线性表是最基本、最简单、也...

    数据结构线性表的插入,删除

    任务描述
    本关任务:实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数,以实现线性表中数据的插入、删除与查找等功能。

    相关知识)
    线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中,数据元素之间通过一对一首尾相接的方式连接起来。具体实现时,线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案:

    在这里插入图片描述
    该方案将线性表存储在一片连续空间里,并通过data、len和max三个属性元素。组织成为一个结构:

    data: 给出线性表存储空间的起始地址;
    max: 指明线性表存储空间最多可存储的数据元素个数;
    len: 当前线性表里的数据元素个数。
    为了讨论简化,我们假设每个数据元素是一个整数:

    typedef int T; // 数据元素的数据类型
    该线性表的结构定义如下:

    struct SeqList{
    T* data; // 数据元素存储空间的开始地址
    int len; // 线性表的当前长度
    int max; // 线性表的最大长度
    };
    以上示意图中的slist是指向该结构的一个指针,只要给定slist指针,就可对线性表进行操作。

    对数据元素进行操作处理是一个数据结构的重要组成部分。线性表涉及的主要操作如下:

    创建线性表:创建一个最多可存储max个数据元素的顺序存储的线性表,并将其初始状态设置为len=0。该操作函数具体定义如下,其返回值为slist:
    SeqList* SL_Create(int max)

    释放线性表存储空间:释放slist->data所指向的用于存储线性表数据元素的存储空间。该操作函数具体定义如下:
    void SL_Free(SeqList* slist)

    置空线性表:将当前线性表变为一个空表,实现方法是将slist->len设置为0。该操作函数具体定义如下:
    void SL_MakeEmpty(SeqList* slist)

    获取线性表当前长度:获取并返回线性表的当前长度slist->len。该操作函数具体定义如下:
    int SL_Length(SeqList* slist)

    判断线性表是否为空:若当前线性表是空表,则返回false,否则返回true。该操作函数具体定义如下:
    BOOL SL_IsEmpty(SeqList* slist)

    判断线性表是否已满:若线性表达到最大长度,则返回 true,否则返回false。该操作函数具体定义如下:
    BOOL SL_IsFull(SeqList* slist)

    返回线性表第i个数据元素:返回线性表的第i个数据元素slist->data[i]。该操作函数具体定义如下:
    T SL_GetAt(SeqList* slist, int i)

    修改线性表第i个数据元素: 将线性表的第 i个数据元素的值修改为 x。该操作函数具体定义如下:
    void SL_SetAt(SeqList* slist, int i, T x)

    在线性表位置i插入数据元素x: 将x插入slist->data[i]之前。若插入失败(i>slist->len 或i<0时,无法插入),返回 false,否则返回 true。该操作函数具体定义如下:
    BOOL SL_InsAt(SeqList* slist, int i, T x)

    删除线性表位置i处的数据元素: 删除线性表的i号数据元素。输入参数i范围应在[0,slist->len-1]内,否则会产生不能预料的异常或错误。返回被删除的数据元素的值。该操作函数具体定义如下:
    T SL_DelAt(SeqList* slist, int i)

    查找线性表中第一个值为x的数据元素的位置: 找到线性表中第一个值为x的数据元素的编号。返回值-1表示没有找到,返回值>=0表示该元素位置。该操作函数具体定义如下:
    int SL_FindValue(SeqList* slist, T x)

    删除线性表中第一个值为x的数据元素: 删除第一个值为x的数据元素,返回该数据元素的编号。如果不存在值为x的数据元素,则返回-1。该操作函数具体定义如下:
    int SL_DelValue(SeqList* slist, T x)

    打印线性表: 打印整个线性表。该操作函数具体定义如下:
    void SL_Print(SeqList* slist)

    编程要求
    本关任务是实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数,以实现线性表中数据的插入、删除与查找等功能。具体要求如下:

    SL_InsAT: 在顺序表的位置i插入结点x,即插入d[i]之前,i的有效范围[0,slist->len];

    SL_DelAt:删除顺序表slist的第i号结点, i的有效范围应在[0,slist->len)内,否则会产生异常或错误。返回被删除的数据元素的值;

    SL_DelValue:删除第一个值为x的结点,存在值为x的结点则返回结点编号,未找到返回-1;

    输入输出格式请参见后续测试样例。

    注意:本关必读中提及的其他操作已经由平台实现,你在实现本关任务的三个操作函数时,在函数体内可调用其他操作。`

    本关涉及的代码文件 Seqlist.cpp 中的 3 个操作函数的代码框架如下:

    bool SL_InsAt(SeqList* slist, int i, T x)
    // 在顺序表的位置i插入结点x, 插入在d[i]之前。i的有效范围[0,slist->len]
    {
    // 请在这里补充代码,完成本关任务
    /********** Begin /
    /
    * End /
    }
    T SL_DelAt(SeqList
    slist, int i)
    // 删除顺序表slist的第i号结点(i的有效范围应在[0,slist->len)内,否则会产生异常或错误)。返回被删除的数据元素的值。
    {
    // 请在这里补充代码,完成本关任务
    /
    * Begin /
    /
    * End /
    }
    int SL_DelValue(SeqList
    slist, T x)
    // 删除第一个值为x的结点。存在值为x的结点则返回结点编号, 未找到则返回-1
    {
    // 请在这里补充代码,完成本关任务
    /
    * Begin /
    /
    * End **********/
    }

    以下是代码:

    #include <stdio.h>
    #include <stdlib.h>
    #include "Seqlist.h"
    SeqList* SL_Create(int maxlen)
    // 创建一个顺序表。
    // 与SqLst_Free()配对。
    {
    	SeqList* slist=(SeqList*)malloc(sizeof(SeqList));
    	slist->data = (T*)malloc(sizeof(T)*maxlen);
    	slist->max=maxlen;
    	slist->len=0;
    	return slist;
    }
    void SL_Free(SeqList* slist)
    // 释放/删除 顺序表。
    // 与SqLst_Create()配对。
    {
    	free(slist->data);
    	free(slist);
    }
    void SL_MakeEmpty(SeqList* slist)
    // 置为空表。
    {
    	slist->len=0;
    }
    int SL_Length(SeqList* slist)
    // 获取长度。
    {
    	return slist->len;
    }
    bool SL_IsEmpty(SeqList* slist)
    // 判断顺序表是否空。
    {
    	return 0==slist->len;
    }
    bool SL_IsFull(SeqList* slist)
    // 判断顺序表是否满。
    {
    	return slist->len==slist->max;
    }
    T SL_GetAt(SeqList* slist, int i)
    // 获取顺序表slist的第i号结点数据。
    // 返回第i号结点的值。
    {
    	if(i<0||i>=slist->len) {
    		printf("SL_GetAt(): location error when reading elements of the slist!\n");		
    		SL_Free(slist);
    		exit(0);
    	}
    	else 
    		return slist->data[i];
    }
    void SL_SetAt(SeqList* slist, int i, T x)
    // 设置第i号结点的值(对第i号结点的数据进行写)。
    {
    	if(i<0||i>=slist->len) {
    		printf("SL_SetAt(): location error when setting elements of the slist!\n");		
    		SL_Free(slist);
    		exit(0);
    	}
    	else 
    		slist->data[i]=x;
    }
    bool SL_InsAt(SeqList* slist, int i, T x)
    // 在顺序表的位置i插入结点x, 插入d[i]之前。
    // i 的有效范围[0,plist->len]。
    {
        // 请在下面的Begin-End之间补充代码,插入结点。
        /********** Begin *********/
    	int j;
    	{
    		for(j=i;j<slist->len;j++){
    			slist->data[j+1]=slist->data[j];
    		}
    		slist->data[i]=x;
    		slist->len++;
    	}
        /********** End **********/
    }
    T SL_DelAt(SeqList* slist, int i)
    // 删除顺序表plist的第i号结点。
    // i的有效范围应在[0,plist->len)内,否则会产生异常或错误。
    // 返回被删除的数据元素的值。
    {
        // 在下面的Begin-End之间补充代码,删除第i号结点。
        /********** Begin *********/
    	for(;i<slist->len;i++)
    	{
    		slist->data[i]=slist->data[i+1];
    	}
    	slist->len--;
        /********** End **********/
    }
    int SL_FindValue(SeqList* slist, T x)
    // 在顺序表表中查找第一个值为x的结点,返回结点的编号。
    // 返回值大于等于0时表示找到值为x的结点的编号,-1表示没有找到。
    {
    	int i=0;
    	while(i<slist->len && slist->data[i]!=x) i++;
    	if (i<slist->len) return i;
    	else return -1;
    }
    int SL_DelValue(SeqList* slist, T x)
    // 删除第一个值为x的结点。
    // 存在值为x的结点则返回结点编号, 未找到返回-1。
    {
        // 在下面的Begin-End之间补充代码,删除第一个值为 x 的结点。
        /********** Begin *********/
    	int i=0;
    	for(i=0;i<slist->len;i++)
    	{
    		if(slist->data[i]==x)
    		{
    			int j=i;
    			for(;i<slist->len-1;i++){
    				slist->data[i]=slist->data[i+1];
    			}
    			slist->len--;
    			return j;
    		}
    		return -1;
    	}
        /********** End **********/
    }
    void SL_Print(SeqList* slist)
    // 打印整个顺序表。
    {
    	if (slist->len==0) {
    		printf("The slist is empty.\n");		
    		return;
    	}
    	//printf("The slist contains: ");
    	for (int i=0; i<slist->len; i++) {
    		printf("%d  ", slist->data[i]);
    	}
    	printf("\n");	
    	
    }
    
    展开全文
  • 数据结构线性表学习笔记总结 线性表-顺序存储-链式存储-循环链表-双链表 知识点总结-代码实现
  • 数据结构线性表之概念(一)相关文章线性表的定义线性表的逻辑结构线性表的特征 相关文章 数据结构线性表之抽象基类(二) 数据结构线性表之实现顺序表(三) 线性表的定义 线性表的逻辑结构 由n(n>=0)个数据元素(a1...

    相关文章

    数据结构线性表之概念(一)

    数据结构线性表之抽象基类(二)

    数据结构线性表之实现顺序表(三)

    线性表的定义

    线性表的逻辑结构

    1. 由n(n>=0)个数据元素(a1,a2,a3,…,an)构成的有限序列
    2. 记作:L=(a1,a2,a3,…,an),其中a1首元素,an尾元素
    3. 表的长度(表长)是线性表中数据元素的数目
    4. 空表指的是不包含数据元素的线性表

    线性表的特征

    对于(a1,a2,a3,…,ai-1,ai,ai+1,…,an)

    1. ai-1是ai直接前驱
    2. ai+1是ai直接后继
    3. a1没有直接前驱
    4. an没有直接后继
    5. ai有且仅有一个直接前驱和一个直接后继
    展开全文
  • 数据结构线性表(链式线形表 与 顺序线性表)的C语言实现,能够运行,可以作为参考
  • 数据结构线性表作业

    2008-06-14 15:42:17
    这是数据结构线性表的作业,有答案!
  • 数据结构 线性表-1引言什么是线性结构线性表-逻辑结构线性表-物理存储结构线性表-顺序存储线性表基本操作线性表插入与删除操作线性表顺序存储结构的不足 引言 什么是线性结构 定义 有且仅有一个起始元素(无直接前...

    引言

    什么是线性结构

    1. 定义
      有且仅有一个起始元素(无直接前趋,仅有一个直接后继),一个终点元素(无直接后继,仅有一个前趋),其余内部元素各有一个直接前趋和一个直接后继的有限有序序列。
    b
    1
    2
    3
    e
    1. 常见类型:线性表、堆栈、队列、数组、串等。

    线性表-逻辑结构

    是指数据元素之间的关系为一一对应的线性关系的数据结构。
    例如:
    (1,2,3,4,5,6)是一个线性表,表长为7,元素为整数。

    线性表-物理存储结构

    1. 顺序存储结构
      逻辑上连续,物理上也连续。
      在这里插入图片描述
    2. 链式存储结构
      物理上可以不连续,逻辑关系由指针表示。
      在这里插入图片描述

    线性表-顺序存储

    1. 将表中元素一个接一个的存入一组连续的存储单元中,这种存储结构是顺序结构。
    2. 采用顺序存储结构的线性表简称为“顺序表”。
    3. 顺序表存储结构示意图
      在这里插入图片描述

    线性表基本操作

    在程序设计语言中,常使用一维数组来表示线性表的顺序存储空间,定义如下:

    #define MAX_LIST_SIZE 100
    typedef struct {  //结构体
    ElemType *elems;  // 存储空间地址
    int length;       // 当前长度
    }SeqList;
    

    1、顺序线性表初始化

    int initiate(SeqList SL) {
    	// 构造一个空的线性表
    	SL.elems=(ElemType*)malloc(MAX_LIST_SIZE*sizeof(ElemType)); 
    	//使用malloc返回所分配的内存空间的首地址
    	if(SL.elems==null)
    		ERROR(“Overflow”);  //存储分配失败
    	SL.length=0; 			// 空表长度为0
    	return OK;
    }
    

    2、销毁线性表

    void destroy(SeqList SL) {
    	// 释放线性表占据的所有存储空间
    	if (SL.elems)
    		free(SL.elems);
    	return;
    }
    

    3、清空线性表

    void clear(SeqList SL) {
    	// 将线性表清空
    	SL.length=0;
    	return;
    }
    

    4、求线性表的长度

    int length(SeqList SL) {
    	// 返回线性表的长度
    	return SL.length;
    }
    

    5、判断线性表是否为空

    boolean isEmpty(SeqList SL) {
    	// 如果线性表为空则返回true, 否则返回false
    	if(SL.length==0)
    		return true;
    		else return false;
    }
    

    6、获取线性表SL中的某个数据元素的内容

    ElemType get(SeqList SL, int idx) {
    	// 判断idx值是否合法,否则输出错误信息
    	if (idx<0 || idx>=SL.length)
    		return ERROR;
    	return SL.elems[idx];
    }
    

    7、线性表SL中检索值为elem的数据元素

    int locate(SeqList SL, ElemType elem) {
    	idx=0;
    	// 查找每个元素是否与待查元素相等
    	while(idx<SL.length && SL.elems[idx]!=elem)
    		idx++;
    	if(idx>=SL.length)
    		return ERROR;
    		else return idx;
    }
    

    线性表插入与删除操作

    1. 插入操作

    指在线性表第i-1个数据元素和第i个数据元素中插入一个新的数据元素,使长度为n的线性表变成长度为n+1的线性表。
    举例
    原线性表
    在这里插入图片描述
    在第3个元素前插入元素372得到新的新线性表
    在这里插入图片描述
    在顺序线性表SL第idx个数据元素之前插入数据元素elem。

    void insert(SeqList SL, int idx, ElemType elem) {
    	// 检查是否有剩余空间
    	if (SL.length== MAX_LIST_SIZE)
    		return ERROR;
    	// 检查idx值是否合法
    	if (idx<1 || idx>SL.length)
    		return ERROR;
    	//将线性表第i个元素之后的所有元素向后移动
    	for (j=SL.length-1; j>=idx-1; j--)
    		SL.elems[j+1]=SL.elems[j];
    	// 将新元素的内容放入线性表的第i个位置,
    	SL.elems[idx-1]=elem;
    	SL.length++;
    }
    
    1. 删除操作
      将线性表的第i个数据元素删除,使长度为n的线性表变成长度为n-1的线性表。
      例子
      原线性表
      在这里插入图片描述
      删除第3个元素得到新线性表如下
      在这里插入图片描述
      删除顺序线性表第idx个数据元素
    ElemType delete(SeqList SL, int idx) {
    	// 检测线性表是否为空
    	if(isEmpty(SL))
    		return ERROR;
    	// 检查idx值是否合法
    	if (idx<0 || idx>=SL.length)
    		return ERROR;
    	// 将欲删除的数据元素内容保存在变量elem中
    	ElemType elem=SL.elems[idx-1];
    	// 将线性表第idx+1个元素之后的所有元素向前移动
    	for (j=idx;j<SL.length;j++)
    		SL.elems[j-1]=SL.elems[j];
    	SL.length--;
    	return elem;
    }
    

    线性表顺序存储结构的不足

    1. 进行插入或删除操作时,要求移动大量的数据元素,效率较低;
    2. 对于长度变化较大的线性表,要一次性分配足够的存储空间,但这些空间常常又得不到充分的利用;
    3. 线性表的容量难以扩充;
    4. 线性表的顺序存储结构不便于对存储空间的动态共享;

    顺序存储结构适用于表中元素变动较少的情况。

    下一篇:数据结构 线性表-2链式存储

    展开全文
  • 数据结构线性表相关操作

    千次阅读 2015-12-28 15:50:34
    数据结构线性表是数据结构最基础的一章内容,也是数据结构最基础的一段,包括线性表的定义,线性表的初始化,线性表的插入,删除,合并。下面贴上代码#include #include #include using namespace std; //线性表的...

    数据结构线性表是数据结构最基础的一章内容,也是数据结构最基础的一段,包括线性表的定义,线性表的初始化,线性表的插入,删除,合并。下面贴上代码

    #include <stdio.h>
    #include <malloc.h>
    #include<iostream>
    using namespace std;
    //线性表的定义
    typedef int ElemType;
    typedef struct LNode{
        ElemType data;
        struct LNode *next;
    }LNode,*LinkList;
    //线性表的初始化
    int InitList_L(LinkList &L)
    {
        L = (LinkList)malloc(sizeof(LNode));
        L->next = NULL;
        return 1;
    }
    //线性表的插入
    int ListInsert_L(LinkList &L,int i,ElemType e)
    {
        LinkList p;
        p = L;
        int j = 0;
        while(p&&j<i-1)
        {
            p=p->next;
            ++j;
        }
        if(!p||j>i-1)
            return 0;
        LinkList s = (LinkList)malloc(sizeof(LNode));
        s->data = e;
        s->next=p->next;
        p->next=s;
        return 1;
    }
    //清空线性表
    void Delete_L(LinkList L)
    {
        LinkList p = L->next;
        if(!p)
            cout << "this list is empty!";
        while(p)
        {
            cout << p->data;
            p = p->next;
        }
        cout << endl;
    }
    //合并线性表
    void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
    {
        LinkList pa = La->next;
        LinkList pb = Lb->next;
        LinkList pc = Lc=La;
        while (pa&&pb)
        {
            if(pa->data<pb->data)
            {
                pc->next=pa;
                pc=pa;
                pa=pa->next;
            }
            else
            {
                pc->next=pb;
                pc=pb;
                pb=pb->next;
            }
        }
        pc->next=pa?pa:pb;
        free(Lb);
    }
    
    int main()
    {
        LinkList La,Lb,Lc;
        InitList_L(La);
        InitList_L(Lb);
        InitList_L(Lc);
        ListInsert_L(La,1,2);
        ListInsert_L(La,2,3);
        ListInsert_L(La,3,5);
        Delete_L(La);
    }
    展开全文
  • 线性表是最基本、最简单、也是最常用的一种数据结构线性表(linear list)是数据结构的一种, 一个线性表是n个具有相同特性的数据元素的有限序列。线性表的相邻元素之间存在着序偶关系。如用(a1,…,ai-1,ai,...
  • 想不明白数据结构线性表有什么意义,感觉有数组就够用了。为啥非要研究出来个线性表呢?数据实现还简单,也能封装增删查改的代码
  • 数据结构 线性表和链表 c++面向对象实现 分文件编写

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,903
精华内容 16,761
关键字:

数据结构线性表

数据结构 订阅