精华内容
下载资源
问答
  • (1)初始化顺序表L\n");    InitList(H);  printf(" (2)依次插入a,b,c,d,e元素\n");  ListInsert(H,1,'a');  ListInsert(H,2,'b');  List...
  • 顺序存储结构 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是...初始化 使用顺序表存储数据: 1.要申请足够大小的物理空间; 2.顺序表申请的存储容量; 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;
    }
    

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

    展开全文
  • 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语言描述

    2019-08-16 21:10:27
    本文放了一段C语言写的顺序表代码,包括顺序表初始化,计算顺序表长度,插入结点,追加结点,删除结点,查找结点等。

    以下为关键代码

    #include<stdio.h>
    #define MAXLEN 100
    //定义顺序表结构体类型
    typedef struct
    {
    char key[10];
    char name[20];
    int age;
    }DATA;
    typedef struct
    {
    DATA ListData[MAXLEN+1];
    int ListLen;
    }SLType;
    //初始化顺序表
    void SLInit(SLType *SL)
    {
    SL->ListLen=0;
    }
    //计算顺序表长度
    int SLLength(SLType *SL)
    {
    return SL->ListLen;
    }
    //插入结点
    int SLInsert(SLType *SL,int n,DATA data)
    {
    int i;
    if(SL->ListLen>=MAXLEN)
    {
    printf("顺序表已满,不能插入结点!\n");
    return 0;
    }
    if(n<1||n>SL->ListLen-1)
    {
    printf("插入结点数量超出了顺序表最大长度!\n");
    return 0;
    }
    for(i=SL->ListLen;i>=n;i--)
    {
    SL->ListData[i+1]=SL->ListData[i];
    }
    SL->ListData[n]=data;
    SL->ListLen++;
    return 1;
    }
    //追加结点
    int SLAdd(SLType *SL,DATA data)
    {
    if(SL->ListLen>=MAXLEN)
    {
    printf("顺序表已满,不能再添加结点了!");
    return 0;
    }
    SL->ListData[++SL->ListLen]=data;
    return 1;
    }
    //删除结点
    int SLDelete(SLType *SL,int n)
    {
    int i;
    if(n<1||n>SL->ListLen)
    {
    printf("删除结点序号错误,不能删除结点!");
    return 0;
    }
    for(i=n;i<SL->ListLen;i++)
    {
    SL->ListData[i]=SL->ListData[i+1];
    }
    SL->ListLen--;
    return 1;
    }
    //查找结点
    //按序号查找
    DATA *SLFindByNum(SLType *SL,int n)
    {
    if(n<1||n>SL->ListLen)
    {
    printf("结点序号错误,不能返回结点!");
    return 0;
    }
    return &(SL->ListData[n]);
    }
    DATA *SLFindByKey(SLType *SL,char *key)
    {
    int i;
    for(i=1;i<SL->ListLen;i++)
    {
    if(strcmp(SL->ListData[i].key,key)==0)
    {
    return 1;
    }
    }
    return NULL;
    //显示所有结点
    int SLAll(SLType *SL)
    {
    int i;
    for(i=1;i<SL->ListLen;i++)
    {
    printf("(%s,%s,%d)\n",SL->ListData[i].key,SL->ListData[i].name,SL->ListData[i].age);
    }
    return 0;
    }
    

    注意: return 0 和 return NULL 的区别,return 0适用于int类型的函数,返回一个数字0,return NULL适用于其他类型的函数如指针类型的函数,返回一个代表空的关键字NULL。
    参考文献:C/C++常用算法手册

    展开全文
  • //初始化一个空的线性表 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);
    
    
    }
    
    
    展开全文
  • 数据结构 C语言描述 第三版 顺序表初始化
  • 文章目录顺序表详解及其... 顺序表初始化2.顺序表的基本操作增(插入元素)删(删除元素)改(更改元素)查(查找元素)完整代码-输出效果 本人在写该文章过程中发现一个内容及其清晰地文章自己也很受益并把它推荐给你们: ...
  • 初始化顺序表并插入元素
  • //线性表的循序表示 typedef int Position;...//顺序表初始化 List MakeEmpty(){ List l; l=(List)malloc(sizeof(struct LNode));//创建一个顺序表 l->Last=-1;//顺序表的索引值为-1,进行初始化 return
  • 顺序表--C语言

    2018-11-12 11:20:02
    顺序表结构如上 #include &lt;stdbool.h&gt; typedef int Position; typedef int ElementType; #define MAXSIZE 1000 typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position ...
  • #include <stdio.h> #include <stdlib.h>... //顺序表的当前长度 }SqList; //顺序表的类型定义 void InitList(SqList *p){ int i; for (i = 0; i < MaxSize; i++) { p->data
  • C语言实现顺序表初始化、增删查改基本功能引言定义原理实现过程及结果代码运行结果总结 引言 定义 顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表,这个表的大小为N;并且,我们称大小为0的表为空表。 ...
  • 数据结构-顺序表实现(C语言) #include<stdio.h> #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; #define MAXSIZE 100 typedef struct{ int *elem; int length; }SqList; //初始化...
  • C语言顺序表初始化,添加,删除,打印。体现和链表添加,删除的区别。
  • 适合初学数据结构,不明白如何通过代码实现顺序表。 超简洁代码如下: # include <stdio.h> # define initsize 10 //表长度的初始定义 # define maxsize 50 //定义线性表的最大...//初始化顺序表 initlist
  • 顺序表实验实验目的实验内容问题描述算法实验代码示例程序运行示例输入无...顺序表的创建:初始化顺序表 顺序表的查找:给出位置 i 的数据 顺序表的插入:位置 i 和后面的数据全部后移一位;在指定的位置 i 插入一个数
  • 实现顺序表初始化、创建、遍历、查找、插入、删除等算法。 该程序的功能是对元素类型为整型的顺序表进行一些操作。该程序包括顺序表结构类型的定义以及对顺序表操作的具体的函数定义和主函数。 #include "...
  • #include #include const int MAXSIZE=100; typedef struct  {  int data[MAXSIZE];  int length;   }Sqlist; ...void InitList(Sqlist &L)//顺序表初始化  {  L.le
  • 顺序表的表示和实现 顺序表的特点: 逻辑上相邻的元素在物理上也是相邻 可以快速计算出任何一个数据元素的存储地址,即访问每个元素所花时间相等 算法实现(C语言) 在这里插入代码片#include<stdio.h> #...
  • //用顺序表实现堆栈 //包含printf与scanf函数 #include //包含malloc函数 #include //v是分配的内存空间的首地址,m是分配的空间的大小(代表了表的总长),n为表的实际长度 //n的初值较为重要。一定要获得栈顶...
  • 文章目录线性表之顺序表操作(C语言)1. 动态数组的定义2. 初始化3. 按照位置插入元素4. 删除指定位置元素5. 获取指定位置元素6. 获取指定元素第一次出现的位置6. 合并两个有序的顺序表 线性表之顺序表操作(C语言)...
  • //初始化静态顺序表 void init(SeqList *Seq) {  assert(Seq);  memset(Seq->arr, 0, sizeof(DateType)* MAXSIZE);  Seq->size = 0; } //尾插静态顺序表 void PushBack(SeqList *Seq,DateType x) { ...
  • 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

空空如也

空空如也

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

顺序表初始化c语言

c语言 订阅