精华内容
下载资源
问答
  • 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 ...

    我们学校实验之一,对你有用可自提

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    #define ERROR 0
    #define OK 1
    #define Overflow 2
    #define Underflow 3
    #define NotProsent 4
    #define Duplicate 5
    typedef int ElemType;
    typedef struct seqList
    {
    	int n;
    	int maxLength;
    	ElemType* element;
    } SeqList;
    
    
    int Init(SeqList* L, int mSize)
    {
    	L->maxLength = mSize;
    	L->n = 0;
    	L->element = (ElemType*)malloc(sizeof(ElemType) * (1+mSize));
    	if (!L->element)
    		return ERROR;
    	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 <= L->n - 1; i++)
    	{
    		if (x == L->element[i])
    		{
    			printf("你查询到了一个匹配的数据:%d\t它所处的位置下标是%d:\n", L->element[i],i);
    		}
    	}
    	return OK;
    }
    int Insert(SeqList* L, ElemType x)
    {
    	if (L->n > L->maxLength)
    	{
    		printf("数组的长度超过了最大的长度,不能再插入了");
    		return ERROR;
    	}
    	else
    	{
    		int i,j;
    		for (i = 0; i<L->n  && x>=L->element[i]; i++);
    		for (j = L->n ; j >= i; j--)
    		{
    			L->element[j + 1] = L->element[j];
    		}
    		L->element[i] = x;
    		printf("数据插入成功!%d\n",L->element[i]);
    		L->n=L->n+1;
    	}
    	return OK;
    }
    int Delete(SeqList* L,ElemType data)
    {
    	int i,j;
    	for (i = 0; i <= L->n - 1 && data != L->element[i]; i++);
    	if (i == L->n)
    	{
    		printf("你想删除的数据不存在,请观察后再输入!\n");
    		return ERROR;
    	}
    	else
    	{
    		for (j = i; j < L->n-1; j++)
    		{
    			L->element[j] = L->element[j + 1];
    		}
    		L->n = L->n - 1;
    		printf("此数据删除成功!\n");
    		return OK;
    	}
    
    }
    int Output(SeqList* L)
    {
    	printf("现在的顺序表如下:\n");
    	int i;
    	if (L->n == 0)
    		return ERROR;
    	for (i = 0; i <= L->n - 1; i++)
    		printf("%d ", L->element[i]);
    	printf("\n");
    	return OK;
    }
    void Destory(SeqList* L)
    {
    	L->n = 0;
    	L->maxLength = 0;
    	free(L->element);
    	printf("顺序表销毁成功!\n");
    }
    int main()
    {
    	int num;
    	int choice;
    	int i;
    	ElemType data;
    	ElemType x=0;
    	SeqList list;
    	printf("请输入总数据的个数:\n");
    	scanf_s("%d", &num);
    	Init(&list, num);
    	for (i = 0; i < num; i++)
    		Insert(&list, i);
    	Output(&list);
    	printf("查询数据-----1\n插入数据-----2\n删除数据-----3\n");
    	printf("请做出你的选择,输入0则退出:\n");
    	scanf_s("%d", &choice);
    	while (choice != 0)
    	{
    		switch (choice)
    		{
    		case 1:
    			printf("请输入你想查询的数据:\n");
    			scanf_s("%d", &data);
    			Find(&list, data);
    			Output(&list);
    			break;
    		case 2:
    			printf("请输入你想插入的数据:\n");
    			scanf_s("%d", &data);
    			Insert(&list, data);
    			Output(&list);
    			break;
    		case 3:
    			printf("请输入你想删除的数据:\n");
    			scanf_s("%d", &data);
    			Delete(&list, data);
    			Output(&list);
    			break;
    		case 0:
    			printf("退出成功!");
    			break;
    		default:
    			printf("您输入的数据有误,请重新输入!\n");
    			break;
    		}
    		printf("查询数据-----1\n插入数据-----2\n删除数据-----3\n");
    		printf("请做出你的选择,输入0则退出:\n");
    		scanf_s("%d", &choice);
    	}
    	Destory(&list);
    	return 0;
    }
    

    代码执行结果如下:
    在这里插入图片描述

    展开全文
  • 数据结构-顺序表的初始化

    万次阅读 多人点赞 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(),它也将终止程序。



    展开全文
  • 顺序存储结构 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻...3.顺序表的长度,也就是表中存储数据元素

    顺序存储结构

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

    初始化

    使用顺序表存储数据:
    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;
    }
    

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

    展开全文
  • 数据结构 是个指针变量,实际意思是指向一个内存地址,当p=(char *)malloc(2) 后,p即指向了malloc函数所分配内存区首地址了,并且告诉你从首地址
  • 不仅如此,顺序表数据的物理存储结构也有要求。顺序表存储数据时,会提前申请一整块足够大小物理空间,然后将数据依次存储起来,存储时做到数据元素之间不留一丝缝隙。例如,使用顺序表存储集合{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

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

    展开全文
  • 数据结构顺序表的初始化

    千次阅读 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、顺序表合并 ...线性表的顺序表示指的是用一组地址连续的存储... 并且顺序表的存储空间需要预先分配 1、方法简单,...
  • 一、什么是顺序表:线性表两种基本实现模型:1.将表中元素顺序地存放在一大块连续存储...二、顺序表两种基本形式: 三、顺序表结构: 四、实现方式: 五、增加元素: a. 尾端加入元素,时间复杂度为O(1)b. 非...
  • 数据结构中线性表的初始化,长度,删除等操作的实现 //定义SqList类型的指针psqList //初始化psqList指向的线性表 //顺序把‘o’,‘l’,‘L’,‘e’,‘e’,'H'六个字符插入到线性表psqList的位置1 //判断线性表是否...
  • 用Python仿照C语言来实现线性表的顺序存储结构,供大家参考,具体内容如下本文所采用的数据结构模板为 《数据结构教程》C语言版,李春葆、尹为民等著。该篇所涉及到是线性表的顺序存储结构。代码:# !/usr/bin/env...
  • 线性顺序表的初始化,创建,打印。 数据结构 #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define MAXNUM 100 #define OVERFLOW 0 typedef int ...
  • 顺序表在进行初始化操作中必须传地址,否则,一切都是徒劳。  •以下,通过画图形式详细介绍为什么要传地址而不能传值 大家了解C语言肯定知道传值和传址区别,但是在学习数据结构时不得不强调传址重要...
  • 本文实例为大家分享了python实现线性表顺序的具体代码,供大家参考,具体内容如下线性表1.抽象数据类型表示(ADT)类型名称:线性表数据对象集:线性表是n(>=0)个元素构成有序序列(a1,a2,….,an)操作集:2.线性表...
  • 数据结构顺序表(创建初始化顺序表和链表不同,顺序表类似数组,顺序存储就是地址连续,而链表由于指针存在地址可以不连续。 既然是一个顺序表是一个类似数组结构,因此在创建时要注意: 1.提前申请足够大...
  • #include &amp;lt;iostream&amp;gt; #include &...*实现顺序表的初始化和增删改查 *注意:该程序默认顺序表的第0个位置不用,元素从1开始存放 */ typedef struct { int *ele...
  • python 内置数据结构很强大,分装很好。...线性表 List零个或多个数据元素有限序列集合 一些数据元素类型 数据类型大小指针 前驱 后继 元素抽象数据模型ADT 线性表 ListData定义Operationinit 初始化c...
  • https://www.xin3721.com/eschool/python.html本文实例讲述了C#数据结构顺序表(SeqList)实现方法。分享给大家供大家参考,具体如下:线性结构(Linear Stucture)是数据结构(Data Structure)中最基本结构,其特征...
  • 不定长顺序表的常见操作:初始化、插入、删除(与定长顺序表一致)、清空、销毁 与定长顺序表不同的是插入可能由增加扩容操作。 #define APPENDSIZE 10 typedef int ElemType; typedef struct SeqList { ElemType...
  • /* time:2018/9/20 function:  顺序表的初始化  b1赋值给顺序表 summarize:  1.结构体声明2种  #1#   typedef struct  {  char no[20];//图书ISBN  char name[50];...
  • 数据结构期中试题之顺序表的基本操作c语言 一定义顺序表的结构及操作主程序中的功能需要按照如下步骤顺序一一实现30分 初始化顺序表L 依次插入a,b,c,d,e元素 输出顺序表L; 输出顺序表L的长度 判断顺序表L是否为空 ...
  • 前面我们已经说了线性表的顺序实现, ...链表结构使用得非常多,不管是操作系统还是数据库都是使用非常频繁一种数据结构, 由于其相对灵活内存使用,并且快速插入和删除,都是非常有优势。 这里通...
  • /////////////////////////////...//顺序表的初始化,建立,插入,查找,删除。// //Author:Wang Yong // //Date: 2010.8.19 // //////////////////////////////////////////// #include <s...

空空如也

空空如也

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

数据结构顺序表的初始化

数据结构 订阅