精华内容
下载资源
问答
  • 数据结构 是个指针变量,实际的意思是指向一个内存地址,当p=(char *)malloc(2) 后,p即指向了malloc函数所分配的内存区的首地址了,并且告诉你从首地址
  • 数据结构中线性表的初始化,长度,删除等操作的实现 //定义SqList类型的指针psqList //初始化psqList指向的线性表 //顺序把‘o’,‘l’,‘L’,‘e’,‘e’,'H'六个字符插入到线性表psqList的位置1 //判断线性表是否...

    运行结果:

    在这里插入图片描述数据结构中线性表的初始化,长度,删除等操作的实现

    //定义SqList类型的指针psqList 
    //初始化psqList指向的线性表
    //顺序把‘o’,‘l’,‘L’,‘e’,‘e’,'H'六个字符插入到线性表psqList的位置1
    //判断线性表是否为空 
    //显示线性表psqList当前的长度
    //顺序显示线性表psqList的所有元素
    //删除线性表psqList位置2的元素,显示线性表的元素
    //查找值为'L'元素的位置,如果查找到则修改该元素值为'l',显示线性表元素 
    /*撤销线性表psqList*/ 
    #include<stdio.h>
    #include<stdlib.h>
    #define MaxSize 56
    #define bool int
    
    Typedef char ElemType;
    Typedef struct
    {
        ElemType data[MaxSize];
        int length;
    } SqList;
    
    void InitList_Sq(SqList *&L)//初始化线性表
    {
       L=(SqList *)malloc(sizeof(SqList));
       l->length==0;
    }
    
    void CreaList_Sq(SqList *&L,ElemType a[],int n)//初始化线性表元素
    {
       int i;
       L=(SqList *)malloc(sizeof(SqList));
       for(i=0;i<n.i++)
       L->data[i]=a[i];
       l->length=n;
    }
    
    void ListEmpty(SqList *L)//判断线性表是否为空
    {
       return(L->length==0)
    }
    
    void ListLength(SqList *L)//线性表的长度
    {
       return(L->length);
    }
    
    void ListTraverse_Sq(SqList *&L)//显示元素
    {
       int i;
       for(i=0;i<L->length;i++)
       printf("%d\t",L->data[i]);
       printf("\n");
    }
    
    void ListDelet(SqList *&L,int i,ElemType &e)//删除线性表元素
    {
       int j;
       if(L->length==0)
       	printf("该线性表为空\n");
       if(i<1||i>L->length)
       	printf("删除元素不在范围内\n");
       e=L->data[i-1];
       if(i<L->length)
       {
    	for(j=i,j<L->length;j++)
    	L->data[j-1]=L->data[j];
       }
       L->length--
    }
    
    bool LocatElem(SqList *L,ElemType e)//按元素值查找
    {
       int i;
       while(i<L->length&&L->data[i]!=e)
       	i++;
       if(i<L->length)
       	return i+1;
       else
       	return 0;
    }
    
    void DestroyList(SqList *&L)
    {
       free(L);
    }
    
    int main()
    {
       SqList *psqList;
       ElemType c;
       InitList_Sq(psqList);
       char a[]={'o','l','L','e','e','H'};
       CreaList_Sq(psqList, a,6);
       if(psqList->length==0)
           printf("线性表为空\n");
       else
          printf("该线性表非空\n");
       printf("线性表的长度为%d\n",ListLength(psqList)); 
       ListTraverse_Sq(psqList);
       printf("删除第二个元素之后的线性表为:\n");
       ListDelet(psqList,2,c);
       ListTraverse_Sq(psqList);
       printf("元素'L'的位置为%d\n",LocatElem(psqList,'L');
       L->data[LocatElem(psqList,'L')-1]='l';
       ListTraverse_Sq(psqList);
       DestroyList(psqList);
       
       return 0;
    }
    
    展开全文
  • #include<iostream> #define MaxSize 50 #define ElemType int using namespace std; //typedef struct{ // ElemType data[MaxSize]; // int length;...//初始化线性表 bool InitList(SqLis
    #include<iostream>
    #define MaxSize 50
    #define ElemType int
    using namespace std;
    
    //typedef struct{
    //    ElemType data[MaxSize];
    //    int length;
    //}SqList1;
    
    typedef struct{
        ElemType *data;
        int length;
    }SqList2;
    //初始化线性表
    bool InitList(SqList2 &L)
    {
        L.data = new ElemType[MaxSize];
        if(!L.data)
            return false;
        L.length = 0;
        return true;
    }
    //求表的长度,返回表的长度
    int getLength(SqList2 L)
    {
        return L.length;
    }
    //按值查找一个元素在线性表中的位置,location为元素位置
    int LocateELem(SqList2 L,ElemType e)
    {
        int location;
        for(int i=0;i<L.length;i++)
        {
            if(L.data[i] == e)
            {
                location = i+1;
                break;
            }
        }
        return location;
    }
    //按位查找。获取表在第i个位置的元素
    ElemType GetElem(SqList2 L,int location)
    {
        ElemType e;
        e = L.data[location-1];
        return e;
    }
    //输出操作,按照前后顺序输出线性表中所有元素
    void PrintList(SqList2 L)
    {
        if(L.length == 0) cout << "空打印(线性表已空)";
        for(int i=0;i<L.length;i++)
        {
            cout << L.data[i] << " ";
        }
        cout << endl;
    }
    //插入操作:在表中第i个位置插入指定元素
    bool ListInsert(SqList2 &L,ElemType e,int location)
    {
        if(location > L.length+1 || location < 1)
        {
            cout << "location越界" << endl;
            return false;
        }
        for(int i=L.length;i>=location;i--)
            L.data[i] = L.data[i-1];
        L.data[location-1] = e;
        L.length++;
        return true;
    }
    //删除操作:删除表中第i个位置的元素
    bool ListDelete(SqList2 &L,int location)
    {
        if(L.length == 0)
        {
            cout << "顺序表已空" << endl;
            return false;
        }
    
        if(location > L.length || location < 1)
        {
            cout << "location越界" << endl;
            return false;
        }
        for(int i=location-1;i<L.length;i++)
        {
            L.data[i] = L.data[i+1];
        }
        L.length--;
        return true;
    }
    
    //判空操作,若L为空,则返回true
    bool Empty(SqList2 L)
    {
        if(L.length == 0)
            return true;
        return false;
    }
    //销毁操作。销毁线性表,并释放线性表L所占内存空间
    void DestoryList(SqList2 &L)
    {
        delete[] L.data;
        L.length = 0;
    }
    int main()
    {
        SqList2 L;
        InitList(L);
        int length = getLength(L);
        cout << length << endl;
        for(int i=0;i<5;i++)
        {
            L.data[i] = i+1;
            L.length++;
        }
        length = getLength(L);
        cout << length << endl;
        PrintList(L);
        ListInsert(L,0,6);
        PrintList(L);
        ListDelete(L,1);
        PrintList(L);
        DestoryList(L);
        PrintList(L);
    }
    
    
    展开全文
  • 不仅如此,顺序表数据的物理存储结构也有要求。顺序表存储数据时,会提前申请一整块足够大小的物理空间,然后将数据依次存储起来,存储时做到数据元素之间不留一丝缝隙。例如,使用顺序表存储集合{1,2,3,4,5},...

    顺序表,全名顺序存储结构,是线性表的一种。通过《什么是线性表》一节的学习我们知道,线性表用于存储逻辑关系为“一对一”的数据,顺序表自然也不例外。

    不仅如此,顺序表对数据的物理存储结构也有要求。顺序表存储数据时,会提前申请一整块足够大小的物理空间,然后将数据依次存储起来,存储时做到数据元素之间不留一丝缝隙。

    例如,使用顺序表存储集合 {1,2,3,4,5},数据最终的存储状态如图 1 所示:

    图 1 顺序存储结构示意图

    由此我们可以得出,将“具有 '一对一' 逻辑关系的数据按照次序连续存储到一整块物理空间上”的存储结构就是顺序存储结构。

    通过观察图 1 中数据的存储状态,我们可以发现,顺序表存储数据同数组非常接近。其实,顺序表存储数据使用的就是数组。

    顺序表的初始化

    使用顺序表存储数据之前,除了要申请足够大小的物理空间之外,为了方便后期使用表中的数据,顺序表还需要实时记录以下 2 项数据:

    顺序表申请的存储容量;

    顺序表的长度,也就是表中存储数据元素的个数;

    提示:正常状态下,顺序表申请的存储容量要大于顺序表的长度。

    因此,我们需要自定义顺序表,C 语言实现代码如下:

    typedef struct Table{

    int * head;//声明了一个名为head的长度不确定的数组,也叫“动态数组”

    int length;//记录当前顺序表的长度

    int size;//记录顺序表分配的存储容量

    }table;

    注意,head 是我们声明的一个未初始化的动态数组,不要只把它看做是普通的指针。

    接下来开始学习顺序表的初始化,也就是初步建立一个顺序表。建立顺序表需要做如下工作:

    给 head 动态数据申请足够大小的物理空间;

    给 size 和 length 赋初值;

    因此,C 语言实现代码如下:

    #define Size 5 //对Size进行宏定义,表示顺序表申请空间的大小

    table initTable(){

    table t;

    t.head=(int*)malloc(Size*sizeof(int));//构造一个空的顺序表,动态申请存储空间

    if (!t.head) //如果申请失败,作出提示并直接退出程序

    {

    printf("初始化失败");

    exit(0);

    }

    t.length=0;//空表的长度初始化为0

    t.size=Size;//空表的初始存储空间为Size

    return t;

    }

    我们看到,整个顺序表初始化的过程被封装到了一个函数中,此函数返回值是一个已经初始化完成的顺序表。这样做的好处是增加了代码的可用性,也更加美观。与此同时,顺序表初始化过程中,要注意对物理空间的申请进行判断,对申请失败的情况进行处理,这里只进行了“输出提示信息和强制退出”的操作,可以根据你自己的需要对代码中的 if 语句进行改进。

    通过在主函数中调用 initTable 语句,就可以成功创建一个空的顺序表,与此同时我们还可以试着向顺序表中添加一些元素,C 语言实现代码如下:

    #include

    #include

    #define Size 5

    typedef struct Table{

    int * head;

    int length;

    int size;

    }table;

    table initTable(){

    table t;

    t.head=(int*)malloc(Size*sizeof(int));

    if (!t.head)

    {

    printf("初始化失败");

    exit(0);

    }

    t.length=0;

    t.size=Size;

    return t;

    }

    //输出顺序表中元素的函数

    void displayTable(table t){

    for (int i=0;i

    printf("%d ",t.head[i]);

    }

    printf("\n");

    }

    int main(){

    table t=initTable();

    //向顺序表中添加元素

    for (int i=1; i<=Size; i++) {

    t.head[i-1]=i;

    t.length++;

    }

    printf("顺序表中存储的元素分别是:\n");

    displayTable(t);

    return 0;

    }

    程序运行结果如下:

    顺序表中存储的元素分别是:

    1 2 3 4 5

    可以看到,顺序表初始化成功。

    展开全文
  • 数据结构不仅仅指的数据值在逻辑上的结构,更有在存储空间上的位置结构,顺序表,故名思意是有一定顺序的数据结构顺序表最基本模型如图:对于基本布局顺序表而言,它存储相同单元大小并且在内存地址上连续的数据,...

    数据结构不仅仅指的数据值在逻辑上的结构,更有在存储空间上的位置结构,顺序表,故名思意是有一定顺序的数据结构。

    顺序表最基本模型如图:

    b7e4abbd8b65acde00c93da3548e9969.png

    对于基本布局顺序表而言,它存储相同单元大小并且在内存地址上连续的数据,逻辑地址是其元素的逻辑顺序,物理地址第一个元素的内存地址加上离第一个元素的距离,如:e1物理地址是l0,那么e2的物理地址是e1的地址加上e1所占用的大小c,以此类推,en的物理地址是l0+(n-1)*c。

    这种基本布局出现了一个问题,如果其中的元素大小不统一,那么岂不是要用最大存储单元作为基本单位,非常浪费空间,因此出现了外置顺序表,它是将元素的索引以相同单元大小连续存放,索引记录对应数据在内存上的地址,那么我们可以通过基本布局的方式去找到索引,再根据索引找到数据。

    在熟悉了顺序表的基本模型后,我们再看顺表的结构,如图所示:

    a7dba5ca5c5b2e729d0da7be118b8ff8.png

    实际的顺序表包含两部分,一部分是顺序表的记录信息块(含顺序表容量、元素个数),一部分是数据块,这两部放在一起是一体式结构,如果分离通过索引连接是分离式结构。

    顺序表含有容量和容量的使用情况信息,那么很容易就实现扩容,其扩容方式有两种:一种是频繁的固定扩容,即每次增加固定单位的容量,因此会平凡扩容;另一种是倍增的扩容,即按照2、4、8、16这种方式来扩,这样扩容频率低,但可能造成浪费。

    在python中list和tuple都是顺序表结构,list是动态顺序表,支持内部结构变化如增加或者减少元素,而tupele并不支持结构的改变,其他性能和list一致。

    既然我们知道了python中使用最频繁的list内在结构,那我们就应该明白append是在顺序表末尾增加一个元素,他的时间复杂度是O(1),而insert插入函数是将插入位置之后的元素依次向下挪动一个位置,复杂度是O(n);同理删除一个元素,当删除最后一个位置的元素pop()只是删除循序表的最后一个位置元素,如果是删除指定元素,那么该元素其后的元素依次挪动一个位置其时间复杂度为O(n);

    这便是数据结构的意义,它对python性能的提升有指导性的作用。

    7e1783986cf32025548368c9fc41fd40.png

    3ab9eaeafcd834f82d365ba491ce7555.png

    展开全文
  • 一、什么是顺序表:线性表的两种基本的实现模型:1.将表中元素顺序地存放在一大块连续的存储...二、顺序表两种基本形式: 三、顺序表结构: 四、实现方式: 五、增加元素: a. 尾端加入元素,时间复杂度为O(1)b. 非...
  • 用Python仿照C语言来实现线性表的顺序存储结构,供大家参考,具体内容如下本文所采用的数据结构模板为 《数据结构教程》C语言版,李春葆、尹为民等著。该篇所涉及到的是线性表的顺序存储结构。代码:# !/usr/bin/env...
  • 抽象数据类型表示(ADT)类型名称:线性表数据对象集:线性表是n(>=0)个元素构成的有序序列(a1,a2,….,an)操作集:2.线性表的顺序实现1.表示方法:其中100可以自己规定,last代表线性表的长度# 线性表定义class ...
  • https://www.xin3721.com/eschool/python.html本文实例讲述了C#数据结构顺序表(SeqList)实现方法。分享给大家供大家参考,具体如下:线性结构(Linear Stucture)是数据结构(Data Structure)中最基本的结构,其特征...
  • python 的内置数据结构很强大,分装的很好。...线性表 List零个或多个数据元素的有限序列集合 一些数据元素类型 数据类型大小指针 前驱 后继 元素抽象数据模型ADT 线性表 ListData定义Operationinit 初始化c...
  • 顺序表在进行初始化操作中必须传地址,否则,一切都是徒劳。  •以下,通过画图的形式详细介绍为什么要传地址而不能传值 大家了解C语言的肯定知道传值和传址的区别,但是在学习数据结构时不得不强调传址的重要...
  • #include<stdio.h> #define MAXSIZE 10 typedef struct{ int data[MAXSIZE]; int length; }Sqlist;...void ListInit(Sqlist &...printf(“初始化完成\n”); } bool ListInsert(Sqlist &L,int i,int e){ if(i<
  • #include &amp;lt;iostream&amp;gt; #include &...*实现顺序表初始化和增删改查 *注意:该程序默认顺序表的第0个位置不用,元素从1开始存放 */ typedef struct { int *ele...
  • 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在...通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系...
  • 数据结构-顺序表初始化

    万次阅读 多人点赞 2014-09-24 17:12:44
    //顺序表初始化 #include #include // #define OK 1; #define OVERFLOW -2 #define MAXSIZE 100//顺序表可能达到的最大长度  typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等 typedef...
  • 数据结构顺序表(创建初始化顺序表和链表不同,顺序表类似数组,顺序存储就是地址连续,而链表由于指针的存在地址可以不连续。 既然是一个顺序表是一个类似数组的结构,因此在创建时要注意: 1.提前申请足够大...
  • printf("顺序表初始化成功!\n"); return OK; } int Find(SeqList *L, ElemType x) { int i; if (L->n > L->maxLength) { printf("n的长度大于maxLength了,错误了"); return ERROR; } for (i = 0; i ...
  • 数据结构顺序表初始化

    千次阅读 2018-08-18 17:19:32
    #include <stdio.h> #include <stdlib.h> ... #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ,其值是函数结果状态,如OK ...
  • 1、顺序表初始化 2、顺序表插入元素 3、顺序表删除元素 4、顺序表查找元素 5、顺序表合并 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。 顺序存储方式不仅只用于存储线性结构。 ...
  • 显示思路2.1 初始化2.2 尾插2.3 显示2. 代码2.1 Sqlist.h2.2 Sqlist.cpp2.3 main2. 结果总结 前言 刷leetcode题目时发现需要先学习一下数据结构,那就开始干吧 1. 目标 printf("* [1] push_back [2] push_...
  • 这是静态分配,数组不能超出MAXSIZE #include <iostream> using namespace std; //状态代码 #define OK 1 ...//定义顺序表结构 typedef struct{ //ElemType *elem; int data[MAXSIZE]={0}; in
  • 数据结构 C语言描述 第三版 顺序表初始化

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,237
精华内容 894
关键字:

数据结构顺序表初始化

数据结构 订阅