精华内容
下载资源
问答
  • 数据结构–顺序表(创建初始化) 顺序表和链表不同,顺序表类似数组,...2.创建实现不同功能的函数:初始化顺序表的函数、打印顺序表的函数 3.主函数 调用以上实现个功能的函数 如下: #include <stdio.h> #inc

    数据结构–顺序表(创建初始化)

    顺序表和链表不同,顺序表类似数组,顺序存储就是地址连续,而链表由于指针的存在地址可以不连续。

    既然是一个顺序表是一个类似数组的结构,因此在创建时要注意:
    1.提前申请足够大的内存空间,防止内存不够导致数据溢出。
    2.在创建和初始化的时候时刻记录顺序表的长度和存储空间大小。

    步骤:
    1.创建顺序表的每一个节点
    2.创建实现不同功能的函数:初始化顺序表的函数、打印顺序表的函数
    3.主函数 调用以上实现个功能的函数
    如下:

    #include <stdio.h>
    #include <stdlib.h>
    #define LISTINCREMENT 4 //预定义顺序表的长度4,即4个节点长度的顺序表
    
    typedef struct {
        int *elem;//elem是开辟顺序表内存空间的首地址,找到首地址即可访问后续连续的节点,声明了一个名为elem的长度不确定的数组,也叫“动态数组”
        int length;//顺序表的长度
        int listsize;//录顺序表分配的存储容量
        }SqList; //创建了一个结构体类型
    
    
    SqList CreatList(){
        SqList L;
        L.elem=(int *)malloc(LISTINCREMENT*sizeof(int));//开辟数组存储空间
        if(!L.elem){
            printf("初始化失败");
            exit(0);
            }   //申请空间失败
        L.length=0;//初始化数组长度为0,目前还未初始化,是一个空表
        L.listsize=LISTINCREMENT;//空表的最大内存容量
        return L;//返回一个长度为0,最大容量为4的数组
    }
    
    void DisplayList(SqList L){
        int i;
         for(i=0;i<L.length;i++){
            printf("%d",L.elem[i]);
            printf("\n");
            }
        }//打印每个节点的值
    
    
    void main(){
        SqList L = CreatList();
        int j;
        for(j=1;j<=LISTINCREMENT;j++){
            L.elem[j-1]=j;//初始化顺序表
            L.length++;//每初始化一个顺序表的节点,顺序表长度加一
            }
        DisplayList(L);
        }  
    

    第一次正式进入CSDN写vlog队列中,从今开始时常记录每日所学所感,如有错误和不恰当之处,欢迎诸佬批评指正,谢谢!~///(v)\~

    展开全文
  • 数据结构 是个指针变量,实际的意思是指向一个内存地址,当p=(char *)malloc(2) 后,p即指向了malloc函数所分配的内存区的首地址了,并且告诉你从首地址
  • 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在...通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系...

    顺序存储结构

    顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

    初始化

    使用顺序表存储数据:
    1.要申请足够大小的物理空间;
    2.顺序表申请的存储容量;
    3.顺序表的长度,也就是表中存储数据元素的个数;

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

    typedef struct Table{
    	int *head;		//声明动态数组
    	int length;		//记录表的当前长度
    	int size;		//记录表的分配容量(最大长度)
    	}table; 
    

    接下来是顺序表的初始化,要进行如下操作:
    1.给 head 动态数据申请足够大小的物理空间;
    2.给 size 和 length 赋初值;
    C语言代码实现如下:、

    #define Size 5		//顺序表申请空间的大小
    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; 
    }
    

    输出奇数

    顺序表的初始化工作做好了,尝试做一个小操作:输出顺序表中的奇数

    #include<stdio.h>
    #include<stdlib.h>
    #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;		//表的初始长度为0
    	t.size=Size;	//表的存储空间(最大长度)为Size
    	return t; 
    }
     
    //输出奇数 
    void displayOddNumber(table t){
    	int i;
    	printf("输出顺序表中的奇数:\n");
    	for(i=0;i<t.length;i++)
    	{
    		if(t.head[i]%2==1)
    		printf("%d\n",t.head[i]);
    	}
    	printf("\n"); 
    }
    int main()
    {
    	int i;
    	table t=initTable();     
    	//添加元素 
    	for(i=1;i<=Size;i++)
    	{
    		t.head[i-1]=i;
    		t.length++;
    	}
    	displayOddNumber(t);
    	return 0;
    }
    

    程序运行结果如下:
    在这里插入图片描述
    个人笔记,感谢阅读。
    在这里插入图片描述

    展开全文
  • 有学生调程序,是要建顺序表。  他的程序是这样的:#include #include <malloc.h>#define MaxSize 50 //Maxsize将用于后面定义存储空间的大小 typedef int ElemType; //ElemType在不同场合可以根据问题的需要确定...

      有学生调程序,是要建顺序表。
      他的程序是这样的:

    #include <stdio.h>
    #include <malloc.h>
    
    #define MaxSize 50    //Maxsize将用于后面定义存储空间的大小
    typedef int ElemType;  //ElemType在不同场合可以根据问题的需要确定,在此取简单的int
    typedef struct
    {
        ElemType data[MaxSize];  //利用了前面MaxSize和ElemType的定义
        int length;
    } SqList;
    
    //声明自定义函数
    SqList InitList(SqList *L);   //初始化顺序表
    void ListInsert(SqList *L,int i,int b);  //插入函数
    void DispList(SqList *L);    //输出函数
    bool ListEmpty(SqList *L);//判定是否为空表ListEmpty(L)
    
    int main()
    {
        SqList *sq;
        InitList(sq);
        ListInsert(sq, 1, 5);
        ListInsert(sq, 2, 3);
        ListInsert(sq, 1, 4);
        DispList(sq);
        return 0;
    }
    
    //输出线性表DispList(L)
    void DispList(SqList *L)
    {
        int i;
        if (ListEmpty(L))
            return;
        for (i=0; i<L->length; i++)
            printf("%d ",L->data[i]);
        printf("\n");
    }
    
    //判定是否为空表ListEmpty(L)
    bool ListEmpty(SqList *L)
    {
        return(L->length==0);
    }
    
    //初始化顺序表InitList(*L)
    SqList InitList(SqList *L)
    {
        L=(SqList *)malloc(sizeof(SqList));//这里申请了结点空间
        L->length=0;
        return *L;
    }
    
    void ListInsert(SqList *L,int i,int b)   //插入函数
    {
        int j,k;
    
        if(i<1)
        {
            printf("插入位置非法/n");
        }
        for(j=L->length; j>i; j--)
        {
            L->data[j]=L->data[j-1];
        }
        L->data[i]=b;
        L->length++;
    }

      运行结果是这样的:
    这里写图片描述
      他找我帮忙。基本可以断定,内存使用不当,有溢出。
      看一下编译提示的信息,有一个警告:
      D:\CB\DS\main.cpp|21|warning: ‘sq’ is used uninitialized in this function [-Wuninitialized]|
      说在21行,sq未经初始化就使用了。通俗的说法,野指针。
      围绕着sq找。在main()函数中有:

        SqList *sq;
        InitList(sq);

      这里在调用InitList时,实际参数sq就是野指针。但这还不是出问题的关键,看InitList函数的定义是:

    //初始化顺序表InitList(*L)
    SqList InitList(SqList *L)
    {
        L=(SqList *)malloc(sizeof(SqList));//这里申请了结点空间
        L->length=0;
        return *L;
    }

      调用时,L得到的是野指针,但在函数里为其分配空间了。但调用完,这个地址并未返回到main函数中。调用完InitList,sq仍然还是野指针。这是关键!
      沿这个思路,希望能将分配的空间地址能返回给main函数。return *L就不合适了,return L是返回地址。于是,函数定义改为:

    //初始化顺序表InitList(*L)
    SqList *InitList(SqList *L)
    {
        L=(SqList *)malloc(sizeof(SqList));//这里申请了结点空间
        L->length=0;
        return L;
    }

      既然参数SqList *L调用时给的是个野指针,不要也罢。于是改选成无参函数:

    //初始化顺序表InitList(*L)
    SqList *InitList()
    {
        SqList *L=(SqList *)malloc(sizeof(SqList));//这里申请了结点空间
        L->length=0;
        return L;
    }

      在调用时,main函数定义为:

    int main()
    {
        SqList *sq;
        sq = InitList();
        ListInsert(sq, 1, 5);
        ListInsert(sq, 2, 3);
        ListInsert(sq, 1, 4);
        DispList(sq);
        return 0;
    }

      为保证程序能够正确编译,函数声明等处的语法问题不一一列出。解决了这一环节的问题,程序能够运行了,但结果:
      这里写图片描述
      断定问题出在ListInsert函数中。看调用,插入的位置用的是逻辑序(从1开始记数),但函数定义中,直接L->data[i]=b;没有考虑物理存储中,下标是从0开始的。
      所以,在ListInsert中加入一个 i–,完成逻辑序号向物理序号的转换,Done。
      正确的结果不贴图了,最后改过的程序是:

    #include <stdio.h>
    #include <malloc.h>
    
    #define MaxSize 50    //Maxsize将用于后面定义存储空间的大小
    typedef int ElemType;  //ElemType在不同场合可以根据问题的需要确定,在此取简单的int
    typedef struct
    {
        ElemType data[MaxSize];  //利用了前面MaxSize和ElemType的定义
        int length;
    } SqList;
    
    //声明自定义函数
    SqList *InitList();   //初始化顺序表
    void ListInsert(SqList *L,int i,int b);  //插入函数
    void DispList(SqList *L);    //输出函数
    bool ListEmpty(SqList *L);//判定是否为空表ListEmpty(L)
    
    int main()
    {
        SqList *sq;
        sq = InitList();
        ListInsert(sq, 1, 5);
        ListInsert(sq, 2, 3);
        ListInsert(sq, 1, 4);
        DispList(sq);
        return 0;
    }
    
    //输出线性表DispList(L)
    void DispList(SqList *L)
    {
        int i;
        if (ListEmpty(L))
            return;
        for (i=0; i<L->length; i++)
            printf("%d ",L->data[i]);
        printf("\n");
    }
    
    //判定是否为空表ListEmpty(L)
    bool ListEmpty(SqList *L)
    {
        return(L->length==0);
    }
    
    //初始化顺序表InitList(*L)
    SqList *InitList()
    {
        SqList *L=(SqList *)malloc(sizeof(SqList));//这里申请了结点空间
        L->length=0;
        return L;
    }
    
    void ListInsert(SqList *L,int i,int b)   //插入函数
    {
        int j;
    
        if(i<1)
        {
            printf("插入位置非法/n");
        }
        i--;
        for(j=L->length; j>i; j--)
        {
            L->data[j]=L->data[j-1];
        }
        L->data[i]=b;
        L->length++;
    }
    展开全文
  • 数据结构-顺序表初始化

    万次阅读 多人点赞 2014-09-24 17:12:44
    //顺序表初始化 #include #include // #define OK 1; #define OVERFLOW -2 #define MAXSIZE 100//顺序表可能达到的最大长度  typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等 typedef...


    //顺序表的初始化
    #include <stdio.h>
    #include <stdlib.h>//
    #define OK 1;
    #define OVERFLOW -2
    #define MAXSIZE 100//顺序表可能达到的最大长度 
    typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等  
    typedef int ElemType;//ElemType是线性表中数据元素的类型,此处用int
    typedef struct
    {
    	ElemType *elem;//存储空间的基地址 
    	int length;//当前长度 
    	int listsize;//当前分配的存储容量 
    }SqList;
    Status InitList_Sq(SqList &L)//构造一个空的顺序表 
    {
    	L.elem=new ElemType[MAXSIZE];//为顺序表分配一个大小为MAXSIZE的数组空间 
    	if(!L.elem) exit(OVERFLOW);//存储失败 
    	L.length=0;//空表长度为零 
    	L.listsize=MAXSIZE;
    	return OK;
    }
    Status ListTraverse(SqList L)//  初始条件:顺序线性表L已存在  
    {
    	ElemType *p;
    	p=L.elem;
    	int i;
    	printf("线性表当前容量为:%d\n",L.listsize);
    	if(L.length>0)
    	{
    		printf("当前线性表有%d个元素,分别是\n",L.length);
    		for(i=1;i<=L.length;i++)
    		{
    			printf("%d ",*p++);
    		}
    	}
    	else 
    	{
    		printf("目前还是空线性表.\n");
    	}
    }
    int main()
    {
    	SqList la;
    	InitList_Sq(la);
    	ListTraverse(la);
    }
    
    
    Exit()
    函数名: exit()
    所在头文件:stdlib.h
    功 能: 关闭所有文件,终止正在执行的程序。
    exit(1)表示异常退出.这个1是返回给操作系统的不过在DOS好像不需要这个返回值
    exit(x)(x不为0)都表示异常退出
    exit(0)表示正常退出
    用 法: void exit(int status);
    参 数 : status //程序退出的返回值.
    程序例:
    #include <stdlib.h>
    #include <conio.h>
    #include <stdio.h>
    int main(void)
    {
    int status;
    printf("Enter either 1 or 2\n");
    status = getch();
    /* Sets DOS errorlevel */
    exit(status - '0');
    /* Note: this line is never reached */
    return 0;
    }
    exit()和return的区别:
    按照ANSI C,在最初调用的main()中使用return和exit()的效果相同。
    但要注意这里所说的是“最初调用”。如果main()在一个递归程序中,exit()仍然会终止程序;但return将
    控制权移交给递归的前一级,直到最初的那一级,此时return才会终止程序。return和exit()的另一个区别
    在于,即使在除main()之外的函数中调用exit(),它也将终止程序。



    展开全文
  • 线性顺序表初始化,创建,打印。 数据结构 #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define MAXNUM 100 #define OVERFLOW 0 typedef int ...
  • 实现顺序表增、删、查找、初始化以及顺序表输出等基本操作函数。L是一个顺序表,函数Status ListInsert_Sq(SqList &L, int pos, ElemType e)是在顺序表的pos位置插入一个元素e(pos应该从1开始),函数Status ...
  • 数据结构顺序表初始化

    千次阅读 2018-08-18 17:19:32
    #include <stdio.h> #include <stdlib.h> ... #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ,其值是函数结果状态,如OK ...
  • 顺序表在进行初始化操作中必须传地址,否则,一切都是徒劳。  •以下,通过画图的形式详细介绍为什么要传地址而不能传值 大家了解C语言的肯定知道传值和传址的区别,但是在学习数据结构时不得不强调传址的重要...
  • 1、顺序表初始化 2、顺序表插入元素 3、顺序表删除元素 4、顺序表查找元素 5、顺序表合并 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。 顺序存储方式不仅只用于存储线性结构。 ...
  • #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<stdio.h> #define maxSize 10 //定义最大长度 /*静态分配实现顺序表 缺点:数组存满了无法扩大空间,因此对应的有动态分配实现数组 */ struct List { int data[maxSize]; //...
  • 上一篇我们总结了什么是线性表,线性表的ADT类型,线性表的两种存储类型顺序存储结构和链式存储结构,今天正式进入线性表的顺序存储结构的总结和归纳,也就是数据结构的线性表的顺序表的讲解。 1、什么是顺序表? ...
  • #include &amp;lt;iostream&amp;gt; #include &...*实现顺序表初始化和增删改查 *注意:该程序默认顺序表的第0个位置不用,元素从1开始存放 */ typedef struct { int *ele...
  • 数据结构 C语言描述 第三版 顺序表初始化
  • 顺序表的头文件"seqList.h" // "seqList.h" #pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> typedef int SLDateType; typedef struct SeqList { SLDateType* a; // ...
  • 数据结构中线性表的初始化,长度,删除等操作的实现 //定义SqList类型的指针psqList //初始化psqList指向的线性表 //顺序把‘o’,‘l’,‘L’,‘e’,‘e’,'H'六个字符插入到线性表psqList的位置1 //判断线性表是否...

空空如也

空空如也

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

数据结构初始化顺序表

数据结构 订阅