精华内容
下载资源
问答
  • 静态创建、初始化一个顺序表 #include<stdio.h> #define MaxSize 10 //定义最大长度 typedef struct { int data[MaxSize];//用静态的数组存放数据元素 int length;//顺序表当前长度 }SqList; //顺序表类型定义...
    #include<stdio.h>
    #define MaxSize 10 //定义最大长度
    
    typedef struct
    {
        int data[MaxSize];//用静态的数组存放数据元素
        int length;//顺序表当前长度
    }SqList; //顺序表类型定义
    
    //基本操作——初始化一个顺序表
    void InitList(SqList &L)
    {
        for(int i=0;i<MaxSize;i++)
        {
            L.data[i]=0;//将所有元素设置为默认初始值
            //内存中可能会有遗留的脏数据
        }
        L.length=0;//顺序表初始长度为0
    }
    
    int main()
    {
        SqList L; //声明一个顺序表
        InitList(L);//初始化顺序表
        //...
        //后续操作
        return 0;
    }
    
    展开全文
  • <p style="text-align:center"><img alt="" height="744" src="https://img-ask.csdnimg.cn/upload/1616921361519.png" width="1382" /></p>  </p>
  • 初始化表对多个其他类对象初始化的运行顺序 使用大学C++教材上的一个例子来说明这个运行先后顺序: #include #include using namespace std; //////////////////////////////////////////////////////////////////...

    初始化表对多个其他类对象初始化的运行顺序

    使用大学C++教材上的一个例子来说明这个运行先后顺序:

    #include
    #include
    using namespace std;

    class Date //定义日期类
    {
    public:
    Date(int y, int m, int d); //声明带参数的构造函数
    void show();
    private:
    int m_nYear, m_nMonth, m_nDay;
    };
    Date::Date(int y, int m, int d) //定义Date类的构造函数
    {
    cout << “Date constructor!” << endl;
    m_nYear = y;
    m_nMonth = m;
    m_nDay = d;
    }
    void Date::show() //定义成员函数show(),显示日期
    {
    cout << m_nYear << “-” << m_nMonth << “-” << m_nDay << endl;
    }

    //
    class Student //定义学生类
    {
    public:
    //声明带参数的构造函数,con_name表示学生姓名,con_id表示学生id,y、m、d表示日期信息
    Student(char *con_name, int con_id, int y, int m, int d);
    void disp_msg();
    private:
    Date a;
    Date m_iBirthday; //Date类型的数据成员
    char m_gName[20];
    int m_nID;
    };
    //定义Student类带参数的构造函数,参数y、m、d用于对Date类对象m_iBirthday初始化
    Student::Student(char *con_name, int con_id,
    int y, int m, int d) :m_iBirthday(y, m, d),a(m)
    {
    cout << “Student constructor!” << endl;
    strcpy_s(m_gName, strlen(con_name) + 1, con_name);
    //strcpy(m_gName, con_name);
    m_nID = con_id;
    }
    void Student::disp_msg() //定义成员函数disp_msg(),显示学生信息
    {
    cout << “std name:” << m_gName << ", id = " << m_nID << “, birthday:”;
    m_iBirthday.show();
    a.show();
    }
    //
    int main()
    {
    Student student(“xiaoming”, 1, 1998, 10, 25); //调用带参数的构造函数定义类对象
    student.disp_msg();
    system(“pause”);
    return 0;
    }
    //
    ——————代码是简而易懂的———————————我是分割线—————————————
    在这里插入图片描述将程序在vs2017中打开运行;
    在39-40行中,我们通过参数y、m、d对Date类对象m_iBirthday进行初始化(在34行定义了m_iBirthday为Date类型的数据成员);

    若我们在34行中再定义一个Date型的数据成员a;同时在40行中用参数y对Date类对象a进行初始;52行输出show:
    在这里插入图片描述

    根据所学知识,39-41行中我们要先执行后面初始化的对象;即m_iBirthday和a两个对象;我们写的是m_iBirthday在前,a在后;而实际上运行结果却是a对象先进行初始化、m_iBirthday初始化排在a对象之后;
    而这又是为什么呢?

    原来初始化表对多个其他类对象初始化时的顺序不是根据后面对象的先后顺序来的,m_iBirthday在前面也不一定比a先执行;执行顺序是根据34-35行这些对象成为Date类的数据成员的先后顺序来的;因为a比m_iBirthday先在被Date定义,所以后面初始化表中会先初始化a;

                   ****这与初始化表中初始化对象的顺序是没有关系的!****
    
    展开全文
  • #include <iostream> using namespace std; #define TURE 1 #define FALSE 0 #define ERROR 0 #define OK 1 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; ...}
  • 怎么体现该顺序表的长度为LISI_INIT_SIZE,比方说头指针的地址是多少,尾指针的地址是多少? 问题2: 在插入的时候,如果初始表长为0,插入的位置为1,那么指针end 的地址会小于p,书上的表达是否有误
  • 顺序表以及初始化

    2020-07-13 23:15:35
    /* 顺序表以及初始化---这里我们先使用数组来表示顺序表 1 定义数组 1.1 一个未不确定大小的数组 1.2 添加元素之后的数组长度 1.3 数组的大小(静态数组,数组的大小是固定的) 2 数组初始化 3 向数
    #include <stdio.h>  /*此标准库用于输入输出*/
    #include <string.h> /*与字符串相关的标准库;字符的复制等*/
    #include <stdlib.h> /*这个与动态申请存储空间相关*/
    
    /* 顺序表以及初始化---这里我们先使用数组来表示顺序表
     1 定义数组
        1.1 一个未不确定大小的数组
        1.2 添加元素之后的数组长度
        1.3 数组的大小(静态数组,数组的大小是固定的)
     2 数组初始化
     3 向数组中添加元素
     4 打印数组元素
     */
    #define Size  5
    typedef int EleType;
    //定义数组
    typedef struct Table{
        EleType *head;/*数组*/
        EleType len;
        EleType size;
    }Table_define;
    
    /*数组初始化
     1 这个Init_Table函数的类型是Table_define;这意味着这个函数Init_Table的返回值是更新之后的Table_define
     2 换句话讲,函数Init_Table是结构体Table_define的扩充;这个好像不好理解,还是看第一点吧
     3 返回值
        3.1 确定的数组(静态数组)
        3.2 数组的大小
        3.3 元素长度初始化为0
     */
    Table_define Init_Table(){
        Table_define Tab_def;
        Tab_def.head = (EleType*)malloc(sizeof(Size));
        if(!Tab_def.head){
            printf("初始化失败!");
        }
        Tab_def.len = 0;
        Tab_def.size = Size;
        return Tab_def;
    }
    /*添加元素---3个参数
     1 需要添加的元素ele
     2 添加到数组的位置下标i(从0开始)
     3 需要添加的数组
     */
    //void Add_Ele(EleType ele,EleType i,Table_define t){
    //    t.head[i]=ele;
    //    t.len++;
    //}
    
    int main(){
        Table_define t = Init_Table();
        /*添加元素*/
        for(int i=0;i<=Size;i++){
            t.head[i]=i;
            t.len++;
        }
        /*打印元素*/
        for(int i=1;i<t.len;i++){
            printf("%d",t.head[i]);
            printf("\n");
        }
        return 0;
    }
    
    

    实际上,更简便的方式:

    #include <stdio.h>  /*此标准库用于输入输出*/
    #include <string.h> /*与字符串相关的标准库;字符的复制等*/
    #include <stdlib.h> /*这个与动态申请存储空间相关*/
    
    
    
    int main(){
        int nums[10];
        int i;
        //控制台输入
        printf("---Input---\n");
        for(i=0;i<10;i++){
            scanf("%d",&nums[i]);
        }
        //输出数组元素
        printf("Output\n");
        for(i=0;i<10;i++){
            printf("%d",nums[i]);
            printf("----\n");
        }
        return 0;
    }
    --------
    ---Input---
    1
    2
    3
    4
    5
    6
    7
    8
    9
    0
    Output
    1----
    2----
    3----
    4----
    5----
    6----
    7----
    8----
    9----
    0----
    Program ended with exit code: 0
    
    展开全文
  • L是一个顺序表,函数Status ListInsert_Sq(SqList &L, int pos, ElemType e)是在顺序表的pos位置插入一个元素e(pos应该从1开始),函数Status ListDelete_Sq(SqList &L, int pos, ElemType &e)是删除顺序表的pos...

    顺序表基本操作

    实现顺序表增、删、查找、初始化以及顺序表输出等基本操作函数。L是一个顺序表,函数Status ListInsert_Sq(SqList &L, int pos, ElemType e)是在顺序表的pos位置插入一个元素e(pos应该从1开始),函数Status ListDelete_Sq(SqList &L, int pos, ElemType &e)是删除顺序表的pos位置的元素并用引用型参数e带回(pos应该从1开始),函数int ListLocate_Sq(SqList L, ElemType e)是查询元素e在顺序表的位次并返回(如有多个取第一个位置,返回的是位次,从1开始,不存在则返回0),函数void ListPrint_Sq(SqList L)是输出顺序表元素。

    顺序表存储结构定义

    #define LIST_INIT_SIZE  100
    #define LISTINCREMENT   10
    typedef int ElemType;  //假设线性表中的元素均为整型
    typedef struct{
        ElemType* elem;   //存储空间基地址
        int length;       //表中元素的个数
        int listsize;     //表容量大小
    }SqList;  

    函数接口定义

    Status InitList_Sq(SqList &L);//初始化顺序表L
    Status ListInsert_Sq(SqList &L, int pos, ElemType e);//在pos位置插入元素e
    Status ListDelete_Sq(SqList &L, int pos, ElemType &e);//删除pos位置的元素,该元素用e带回
    int ListLocate_Sq(SqList L, ElemType e);//查找元素e在L中的位置
    void ListPrint_Sq(SqList L);//输出顺序表
    

    函数实现

    Status InitList_Sq(SqList &L)
    {
        //初始化L为一个空的有序顺序表
        L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
        if(!L.elem)exit(OVERFLOW);
        L.listsize=LIST_INIT_SIZE;
        L.length=0;
        return OK;
    }
    Status ListInsert_Sq(SqList &L, int pos, ElemType e)
    {
        int i;
        if(pos<1 || pos>L.length+1)
            return ERROR;
        if(L.length>=L.listsize)//扩容
        {
            L.elem=(ElemType*)realloc(L.elem,(LIST_INIT_SIZE+LISTINCREMENT)*sizeof(ElemType));
            if(!L.elem)
                return OVERFLOW;
            L.listsize+=LISTINCREMENT;
        }
        for(i=L.length+1; i>=pos; i--)
            L.elem[i]=L.elem[i-1];
        L.elem[pos]=e;
        L.length++;
        return OK;
    }
    Status ListDelete_Sq(SqList &L, int pos, ElemType &e)
    {
        int i;
        if(pos<1 || pos>L.length)
            return ERROR;
        e=L.elem[pos];
        for(i=pos; i<L.length; i++)
            L.elem[i]=L.elem[i+1];
        L.length--;
        return OK;
        e=L.elem[pos-1];
        for(int i=pos-1; i<pos; i++)
        {
            L.elem[i]=L.elem[i+1];
            L.length--;
    
        }
        return OK;
    }
    
    int ListLocate_Sq(SqList L, ElemType e)
    {
        int flag=1;
        int l;
        for(int i=1; i<=L.length; i++)
        {
            if(L.elem[i]==e)
            {
                l=i;
                flag=0;
                break;
            }
        }
        if(flag==1)
        {
            return ERROR;
        }
    
        return l;
    }
    
    void ListPrint_Sq(SqList L)
    {
        if(!L.elem)
            return ;
        int i;
        for(i=1; i<L.length; i++)
            printf("%d ",L.elem[i]);
        printf("%d",L.elem[i]);
    }
    输入格式:第一行输入一个整数operationNumber,表示操作数,接下来operationNumber行,每行表示一个操作信息(含“操作种类编号 操作内容”)。 编号为1表示插入操作,后面两个参数表示插入的位置和插入的元素值 编号为2表示删除操作,后面一个参数表示删除的位置 编号为3表示查找操作,后面一个参数表示查找的值 编号为4表示顺序表输出操作输出格式:对于操作2,输出删除的元素的值 对于操作3,输出该元素的位置,如果不存在该元素,输出“NOT FOUND”; 对于操作4,顺序输出整个顺序表的元素,两个元素之间用空格隔开,最后一个元素后面没有空格。

    输入样例:

    4
    1 1 11
    2 2
    3 3
    4
    

    输出样例:

    1
    3
    11 2 3 4 5 6 7 8 9 10
    
    完整代码实现:

    //库函数头文件包含
    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    
    //函数状态码定义
    #define TRUE        1
    #define FALSE       0
    #define OK          1
    #define ERROR       0
    #define INFEASIBLE -1
    #define OVERFLOW   -2
    
    typedef int  Status;
    
    //顺序表的存储结构定义
    #define LIST_INIT_SIZE  100
    #define LISTINCREMENT   10
    typedef int ElemType;  //假设线性表中的元素均为整型
    typedef struct{
        ElemType* elem;   //存储空间基地址
        int length;       //表中元素的个数
        int listsize;     //表容量大小
    }SqList;    //顺序表类型定义
    Status InitList_Sq(SqList &L);
    Status ListInsert_Sq(SqList &L, int pos, ElemType e);
    Status ListDelete_Sq(SqList &L, int pos, ElemType &e);
    int ListLocate_Sq(SqList L, ElemType e);
    void ListPrint_Sq(SqList L);
    
    int main() {
        SqList L;
    
        if(InitList_Sq(L)!= OK) {
            printf("InitList_Sq: 初始化失败!!!\n");
            return -1;
        }
    
        for(int i = 1; i <= 10; ++ i)
            ListInsert_Sq(L, i, i);
    
        int operationNumber;  //操作次数
        scanf("%d", &operationNumber);
    
        while(operationNumber != 0) {
            int operationType;  //操作种类
            scanf("%d", & operationType);
    
            if(operationType == 1) {  //增加操作
                int pos, elem;
                scanf("%d%d", &pos, &elem);
                ListInsert_Sq(L, pos, elem);
            } else if(operationType == 2) {  //删除操作
                 int pos; ElemType elem;
                 scanf("%d", &pos);
                 ListDelete_Sq(L, pos, elem);
                 printf("%d\n", elem);
            } else if(operationType == 3) {  //查找定位操作
                ElemType elem;
                scanf("%d", &elem);
                int pos = ListLocate_Sq(L, elem);
                if(pos >= 1 && pos <= L.length)
                    printf("%d\n", pos);
                else
                    printf("NOT FIND!\n");
            } else if(operationType == 4) {  //输出操作
                ListPrint_Sq(L);
            }
           operationNumber--;
        }
        return 0;
    }
    Status InitList_Sq(SqList &L)
    {
        //初始化L为一个空的有序顺序表
        L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
        if(!L.elem)exit(OVERFLOW);
        L.listsize=LIST_INIT_SIZE;
        L.length=0;
        return OK;
    }
    Status ListInsert_Sq(SqList &L, int pos, ElemType e)
    {
        int i;
        if(pos<1 || pos>L.length+1)
            return ERROR;
        if(L.length>=L.listsize)//扩容
        {
            L.elem=(ElemType*)realloc(L.elem,(LIST_INIT_SIZE+LISTINCREMENT)*sizeof(ElemType));
            if(!L.elem)
                return OVERFLOW;
            L.listsize+=LISTINCREMENT;
        }
        for(i=L.length+1; i>=pos; i--)
            L.elem[i]=L.elem[i-1];
        L.elem[pos]=e;
        L.length++;
        return OK;
    }
    Status ListDelete_Sq(SqList &L, int pos, ElemType &e)
    {
        int i;
        if(pos<1 || pos>L.length)
            return ERROR;
        e=L.elem[pos];
        for(i=pos; i<L.length; i++)
            L.elem[i]=L.elem[i+1];
        L.length--;
        return OK;
        e=L.elem[pos-1];
        for(int i=pos-1; i<pos; i++)
        {
            L.elem[i]=L.elem[i+1];
            L.length--;
    
        }
        return OK;
    }
    
    int ListLocate_Sq(SqList L, ElemType e)
    {
        int flag=1;
        int l;
        for(int i=1; i<=L.length; i++)
        {
            if(L.elem[i]==e)
            {
                l=i;
                flag=0;
                break;
            }
        }
        if(flag==1)
        {
            return ERROR;
        }
    
        return l;
    }
    
    void ListPrint_Sq(SqList L)
    {
        if(!L.elem)
            return ;
        int i;
        for(i=1; i<L.length; i++)
            printf("%d ",L.elem[i]);
        printf("%d",L.elem[i]);
    }


    展开全文
  • 既然是一个顺序表是一个类似数组的结构,因此在创建时要注意: 1.提前申请足够大的内存空间,防止内存不够导致数据溢出。 2.在创建和初始化的时候时刻记录顺序表的长度和存储空间大小。 步骤: 1.创建顺序表的每一个...
  • 该程序实现了一个顺序表的基本操作: int InitList_Sq(); //初始化线性表 void CreateSqList(); //创建线性表 void ListInsert(); //向线性表中插入值 void ListDelete(); //删除顺序表中的数据元素 void Print...
  • 自定义顺序表,C 语言实现代码如下: typedef struct Table{ int * head;//声明了一个名为head的长度不确定的数组,也叫“动态数组” ...注意,head 是我们声明的一个初始化的动态数组,不要只把它看做...
  • 我刚学数据结构,里面有很多的伪代码。请帮忙,写一个能实现顺序表初始化,和顺序表元素的插入的 c语言源程序。
  • 数据结构 是个指针变量,实际的意思是指向一个内存地址,当p=(char *)malloc(2) 后,p即指向了malloc函数所分配的内存区的首地址了,并且告诉你从首地址
  • C语言顺序表初始化

    2021-02-24 18:26:58
    // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的数据类型名称 typedef int Status ; typedef int ElemType ; // struct 结构体 ...
  • 在使用顺序表之前,首先创建一个空的顺序表,也就是初始化顺序表。这里,在程序中只需设置顺序表的结点数量ListLen为0即可。这样,后面需要添加的数据元素将从顺序表的第一个位置存储
  • C语言实现顺序表初始化、增删查改... 顺序表中的第一个元素只有一个后继节点,最后一个元素只有一个前驱节点,中间元素均只有一个前驱节点和一个后继节点。 实现过程及结果 C语言实现顺序表的所有函数操作。 代码 #
  • 一个序列 元素之间是有序的 数据元素 之间是 一对一的关系 有限性: 线性表的数据元素的个数是有限的 (食物链中生物的个数是有限的) 常见的操作 创建和初始化 、 查找 、 插入 、 删除(增删改查) 线性表表达...
  • 文章目录顺序表的定义顺序表上的操作初始化求表长遍历表动态分配插入操作查找操作按值查找按位查找删除操作判空操作销毁操作完整代码及实例 顺序表的定义  线性表的顺序存储又称顺序表。它是用组地址连续的存储...
  • //从n开始倒退着像后移动一个地址 Elemtype *p=&(L.elem[L.length-1]); //p代表第n个元素 for(j;j>=i-1;j--) *(p+1)=*p; *q=e; //地址不变,数值变化 L.length++; return OK; } void main() { ...
  • ![图片说明]...蓝色的圈内,当我使用”&“号时,第一个L说表达式必须是可修改的左值, 当我使用指针符时,两个L都说表达式必须包含类类型是怎么回事,求大佬指教
  • 线性结构:在非空有限集合中,存在唯一“第一个”数据元素,存在唯一“最后一个”数据元素;  除此之外的数据元素都存在唯一的前驱,唯一的后继。 线性表:n个元素的有限序列 顺序表:用一组地址连续的存储单元...
  • Python基础之定义一个顺序表 这是我第一次写,也是在边学边练的过程中,写的可能会有些问题,欢迎大家批评指正。 class sqlist: def init(self,max=100): #初始化,默认分配给顺序表的空间为100个字符 self.max=max ...
  • (1)初始化顺序表L\n");    InitList(H);  printf(" (2)依次插入a,b,c,d,e元素\n");  ListInsert(H,1,'a');  ListInsert(H,2,'b');  List...
  • 在剧中Sheldon可以说是一个极品,真不知Leonard是如何忍受这位极品室友成天的唠叨。 你知道么?Sheldon有一个神秘的小本本,记录了所有他从小开始讨厌的人名。Stuart这位漫画店老板就是小本本的一员哦,谁叫他常常...
  • 可以快速计算出任何一个数据元素的存储地址,即访问每个元素所花时间相等 算法实现(C语言) 在这里插入代码片#include<stdio.h> #include<stdlib.h> #define maxsize 100 #define ERROR 0 #define OK ...
  • 线性表之顺序存储初始化倒序输出   顺序表,全名顺序存储结构,是线性表的一种。“具有 ‘一对一’ ...我们可以先定义出一个顺序表的结构。   然后就是初始化了,我们需要对基地址先初始化,申请相应大小的动态
  • 线性表的每个数据元素的类型都相同,所以可以用一维数组来实现顺序存储结构,即把第一个数据元素存到数组下标为0的位置中,接着把线性表相邻的元素存储在数组中相邻的位置。 数组的长度是存放线性表的存储空
  • 这篇博客采用纯c语言完成数据结构顺序表的 增删改查几基本操作 当作是自己每次学习后的小总结 下面po代码!! #include<stdio.h> #include<stdlib.h> #define LISTSIZE 20 typedef struct { int* ...
  • 我们已经建立好了一个容量为 2020 的顺序表,你需要对其执行一系列的操作。 输入格式 第一行输入一个正整数 m(1≤m≤100),代表一共有 m 个操作。 接下来输入 m 行,每行首先输入一个整数 t,分别代表以下操作: ...

空空如也

空空如也

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

初始化一个顺序表