精华内容
下载资源
问答
  • 初始化顺序表并插入元素

    初始化顺序表并插入元素
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • C语言顺序表初始化,添加,删除,打印。体现和链表添加,删除的区别。
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>

    #define maxsize 10//数组最大长度

    typedef struct array
    {
        int data[maxsize];
        int last;//指向数组中当前存储的最后一个数据
    }arr,*parr;

    void set_arr_null(arr *pseq);
    void init_arr(arr *pseq);
    int add_arr_element(arr *pseq);
    int del_arr_element(arr *pseq);
    void print_arr_element(arr *pseq);

    int main()
    {
        arr *pbuf=(arr *)malloc(sizeof(arr));
        if(NULL==pbuf)
        {
            printf("pbuf malloc failed\n");
            return -1;
        }

        //设置顺序表为空
        set_arr_null(pbuf);

        //初始化顺序表
        init_arr(pbuf);

        while(1)
        {
            printf("\t1:添加数组元素\n\t2:删除数组元素\n\t3:查看数组元素\n\t4:退出\n");
            printf("请输入选项:");
            int sel=0;
            scanf("%d",&sel);
            getchar();
            switch(sel)
            {
                case 1:
                    add_arr_element(pbuf);
                    break;
                case 2:
                    del_arr_element(pbuf);
                    break;
                case 3:
                    print_arr_element(pbuf);
                    break;
                case 4:
                    exit(0);
                default:
                    printf("reinput 1-4\n");
            }
        }

        return 0;
    }

    void set_arr_null(arr *pseq)
    {
        pseq->last=0;
    }

    void init_arr(arr *pseq)
    {
        int i=0;
        for(i=0;i<maxsize;i++)
        {
            pseq->data[i]=0;
        }
    }

    int add_arr_element(arr *pseq)
    {
        printf("%p %p",pseq->data,&pseq->last);
        printf("last:%d maxsize:%d\n",pseq->last,maxsize);
        if(pseq->last+1>maxsize)
        {
            printf("overflow\n");
            return -1;
        }
        printf("请输入添加的位置(从1开始)和数值:\n");
        int pos=0;
        int val=0;
        scanf("%d %d",&pos,&val);
        if(pos>pseq->last+1)
        {
            printf("请在1--%d之间添加数值\n",pseq->last+1);
            return -1;
        }
        int i=0;
        for(i=pseq->last;i>=pos;i--)
        {
            pseq->data[i+1]=pseq->data[i];
        }
        pseq->data[i+1]=val;
        pseq->last++;

        return 0;
    }

    int del_arr_element(arr *pseq)
    {
        if(NULL==pseq)
        {
            printf("pseq null\n");
            return -1;
        }

        if(pseq->last<=0)
        {
            printf("underflow\n");
            return -1;
        }
        int pos=0;
        printf("请输入删除的位置(从1开始):\n");
        scanf("%d",&pos);
        if(pos>pseq->last)
        {
            printf("只能在1--%d之间删除\n",pseq->last);
            return -1;
        }

        int i=0;
        for(i=pos;i<pseq->last+1;i++)
        {
            pseq->data[i]=pseq->data[i+1];
        }
        
        pseq->last--;

        return 0;
    }

    void print_arr_element(arr *pseq)
    {
        int i=0;
        if(pseq->last==0)
        {
            printf("array null\n");
            return;
        }
        for(i=1;i<pseq->last+1;i++)
        {
            printf("%d ",pseq->data[i]);
        }
        printf("\n");
    }
    展开全文
  • 顺序表的表示和实现 顺序表的特点: 逻辑上相邻的元素在物理上也是相邻 可以快速计算出任何一个数据元素的存储地址,即访问每个元素所花时间相等 算法实现(C语言) 在这里插入代码片#include<stdio.h> #...

    顺序表的表示和实现

    顺序表的特点:

    • 逻辑上相邻的元素在物理上也是相邻
    • 可以快速计算出任何一个数据元素的存储地址,即访问每个元素所花时间相等

    算法实现(C语言)

    在这里插入代码片#include<stdio.h>
    #include<stdlib.h>
    #define maxsize 100
    #define ERROR 0
    #define OK 1
    typedef int ElemType;
    typedef int Status;
    
    //定义顺序表类型
    typedef struct{
    	ElemType *data;
    	int length;
    }SqList;
    //构造空顺序表
    int InitList(SqList &L)
    {
    	L.data=(ElemType*)malloc(sizeof(ElemType)*maxsize);//malloc函数为分配一个内存空间
    }
    //判断线性表的长度
    Status GetLength(SqList &L){
    	return (L.length);
    }
    //判断线性表是否为空
    Status IsEmpty(SqList &L)
    {
    	if(L.length==0)
    	{
    		return 1;
    	}
    	else
    	{
    		return 0;
    	}
    }
    //顺序表的插入
    Status ListInerst(SqList &L,int i,ElemType e)
    {
    	if(i<1||i>L.length+1) return ERROR;
    	if(L.length=maxsize) return ERROR;
    	for(int j=L.length-1;j>=i-1;j--)
    	{
    		L.data[j+1]=L.data[j];
    	}
    	L.data[i-1]=e;
    	L.length++;
    	return OK;
    }
    //顺序表的删除
    Status ListDelete(SqList &L,int i)
    {
    	if(i<1||i>L.length) return ERROR;
    	for(int j=i;j<=L.length-1;j++)
    	{
    		L.data[j-1]=L.data[j];
    	}
    	L.length--;
    	return OK;
    }
    //顺序表的查找——按值查找
    Status LocateElem(SqList &L,ElemType e)
    {
    	for(int i=0;i<L.length;i++)
    	{
    		if(L.data[i]==e)
    			return i+1;
    	}
    	return 0;
    }
    //顺序表的取值
    Status GetData(SqList &L,int i,ElemType &e)
    {
    	if(i<1||i>L.length)
    		return ERROR;
    	e=L.data[i-1];//第i-1个存储单元存储着第i个元素
    	return OK;
    }
    
    

    顺序表存储的优缺点:

    优点:

    • 存储密度大(结点本身所占存储量/结点结构所占存储量)
    • 可以随机存储表中任一元素

    缺点:

    • 插入或删除某一元素时,需移动大量元素
    • 浪费存储空间
    • 属于静态存储形式,数据元素的个数不能自由扩充,而且存储满后,会出现溢出错误。
    展开全文
  • //初始化一个空的线性表 Status InitList(SqList *L) { L->pList = (SqList *)malloc(sizeof(SqList)); //申请内存空间 if(L->pList == NULL) { printf("内存空间分配失败!"); } else { L->sqLength = 0; } return ...
    #include <stdio.h>
    #include <stdlib.h>
    # include <malloc.h>
    #define MAXSIZE 100
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    typedef int ElemType;
    typedef int Status;
    
    typedef struct
    {
        ElemType *pList;
        int sqSize;
        int sqLength;
    }SqList;
    
    Status InitList(SqList *L);
    
    Status CreateList(SqList *L);
    
    Status PrintList(SqList *L);
    Status InsertList(SqList *L,int i,ElemType e);
    
    Status DeleteSqList(SqList *L,int i,ElemType *e);
    
    
    
    
    //初始化一个空的线性表
    Status InitList(SqList *L)
    {
        L->pList = (SqList *)malloc(sizeof(SqList)); //申请内存空间
        if(L->pList == NULL)
        {
            printf("内存空间分配失败!");
        }
        else
        {
            L->sqLength = 0;
        }
    
        return OK;
    
    }
    
    //创建顺序表
    Status CreateList(SqList *L)
    {
        int n,i;
        printf("请输入要输入的数据的个数:");
        scanf("%d",&n);
        if(n>MAXSIZE)
        {
            printf("超出最大容量,请重新输入");
        }
        printf("请输入:");
        for( i=0;i<n;i++)
        {
            scanf("%d",&L->pList[i]);
            L->sqLength++;
        }
        return OK;
    
    
    
    }
    
    //输出顺序表
    Status PrintList(SqList *L)
    {
        int j;
        for(j=0;j<L->sqLength;j++)
        {
            printf("%d ",L->pList[j]);
        }
        printf("\n");
        return OK;
    }
    
    //插入元素
    Status InsertList(SqList *L,int i,ElemType e)
    {
        int index;
        //首先合法性检查
        //是否还有空间可以插入;插入位置是否合法
        if(L->sqLength == L->sqSize || i>L->sqLength )
        {
            return FALSE;
        }
    
        for(index=L->sqLength-1;index>=i-1;index--)
        {
            L->pList[index+1] = L->pList[index];
        }
        L->pList[i-1] = e;
        L->sqLength++;
        return OK;
    }
    
    
    //删除元素并用e返回
    
    Status DeleteSqList(SqList *L,int i,ElemType *e)
    {
        int index;
        //首先检查合法性,顺序表是否为空或者删除位置>顺序表的长度或者小于1
        if(L->sqLength == NULL ||  i<1 || i>L->sqLength)
            return FALSE;
        *e = L->pList[i-1];
        if(i<L->sqLength)
        {
            for(index=i;index<L->sqLength;index++)
            {
                L->pList[index-1] = L->pList[index];
                L->sqLength--;
            }
            return OK;
        }
    
    }
    
    int main()
    {
        SqList L ;
        int e;
        InitList(&L);
        CreateList(&L);
        printf("-----原顺序表-----");
        printf("\n");
        PrintList(&L);
        InsertList(&L,3,0);
        printf("-----插入元素后的顺序表为-----");
        printf("\n");
        PrintList(&L);
        DeleteSqList(&L,5,&e);
        printf("-----删除元素后的顺序表为-----");
        printf("\n");
        PrintList(&L);
    
    
    }
    
    
    展开全文
  • //初始化静态顺序表 void init(SeqList *Seq) {  assert(Seq);  memset(Seq->arr, 0, sizeof(DateType)* MAXSIZE);  Seq->size = 0; } //尾插静态顺序表 void PushBack(SeqList *Seq,DateType x) { ...
  • C语言顺序表初始化

    2021-02-24 18:26:58
    没学过C语言,将就着看着吧! #include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的...
  • 初始化顺序表L 2.依次采用尾插法或者头插法插入元素a,b,c,d,e 3.输出顺序表L 4.输出顺序表的长度 5.判断顺序表是否为空 6.输出顺序表的第四个元素 7.输出元素a的位置 8.在第三个元素位置插入元素f
  • C语言实现顺序表初始化、增删查改基本功能引言定义原理实现过程及结果代码运行结果总结 引言 定义 顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表,这个表的大小为N;并且,我们称大小为0的表为空表。 ...
  • C语言实现静态顺序表

    2018-11-17 15:22:41
    2.初始化顺序表; 3.增删查改; 4.顺序表的逆置等。 #define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType data[MAX_SIZE]; DataType length; }SeqList; //顺序表的初始化就是...
  • c语言结构体在顺序表中的实现 #define MAX 100 typedef int datatype; typedef struct { datatype elem[100];...SeqList InitList()//初始化顺序表 { SeqList L; L=(SeqList)malloc(sizeof(Liat)...
  • #define _CRT_SECURE_NO_WARNINGS 1 #include #include #include #include #define MAX_SIZE 5 typedef int DataType; typedef struct SeqList {  size_t size;  DataType array[MAX_SIZE];...//冒
  • C语言实现动态顺序表

    2018-11-23 00:29:38
    关键知识点: 动态顺序表的存储是以动态数组的方式,它比之静态顺序表,在空间的开辟上,更加的灵活。...初始化顺序表 顺序表的尾插 顺序表的尾删 顺序表的头插 顺序表的头删 任意位置插入元素 任意位...
  • c语言顺序表 运行结果测试 测试结果 代码 #include<stdio.h> #include<stdlib.h> typedef int DataType; typedef struct List{ DataType *data; //元素 int Max_SIZE; //数组的最大容量值 ...
  • #define_CRT_SECURE_NO_WARNINGS1 #include<stdio.h> #include<assert.h> #include<stdlib.h> #include<string.h> #defineMAX_SIZE5 typedefintDataType;...typedefstruc...
  • 1.静态分配初始化顺序表: #include<stdio.h> #define ElemType int #define MaxSize 10 typedef struct { ElemType data[MaxSize]; int length; }SqList; void InitSqList(SqList *L) { int i; for(i=...
  • C语言数据结构顺序表的查找算法

    千次阅读 2019-06-04 11:58:46
    /* *顺序表的查找算法(重点是哨兵的设置) *创建一个数据结构体 *创建一个顺序表的结构体 ...*程序 的步骤分为 初始化顺序表 创建顺序表 查找 输出 测试 */ #include<stdio.h> #include&...
  • 数据结构是计算机类学生基本上必修的一门课程,也是比较难得一门课程。对于初学shujujiegouderenlaishui最近写了个数据结构的顺序表,运行了一下感觉还可以,所以想拿出来和大家分享一下
  •  //seqlist.h #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #define MAXSIZE 100 typedef struct {  int listLen; //节点数量  DATA_T dataList[MAXSIZE+1];.../* 初始化顺序表 */ void seqli
  • 初始化列表 GetLength 获取长度 GetElem 查找元素 Locate 找出…的准确位置 InsElem 插入元素 define 定义 typedef 定义类型 struct 结构体 MAXLEN 序列最大值 顺序表的完整代码 #include <...
  • 数据结构c语言版严蔚敏 顺序表

    千次阅读 2019-02-21 21:13:40
    说来惭愧由于贪玩,数据结构挂科了,现在重新学一遍数据结构,...listsize代表这个顺序表的最大容量 可以随时扩容 length代表表中元素个数 应小于listsize 1.初始化 Status list_init(SqList &L) { L.elem...
  • C语言实现顺序表

    千次阅读 2018-07-01 13:21:16
    1、初始化顺序表 2、顺序表的头插 3、顺序表的尾插 4、顺序表的头删 5、顺序表的尾删 6、顺序表的任意点插入 7、顺序表的查找删除 8、顺序表的排序 9、清空顺序表 10、打印顺序表 具体代码实现如下: ...
  • 顺序存储结构 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是...初始化 使用顺序表存储数据: 1.要申请足够大小的物理空间; 2.顺序表申请的存储容量; 3.顺序表的长度,也就是表中存储数据元素
  • 问题是void InitList(Sqlist *L) ,这里只是设置了len不就相当于什么都没做吗,传递结点地址怎么就初始化成结点数组,即链表了?#include #include #define OK 1#define NO 0#define MAXSIZE 20typedef int bool;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 778
精华内容 311
关键字:

c语言初始化顺序表

c语言 订阅