精华内容
下载资源
问答
  • 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 关键字来定义自己习惯...

    没学过C语言,将就着看着吧!

    #include<stdio.h>
    #include<math.h>
    // #define 定义一个标识符来表示一个常量
    #define  OK   1
    #define  ERROR   -1
    #define  MAX_SIZE  100
    //  typedef 关键字来定义自己习惯的数据类型名称
    typedef  int  Status ;
    typedef  int  ElemType ; 
    // struct 结构体
    typedef  struct  sqlist{   
    	// 定义一个数组
    	ElemType  Elem_array[MAX_SIZE] ;
    	// 数组的长度
        int length ;
    } SqList ;
    
    // 初始化数组方法
    // 参数:一个SqList 指针,指针只能是一个结构体的地址。
    Status Init_SqList( SqList *L ) 
    {  
    	// 动态分配空间 c语言中数组需要分配空间
        L->Elem_array[MAX_SIZE]=( ElemType * )malloc(MAX_SIZE*sizeof( ElemType )) ;
        // 如果数组为空,则报错;
        if ( !L -> Elem_array ) 
            return  ERROR ; 
        // 返回 ok,目前还不知道为什么要L->length= 0 ; 有大佬知道请评论;
        else {
            L->length= 0 ; 
            return OK ;  
        }  
    }
    
    展开全文
  • 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语言实现顺序表的初始化、增删查改基本功能引言定义原理实现过程及结果代码运行结果总结 引言 定义 顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表,这个表的大小为N;并且,我们称大小为0的表为空表。 ...

    C语言实现顺序表的初始化、增删查改基本功能

    引言

    定义

    顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表,这个表的大小为N;并且,我们称大小为0的表为空表。

    原理

    <1> 其实顺序表的实现就是简单的数组实现,对表的所有操作都是通过使用数组来实现的。
    <2> 顺序表中的第一个元素只有一个后继节点,最后一个元素只有一个前驱节点,中间元素均只有一个前驱节点和一个后继节点。

    实现过程及结果

    C语言实现顺序表的所有函数操作。

    代码

    #include<stdio.h>
    #include<stdlib.h>
    
    //宏定义
    #define MAXSIZE 50
    #define ERROR 0
    
    typedef int Elemtype; 
    
    typedef struct 
    {
    	Elemtype x[MAXSIZE];
    	int length;
    }sqlist;
    
    //顺序表的初始化、增删查改以及输出操作函数的声明
    void Initlist(sqlist *L);
    void Outlist(sqlist *L);
    void Insertlist(sqlist *L,int i,Elemtype e);
    void Deletelist(sqlist *L,int i);
    void Foundlist(sqlist *L,Elemtype e);
    void Amendlist(sqlist *L,int i,Elemtype e);
    
    //主函数
    void main()
    {
    	Elemtype e;
    	int i;
    	char ch;
    	sqlist a;
    	int t;
    	printf("		《 Welcome to use the founction 》\n");
    	printf("	    The founction can offer following service\n");
    	printf("		*******Please first Initlist*******\n\n");
    	printf("		1、Initlist   ->初始化线性表\n");
    	//初始条件:顺序表已存在
    	printf("		2、Insertlist ->插入操作\n");
    	printf("		3、Deletelist ->删除操作\n");
    	printf("		4、Foundlist  ->查找操作\n");
    	printf("		5、Amendlist  ->更改操作\n");
    	printf("		0、Exitlist   ->退出操作\n\n\n");
    	
    	do
    	{
    		printf("Enter your choice:");
    		scanf("%d",&t);
    
    		switch(t)
    		{
    		case 1:
    			{
    				Initlist(&a);
    				Outlist(&a);
    			}break;
    		case 2:
    			{
    				printf("Enter Insert data:");
    				scanf("%d",&e);
    				printf("Enter the position of Insert:");
    				scanf("%d",&i);
    				Insertlist(&a,i,e);
    				Outlist(&a);
    			}break;
    		case 3:
    			{
    				printf("Enter the position of Delete:");
    				scanf("%d",&i);
    				Deletelist(&a,i);
    				Outlist(&a);
    			}break;
    		case 4:
    			{
    				printf("Enter Found data:");
    				scanf("%d",&e);
    				Foundlist(&a,e);
    			}break;
    		case 5:
    			{
    				printf("Enter the position of amend:");
    				scanf("%d",&i);
    				printf("Enter data of amending:");
    				scanf("%d",&e);
    				Amendlist(&a,i,e);
    				Outlist(&a);
    			}break;
    		case 0:
    			{
    				ch = getchar();
    			}break;
    		}
    	}while(t!=0);
    	ch = getchar();
    }
    //初始化操作
    void Initlist(sqlist *L)
    {
    	int i;
    	printf("Enter the length of the List: ");
    	scanf("%d",&L->length);
    	printf("\n");
    	for(i=0;i<L->length;i++)
    	{
    		printf("Data %d:",i+1);
    		scanf("%d",&L->x[i]);
    		printf("\n");
    	}
    }
    //输出操作
    void Outlist(sqlist *L)
    {
    	int i;
    	printf("Output current List:");
    	for(i=0;i<L->length;i++)
    	{
    		if(i<L->length-1)
    		{
    			printf("%d ->",L->x[i]);
    		}	
    		else
    		{
    			printf("%d ",L->x[i]);
    		}
    	}
    	printf("\n");
    }
    //插入操作
    void Insertlist(sqlist *L,int i,Elemtype e)
    {
    	int j;
    	if(L->length==MAXSIZE)
    	{
    		printf("List full!!!!!!\n");
    		exit(0);
    	}
    	if(i<0||i>L->length+1)
    	{
    		printf("The position is illegal!!!!!!\n");
    		exit(0);
    	}
    	for(j = L->length-1;j>=i;j--)
    	{
    		L->x[j+1]=L->x[j];
    	}
    	L->x[i]=e;
    	L->length++;
    }
    //删除操作
    void Deletelist(sqlist *L,int i)
    {
    	int j;
    	if(L->length==0)
    	{
    		printf("List empty!!!!!!\n");
    		exit(0);
    	}
    	if(i<0||i>L->length+1)
    	{
    		printf("The position is illegal!!!!!!\n");
    		exit(0);
    	}
    	for(j = i+1;j<L->length;j++)
    	{
    		L->x[j-1]=L->x[j];
    	}
    	L->length--;
    }
    //查找操作
    void Foundlist(sqlist *L,Elemtype e)
    {
    	int j;
    	for(j=0;j<L->length;j++)
    	{
    		if(L->x[j] == e)
    			printf("The element you're looking for is in the %d position\n",j+1);
    	}
    }
    //修改操作
    void Amendlist(sqlist *L,int i,Elemtype e)
    {
    	if(L->length==0)
    	{
    		printf("List empty!!!!!!\n");
    		exit(0);
    	}
    	if(i<0||i>L->length+1)
    	{
    		printf("The position is illegal!!!!!!\n");
    		exit(0);
    	}
    	L->x[i] = e;
    }
    

    运行结果

    在这里插入图片描述

    总结

    <1> 虽然数组是动态指定的,但是还是需要把表的大小的最大值进行估计。估计的与实际的偏差,也就是所造成的空间浪费。
    <2> 倘若表中数据过大,插入和删除操作的时间花费有点昂贵。

    上述所谓的空间和时间开销,可以通过线性表的链式存储结构来避免。

    展开全文
  • 数据结构 C语言描述 第三版 顺序表的初始化

    数据结构C语言的描述第三版 -顺序表的初始化

    顺序表

    #include <stdio.h>
    #include <stdlib.h>
    typedef int DataType;//自定义数据类型
    typedef struct student//定义student表
    {
      int MAX;//最大元素个数
       DataType n;//其中的元素
       int length; //元素个数
    }stu1;//表名
    typedef struct student *list;//用typedef 给顺序表一个新的别名
    
    list_createNULLlist(int m)//分配空间给顺序表
    {
        list plist=(list)malloc(sizeof(struct student));
        if(plist!=NULL)//如果为头指针为空  开辟空间
        {
             plist->n=(DataType*)malloc(sizeof(DataType)*m);
        if(plist->n)//如果表内元素为空
        {
    
            plist->MAX=m;//表的最大的元素的个数
            plist->n=0;//表头的值设置为0
            return plist;//返回表的值
        }
        else free(plist);//释放表的内存
        }
        printf("out of space!!\n");//清空
        return NULL;//返回空值
    }//顺序表的初始化
    
    int main()
    {
        int m;//定义顺序表的需要分配内存的大小
        printf("please input size of the list :");
        scanf("%d",&m);//输入元素的最大个数
        printf("%d\n",list_createNULLlist(m));//打印表
        return 0;
    }
    
    
    
    
    
    
    展开全文
  • C语言实现顺序表的初始化,插入,删除,查找

    万次阅读 多人点赞 2016-12-03 23:24:07
    #define LIST_INIT_SISE 100 // 线性表存储空间的初始分配量 #define LIST_INCREASE_SISE 20 // 线性表存储空间的分配增量 #define OK 0 #define ERROR -1 #define OVERFLOW -2 typedef int elementTy
  • 顺序存储结构 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻...3.顺序表的长度,也就是表中存储数据元素
  • //用顺序表实现堆栈 //包含printf与scanf函数 #include //包含malloc函数 #include //v是分配的内存空间的首地址,m是分配的空间的大小(代表了表的总长),n为表的实际长度 //n的初值较为重要。一定要获得栈顶...
  • c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据...
  • 顺序表的表示和实现 顺序表的特点: 逻辑上相邻的元素在物理上也是相邻 可以快速计算出任何一个数据元素的存储地址,即访问每个元素所花时间相等 算法实现(C语言) 在这里插入代码片#include<stdio.h> #...
  • #include <stdio.h> #include <stdlib.h>... //顺序表的当前长度 }SqList; //顺序表的类型定义 void InitList(SqList *p){ int i; for (i = 0; i < MaxSize; i++) { p->data
  • <p style="text-align:center"><img alt="" height="779" src=...出现了关于malloc和free警告,麻烦大佬帮我解答一下疑惑,谢谢</p>
  • //初始化静态顺序表 void init(SeqList *Seq) {  assert(Seq);  memset(Seq->arr, 0, sizeof(DateType)* MAXSIZE);  Seq->size = 0; } //尾插静态顺序表 void PushBack(SeqList *Seq,DateType x) { ...
  • C语言顺序表的实现

    2020-06-19 23:56:00
    利用C语言实现了单链表的初始化,创建,插入,删除,打印功能 代码如下: #include<stdio.h> #include<stdlib.h> typedef int elemtype; #define LIST_INIT_SIZE 20 #define LISTINCREMENT 10 typedef...
  • 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 ...
  • 转载-C语言顺序表

    2019-06-16 00:15:34
    文章目录线性表的顺序存储顺序表的线性存储示意图C语言定义线性表的顺序存储结构顺序表的基本操作(1) 顺序表的初始化(2)求顺序表的长度(3)按序号查找(4)插入操作(5) 删除操作(6)按内容查找(7)头插(8)头删(9)尾插(10)...
  • //初始化动态顺序表 void initSeqList(SeqList *Seq) {  Seq->arr = NULL/* malloc(sizeof(DateType) * 3)*/;  Seq->capacility = 0;  Seq->size = 0; } //销毁空间 void DestroySeq(SeqList *Seq...
  • // printf("顺序表已满,无法插入!"); // return; // } // pSeq->array[pSeq->size++] = x; // pSeq->size++; //} //void PopBack(SeqList* pSeq) //{ // assert(pSeq); // if (pSeq->size  0) // ...
  • C语言顺序表详解

    2021-02-06 17:28:11
    顺序表代码构思创建文件创建结构体初始化尾插内存扩容尾删打印头插头删任意位置插入任意位置删除解释不好,最后献上完整代码头文件 SeqList.h 代码源文件 SeqList.c 代码源文件 test.c 代码 顺序表是什么? 顺序表...
  • 适合初学数据结构,不明白如何通过代码实现顺序表。 超简洁代码如下: # include <stdio.h> # define initsize 10 //表长度的初始定义 # define maxsize 50 //定义线性表的最大...//初始化顺序表 initlist

空空如也

空空如也

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

c语言顺序表的初始化

c语言 订阅