精华内容
下载资源
问答
  • 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 ;  
        }  
    }
    
    展开全文
  • #include <stdio.h> #include <malloc.h> #define MaxSize 50 typedef char ElemType;...//创建 void InitList(SqList *&L) { L = (SqList *)malloc(sizeof(SqList)); L->length = 0;
    #include <stdio.h>
    #include <malloc.h>
    #define MaxSize 50
    
    typedef char ElemType;
    typedef struct
    {
    	ElemType data[MaxSize];
    	int length;
    } SqList;
    
    //创建表
    void InitList(SqList *&L)
    {
    	L = (SqList *)malloc(sizeof(SqList));
    	L->length = 0; 
    }
    
    //销毁表
    void DestroyList(SqList *L)
    {
    	free(L);
    }
    
    //判空
    int ListEmpty(SqList *L)
    {
    	return(L->length==0);
    }
    
    //返回L中数据元素的个数
    int ListLength(SqList *L)
    {
    	return(L->length);
    }
    
    //输出L表
    void DispList(SqList *L)
    {
    	int i;
    	if (ListEmpty(L)) return;
    	for (i = 0; i < L->length; i++)
    		printf("%c", L->data[i]); 
    	printf("\n");
    }
    
    //用e返回L中第i个数据元素的值
    int GetElem(SqList *L, int i, ElemType &e)
    {
    	if (i<1 || i>L->length)
    		return 0;
    	e = L->data[i];
    	return e;
    }
    
    //返回L中第一个与e相同的元素在L中的位置,若不存在,则返回0
    int LocateElem(SqList *L, ElemType e)
    {
    	int i = 0;
    	while (i < L->length && L->data[i] != e) i++;
    	if (i >= L->length)
    		return 0;
    	else
    		return i + 1;
    }
    
    //在L中第i个位置前插入e,L长度+1
    int ListInsert(SqList *L, int i, ElemType e)
    {
    	int j;
    	if (i<1 || i>L->length + 1)
    		return 0;
    	i--;							//将顺序表位序转化为elem下标
    	for (j = L->length; j > i; j--)		//将data[i]及后面元素后移一个位置
    		L->data[j] = L->data[j - 1]; 
    	L->data[i] = e; 
    	L->length++;	 			//顺序表长度增1
    	return 1;
    }
    
    //删除第i个数据元素,L长度-1
    int ListDelete(SqList *L, int i, ElemType &e)
    {
    	int j;
    	if (i<1 || i>L->length)
    		return 0;
    	i--;							//将顺序表位序转化为elem下标
    	e = L->data[i];
    	for (j = i; j < L->length - 1; j++)
    		L->data[j] = L->data[j + 1]; 
    	L->length--;
    	return 1;
    }
    
    
    void main()
    {
    	SqList *L;
    	ElemType e;
    
    	//调用InitList()函数初始化顺序表
    	printf("(1)初始化顺序表L\n");
    	InitList(L);
    
    	//调用ListInsert依次插入abcde元素
    	printf("(2)依次插入a,b,c,d,e元素\n");
    	int s = 1,i;
    	char m = 'a';
    	for (i=1;i<=5;i++)
    	{
    		ListInsert(L, s, m);
    		s++;
    		m++;
    	}
    
    	//输出L的长度
    	printf("(3)L长度=%d\n", ListLength(L));
    
    	//判断L是否为空
    	if (ListEmpty(L))
    	{
    		printf("(4)顺序表L为空\n");
    	}
    	else
    	{
    		printf("(4)顺序表L为非空\n");
    	}
    	
    	//输出L的第3个元素
    	printf("(5)顺序表L的第三个元素=%c\n", GetElem(L,2,e));
    
    	//输出元素b的位置
    	char b='b';
    	printf("(6)元素b的位置=%d\n", LocateElem(L,b));
    
    	//在第4个元素位置上插入f元素
    	printf("(7)在第4个元素位置上插入f元素\n");
    	char f = 'f';
    	ListInsert(L, 4, f);
    	printf("输出顺序表L:"); DispList(L);
    
    	//删除L的第3个元素
    	printf("(8)删除L的第3个元素\n");
    	ListDelete(L,3,e);
    	//输出顺序表	L
    	printf("(9)输出顺序表L:");
    	DispList(L);
    
    	//释放顺序表L
    	printf("(10)释放顺序表L");
    	DestroyList(L);
    }
    

    输出结果

    展开全文
  • 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语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据...

    c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出)

    1、创建、申请空间

    2、初始化、顺序表数据结构大小、长度

    3、赋值、顺序表数据结构赋值

    4、插入、在指定位置插入数据,后续数据循环后移,长度增加,空间大小增加或者不变

    5、删除、删除指定位置的数据,后续数据循环前移,长度减小、空间大小不变

    6、查询、查看指定数据是否在顺序表结构中

    7、替换、将顺序表结构中指定数值替换为另外的数值

    8、输出、输出顺序表结构中存储的数据(根据长度大小输出)

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <Windows.h>
    #define Size 5
    //显示日期、时间、文件信息
    void xinxi()
    {
    
    	printf("Date : %s\n", __DATE__);
    	printf("Time : %s\n", __TIME__);
    	printf("File : %s\n", __FILE__);
    	printf("Line : %d\n", __LINE__);
    	printf("\n***以下是程序部分***\n\n");
    	
    }
    //定义顺序表结构
    typedef struct Table
    {
    	int *head;//类似于数组指针
    	int length;//数据长度
    	int size;//机构大小
    }table;
    //初始化顺序表结构
    table initcreact()
    {
    	table t;
    	if ((t.head = (int *)malloc(Size*sizeof(int))) == NULL)
    	{
    		printf("申请存储空间失败!");
    			exit(1);
    	}
    	t.length = 0;//初始化长度为 0
    	t.size = Size;//结构大小
    	return t;
    }
    //结构赋值
    table fuzhi(table t)
    {
    	int i;
    	for (i = 0; i < t.size; i++)
    	{
    		t.head[i] = i + 1;
    		t.length++;//长度随赋值情况增加
    	}
    	return t;
    }
    //输出结构存储情况
    table prt(table t)
    {
    	printf("存储的数据如下:\n");
    	for (int i = 0; i < t.length; i++)
    		printf("%d ", t.head[i]);
    	printf("\n");
    	return t;
    }
    //插入数据
    table insert(table t,int elme,int add)
    {
    	if (t.length == t.size)//如果数据结构已满,增加存储空间
    		t.head= (int *)realloc(t.head, (t.size + 1) * sizeof(int));
    	if (t.head == NULL)
    	{
    		printf("申请存储空间失败!\n");
    		exit(1);
    	}
    	else t.size++;//空间大小增加
    	int i = t.size;
    	for (; i >= elme-1; i--)//数据循环后移
    		t.head[i] = t.head[i - 1];
    	t.head[elme-1] = add;//指定位置插入数据,赋值
    	t.length++;//长度增加
    	return t;
    }
    //删除指定数据
    table deleter(table t, int elme)
    {
    	int i = elme-1;
    	for (; i <= t.size; i++)
    		t.head[i] = t.head[i +1];
    	t.head[i] = 0;
    	t.length--;
    	return t;
    }
    //查询指定数据,返回在数据结构中的位置
    int select(table t, int elme)
    {
    	int i;
    	for (i = 0; i <= t.length; i++)
    	{
    		if (t.head[i] == elme)
    			return i+1;
    	}
    	return -1;
    }
    //替换指定数据
    table tihuan(table t, int elme, int add)
    {
    	int i=select(t,elme);
    	
    		t.head[i-1] = add;
    		return t;
    	
    }
    //主函数
    int main()
    {
    	xinxi();
    	table t = initcreact();
    	t = fuzhi(t);
    	t = prt(t);
    	int elme;
    	printf("请输入插入的位置:");
    	scanf("%d", &elme);
    	int add;
    	printf("请输入插入数据:");
    	scanf("%d", &add);
    	if (elme > t.size+1 || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = insert(t, elme,add);
    	t = prt(t);
    	printf("请输入删除的位置:");
    	scanf("%d", &elme);
    	if (elme > t.size || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = deleter(t, elme);
    	t = prt(t);
    	printf("查找 5 的位置\n");
    	elme = select(t, 5);
    	printf("5 的位置是 %d\n", elme);
    
    	t = prt(t);
    	printf("用 55 替换 5\n");
    	tihuan(t, 5, 55);
    	t = prt(t);
    
    	system("pause");
    	return 0;
    }

     

     

    展开全文
  • //初始化一个空的线性表 Status InitList(SqList *L) { L->pList = (SqList *)malloc(sizeof(SqList)); //申请内存空间 if(L->pList == NULL) { printf("内存空间分配失败!"); } else { L->sqLength = 0; } return ...
  • 初始化顺序表并插入元素
  • C语言顺序表初始化,添加,删除,打印。体现和链表添加,删除的区别。
  • C语言顺序表详解

    2021-02-06 17:28:11
    顺序表代码构思创建文件创建结构体初始化尾插内存扩容尾删打印头插头删任意位置插入任意位置删除解释的不好,最后献上完整代码头文件 SeqList.h 代码源文件 SeqList.c 代码源文件 test.c 代码 顺序表是什么? 顺序表...
  • 通过此程序可以实现顺序表初始化,顺序表创建,顺序表插入元素,顺序表删除元素,判断顺序表是否为空,顺序表查找元素,求顺序表长度,顺序表输出操作。 `#include<stdio.h> #include<malloc.h&...
  • //用顺序表实现堆栈 //包含printf与scanf函数 #include //包含malloc函数 #include //v是分配的内存空间的首地址,m是分配的空间的大小(代表了表的总长),n为表的实际长度 //n的初值较为重要。一定要获得栈顶...
  • 转载-C语言顺序表

    2019-06-16 00:15:34
    文章目录线性表的顺序存储顺序表的线性存储示意图C语言定义线性表的顺序存储结构顺序表的基本操作(1) 顺序表初始化(2)求顺序表的长度(3)按序号查找(4)插入操作(5) 删除操作(6)按内容查找(7)头插(8)头删(9)尾插(10)...
  • C语言顺序表实现

    2021-04-06 17:00:08
    一.顺序表实现(静态分配) #include<stdio.h> #include<...//初始化一个顺序表 void InitList(SqList &L) { L.length = 0; } int main() { //声明一个列表L SqList L; //调用InitList函
  • 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.顺序表的长度,也就是表中存储数据元素
  • 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...
  • 数据结构 C语言描述 第三版 顺序表初始化
  • 伪代码实现,顺序表 #include <stdio.h> #include <stdlib.h> typedef int ElemType;.../*初始化顺序表*/ void InitList(SqList *l) { l->length = 0; }int lnitList_Sq(SqList &L) {
  • <p style="text-align:center"><img alt="" height="779" src="https://img-ask.csdnimg.cn/upload/1612625320372.JPG" width="1674" /></p>   ... 编译时,出现了关于malloc和free的警告,...
  • #include <stdio.h> #include <stdlib.h>... //顺序表的当前长度 }SqList; //顺序表的类型定义 void InitList(SqList *p){ int i; for (i = 0; i < MaxSize; i++) { p->data
  • (1)初始化顺序表L\n");    InitList(H);  printf(" (2)依次插入a,b,c,d,e元素\n");  ListInsert(H,1,'a');  ListInsert(H,2,'b');  List...
  • 顺序表的表示和实现 顺序表的特点: 逻辑上相邻的元素在物理上也是相邻 可以快速计算出任何一个数据元素的存储地址,即访问每个元素所花时间相等 算法实现(C语言) 在这里插入代码片#include<stdio.h> #...
  • 静态分配 头文件 #include<stdio.h> 创 #define MaxSize 10 //定义最大容量 typedef struct //类型重命名 { int data[MaxSize];...void InitList(Sqlist *L) //初始化 { for (int i = 0; i < Ma
  • 顺序表的一些基本操作算法(copy可以直接运行),附上代码: //王道顺序表后面的练习题 #include<stdio.h> #define MaxSize 100 typedef int ElementType;...//顺序表初始化 void init(Seq* L) { L
  • 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表...1.顺序表的建立以及初始化 #include<stdio.h> #define MAXSIZE 255//

空空如也

空空如也

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

c语言顺序表初始化

c语言 订阅