数据结构 线性表的基础操作 C/C++代码实现 #1

最新推荐文章于 2024-09-08 10:44:31 发布
最新推荐文章于 2024-09-08 10:44:31 发布
阅读量2.1k 收藏 23
点赞数 3
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Haneee/article/details/103953591
版权

线性表的基础操作

1.创建线性表

2.销毁线性表

3.清空线性表

4.检查线性表是否为空

5.返回线性表的数据元素个数

6.返回线性表中指定位置的元素的值

7.找到符合条件的元素，返回其位置

8.返回线性表中指定元素的前一个元素的位置

9.返回线性表中指定元素的后一个元素的位置

10.在线性表指定位置插入一个元素

11.删除线性表中指定位置的元素

12.遍历线性表

线性表的两种存储结构

1.顺序存储结构

2.链式存储结构

线性表的顺序存储结构C语言实现

首先是结构体：

typedef int elemtype;

typedef struct List1
{
	elemtype* data;
	int lenth;
	int listsize;
}List1,*Plist;

1.创建线性表

//lenth表示线性表最大的存储空间
int InitList1(Plist& list, int lenth)
{
	list = (Plist)malloc(sizeof(List1));
	if (list == NULL )	return 1;
	//如果空间申请失败返回1（当然，基本上不会出现问题）
	list->data = NULL;
	list->data = (elemtype*)malloc(sizeof(elemtype) * lenth);
	if ( list->data == NULL)	return 1;
	//如果空间申请失败返回1（同理）
	list->lenth = 0;
	list->listsize = lenth;
	return 0;
	//正常结束返回0
}

2.销毁线性表

int DestroyList1(Plist& list)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;//如果线性表本身就是不存在返回1
	}
	if((list->data)!=NULL)
		free(list->data);
	free(list);
	list = NULL;
	return 0;
}

3.清空线性表

int ClearList1(Plist& list)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	list->lenth = 0;
	return 0;
}

4.检查线性表是否为空

int List1Empty(Plist& list)
{
	if (list == NULL)	
	{
		printf_s("线性表不存在\n");
		return -1;
	}
	if (list->lenth == 0)	return 1;//线性表为空返回1
	else return 0;//不为空返回0
}

5.返回线性表数据元素的个数

int List1Length(Plist& list)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return -1;
	}
	return list->lenth;
}

6.返回线性表中指定位置的元素的值

//找到指定位置，并将元素的值放入e中
int GetElemList1(Plist& list,int i,elemtype &e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (i >= list->lenth)
	{
		printf_s("该位置没有元素\n");
		return 2;
	}
	e = list->data[i];
	return 0;
}

7.找到符合条件的元素，返回其位置

//自定义比较函数，如果啊a<b返回1
bool compare(elemtype a, elemtype b)
{
	return a < b;
}

//该处知识点涉及——函数指针，很少使用，但是也需要了解
bool (*p)(elemtype a, elemtype b) = compare;

//查找符合条件的元素，并返回
int LocateElemList1(Plist& list, elemtype e, bool (*compare)(elemtype a, elemtype b))
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return -1;
	}
	for (int i = 0; i <= list->lenth; i++)
	{
		if (compare(e, list->data[i]))
		{
			return i;
			//compare 表示如果a<b则为1；结果返回的就是线性表中第一个比e小的数字的位置
		}
	}
	return -2;//没有比e小的数字则返回-2
}

函数指针的用法我会在这篇文章的最后简单调用一下给你们看。

对于顺序结构的线性表来说，查找元素的前驱和后继意义不大，但我还是写上了，不过没有多少注释了，这部分看不看都可以。

8.返回线性表中指定元素的前一个元素的位置

int PriorElem(Plist& list, elemtype cur_e, elemtype& pre_e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth <= 1)
	{
		if (list->lenth == 0)
		{
			printf_s("List is empty\n");
			return 2;
		}
		else if (list->lenth == 1)
		{
			printf_s("Can't find the precursor, because there's only one\n");
			return 3;
		}
	}
	for (int i = 0; i < list->lenth; i++)
	{
		
		if (cur_e == list->data[i])
		{
			if (i != 0)
			{
				pre_e = i - 1;
				return 0;
			}
			else
			{
				printf_s("Can't find the precursor, because it's the first\n");
				return 4;
			}
		}
	}
	printf_s("Can't find the precursor because there's no such element\n");
	return 5;
}

9.返回线性表中指定元素的后一个元素的位置

int NextElem(Plist& list, elemtype cur_e, elemtype& next_e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth <= 1)
	{
		if (list->lenth == 0)
		{
			printf_s("List is empty\n");
			return 2;
		}
		else if (list->lenth == 1)
		{
			printf_s("Can't find the successor, because there's only one\n");
			return 3;
		}
	}
	for (int i = 0; i < list->lenth; i++)
	{

		if (cur_e == list->data[i])
		{
			if (i != list->lenth-1)
			{
				next_e = i + 1;
				return 0;
			}
			else
			{
				printf_s("Can't find the successor, because it's the last one\n");
				return 4;
			}
		}
	}
	printf_s("Can't find the successor because there's no such element\n");
	return 5;
}

10.在线性表指定位置插入一个元素

//指定位置之前插入元素
int List1Insert(Plist& list, int numth, elemtype e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == list->listsize)
	{
		printf_s("线性表已满，无法操作。\n");
		return 2;
	}
	if (numth > list->lenth)
	{
		printf_s("该位置无效，无法操作\n");
		return 3;
	}
	for (int i = list->lenth; i > numth; i--)
	{
		list->data[i] = list->data[i - 1];
	}
	list->data[numth] = e;
	list->lenth++;
	return 0;
}

11.删除线性表中指定位置的元素

int List1Delete(Plist& list, int numth, elemtype &e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == 0)
	{
		printf_s("线性表已满\n");
		return 2;
	}
	if (numth >= list->lenth)
	{
		printf_s("该位置没有元素\n");
		return 3;
	}
	e = list->data[numth];
	for (int i = numth; i < list->lenth-1; i++)
	{
		list->data[i] = list->data[i + 1];
	}
	list->lenth--;
	return 0;
}

12.遍历线性表

void visit(elemtype e)
{
	printf_s("%d ", e);
	return;
}

void (*q)(elemtype a) = visit;

int List1Traverse(Plist& list,void (*visit1)(elemtype a))
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == 0)
	{
		printf_s("线性表为空\n");
		return 2;
	}
	for (int i = 0; i < list->lenth; i++)
	{
		visit1(list->data[i]);
	}
	printf_s("\n");
	return 0;
}

好了，以上为线性表顺序结构的基本操作，为了方便写入，我又写了一个插入的函数，这个函数只会在线性表的最后插入一个元素。

int List1push_back(Plist& list,elemtype e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == list->listsize)
	{
		printf_s("线性表已满，无法操作。\n");
		return 2;
	}
	list->data[list->lenth] = e;
	list->lenth++;
	return 0;
}

前面说过，要给你们看一下函数指针的调用。

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
int main()
{
	Plist l;
	int i;
	InitList1(l, 10);
	for (i = 0; i < 10; i++)
	{
		List1push_back(l, i);
	}
	//q在刚刚已经定义为全局变量
	List1Traverse(l,*q);
	
	return 0;
}

输出结果是 ：0 1 2 3 4 5 6 7 8 9 \n

呼，好多啊。昨天写了一天，今天又整理了一上午，但感觉还是很值的，函数指针也是在整理复习的时候才知道。C语言很多地方确实没有C++好用，但是没办法，大家多数最开始的时候学的都是C语言，所以我先写了C语言的顺序表操作。

这一篇就写这一部分吧，下一篇会写C语言的链表实现。

对了，放一下总代码：

#include<stdio.h>
#include<stdlib.h>
#include<Windows.h>
#include<malloc.h>

typedef int elemtype;

typedef struct List1
{
	elemtype* data;
	int lenth;
	int listsize;
}List1,*Plist;

int InitList1(Plist& list, int lenth)
{
	list = (Plist)malloc(sizeof(List1));
	if (list == NULL )	return 1;
	list->data = NULL;
	list->data = (elemtype*)malloc(sizeof(elemtype) * lenth);
	if ( list->data == NULL)	return 1;
	list->lenth = 0;
	list->listsize = lenth;
	return 0;
}

int DestroyList1(Plist& list)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if((list->data)!=NULL)
		free(list->data);
	free(list);
	list = NULL;
	return 0;
}

int ClearList1(Plist& list)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return -1;
	}
	list->lenth = 0;
	return 0;
}

int List1Empty(Plist& list)
{
	if (list == NULL)	
	{
		printf_s("线性表不存在\n");
		return -1;
	}
	if (list->lenth == 0)	return 1;
	else return 0;
}

int List1Length(Plist& list)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		exit(-1);
	}
	return list->lenth;
}

int GetElemList1(Plist& list,int i,elemtype &e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (i >= list->lenth)
	{
		printf_s("Out of list range\n");
		return 2;
	}
	e = list->data[i];
	return 0;
}
bool compare(elemtype a, elemtype b)
{
	return a < b;
}

bool (*p)(elemtype a, elemtype b) = compare;

int LocateElemList1(Plist& list, elemtype e, bool (*compare)(elemtype a, elemtype b))
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	for (int i = 0; i <= list->lenth; i++)
	{
		if (compare(e, list->data[i]))
		{
			return i;//compare 表示如果a>b则为1；结果返回的就是线性表中第一个比e小的数字的位置
		}
	}
	return -1;//没有比e小的数字则返回-1；
}


int PriorElem(Plist& list, elemtype cur_e, elemtype& pre_e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth <= 1)
	{
		if (list->lenth == 0)
		{
			printf_s("List is empty\n");
			return 2;
		}
		else if (list->lenth == 1)
		{
			printf_s("Can't find the precursor, because there's only one\n");
			return 3;
		}
	}
	for (int i = 0; i < list->lenth; i++)
	{
		
		if (cur_e == list->data[i])
		{
			if (i != 0)
			{
				pre_e = i - 1;
				return 0;
			}
			else
			{
				printf_s("Can't find the precursor, because it's the first\n");
				return 4;
			}
		}
	}
	printf_s("Can't find the precursor because there's no such element\n");
	return 5;
}

int NextElem(Plist& list, elemtype cur_e, elemtype& next_e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth <= 1)
	{
		if (list->lenth == 0)
		{
			printf_s("List is empty\n");
			return 2;
		}
		else if (list->lenth == 1)
		{
			printf_s("Can't find the successor, because there's only one\n");
			return 3;
		}
	}
	for (int i = 0; i < list->lenth; i++)
	{

		if (cur_e == list->data[i])
		{
			if (i != list->lenth-1)
			{
				next_e = i + 1;
				return 0;
			}
			else
			{
				printf_s("Can't find the successor, because it's the last one\n");
				return 4;
			}
		}
	}
	printf_s("Can't find the successor because there's no such element\n");
	return 5;
}

int List1Insert(Plist& list, int numth, elemtype e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == list->listsize)
	{
		printf_s("线性表已满，无法操作。\n");
		return 2;
	}
	if (numth > list->lenth)
	{
		printf_s("The location is not valid\n");
		return 3;
	}
	for (int i = list->lenth; i > numth; i--)
	{
		list->data[i] = list->data[i - 1];
	}
	list->data[numth] = e;
	list->lenth++;
	return 0;
}

int List1Delete(Plist& list, int numth, elemtype &e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == 0)
	{
		printf_s("The list is empty\n");
		return 2;
	}
	if (numth >= list->lenth)
	{
		printf_s("The location is not valid\n");
		return 3;
	}
	e = list->data[numth];
	for (int i = numth; i < list->lenth-1; i++)
	{
		list->data[i] = list->data[i + 1];
	}
	list->lenth--;
	return 0;
}

void visit(elemtype e)
{
	printf_s("%d ", e);
	return;
}

void (*q)(elemtype a) = visit;

int List1Traverse(Plist& list,void (*visit1)(elemtype a))
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == 0)
	{
		printf_s("The list is empty\n");
		return 2;
	}
	for (int i = 0; i < list->lenth; i++)
	{
		visit1(list->data[i]);
	}
	printf_s("\n");
	return 0;
}

int List1push_back(Plist& list,elemtype e)
{
	if (list == NULL)
	{
		printf_s("线性表不存在\n");
		return 1;
	}
	if (list->lenth == list->listsize)
	{
		printf_s("线性表已满，无法操作。\n");
		return 2;
	}
	list->data[list->lenth] = e;
	list->lenth++;
	return 0;
}

int print(Plist &l)
{
	int List1Traverse(Plist & l, void(*visit)(elemtype a));
	List1Traverse(l,*q);
	if (l != NULL)
		printf_s("链表长度为：%d\n", l->lenth);
	return 0;
}
int menu(Plist L)
{
	int print(Plist &L);
	printf_s("=====线性表C语言实现=====\n");
	printf_s("1.创建表		2.删除表\n");
	printf_s("3.初始化表		4.插入元素\n");
	printf_s("5.删除元素		\n");
	printf_s("=====线性表C语言实现=====\n");
	print(L);
	return 0;
}

int main()
{
	int n,a,b;
	Plist L=NULL;
	menu(L);
	while (scanf_s("%d", &n) != EOF)
	{
		switch (n)
		{
		case 1: 
			if (L == NULL)
		{
			
			printf_s("请输入链表的最大长度：");
			scanf_s("%d", &a);
			a=InitList1(L, a);
			if (a == 0)
			{
				printf_s("创建成功，正在返回主菜单\n");
				Sleep(1000);
				system("cls");
				break;
			}
			else 
			{
				printf_s("创建失败，空间申请失败，正在返回主菜单\n");
				break;
			}
		}
			else 
		{
			printf_s("操作失败！线性表已经存在！即将返回主菜单！\n");
			Sleep(1000);
			system("cls");
			break;
		}
		case 2: 
			a=DestroyList1(L);
			if(a==0)
				printf_s("操作成功，即将返回主菜单！\n");
			Sleep(1000);
			system("cls");
			break;
		case 3:
			if (L != NULL)
			{
				printf_s("请输入初始化的数目：");
				scanf_s("%d", &a);
				L->lenth = 0;
				printf_s("请输入初始化的数组：");
				for (int i = 0; i < a; i++)
				{
					scanf_s("%d", &b);
					List1push_back(L, b);
				}
				printf_s("操作成功，即将返回主菜单！\n");
			}
			else printf_s("操作失败，链表不存在，即将返回主菜单！\n");
			Sleep(1000);
			system("cls");
			break;
		case 4:
			if (L != NULL)
			{
				printf_s("请输入插入元素位置和元素值：");
				scanf_s("%d%d", &a, &b);
				a = List1Insert(L, a, b);
				if (a == 0)
					printf_s("操作成功，即将返回主菜单！\n");
			}
			else printf_s("操作失败，链表不存在，即将返回主菜单！\n");
			Sleep(1000);
			system("cls");
			break;
		case 5:
			if (L != NULL)
			{
				printf_s("请输入删除元素的位置：");
				scanf_s("%d", &a);
				a = List1Delete(L, a, b);
				printf_s("删除元素的值为%d\n", b);
				if (a == 0)
					printf_s("操作成功，即将返回主菜单！\n");
			}
			else  printf_s("操作失败，链表不存在，即将返回主菜单！\n");
			Sleep(1000);
			system("cls");
			break;

		default:
			printf_s("输入有误，请重新输入！");
			Sleep(1000);
			system("cls");
			break;
		}
		menu(L);
	}

}

#if 0
int main()
{
	Plist l;
	InitList1(l, 10);
	for (int i = 0; i < 10; i++)
	{
		List1push_back(l, i);
	}
	List1Traverse(l,*q);
	
	return 0;
}
#endif
Coder42
关注
专栏目录
c/c++数据结构-线性表-顺序表
04-26
数据结构实验中线性表的顺序表代码，带有详细注释，小白也能看得懂
线性表 c++语言代码,《数据结构之线性篇》-线性表的C++实现
weixin_29310853的博客
05-22 295
#pragma once#ifndef _LIST_H_#define _LIST_H_#includeusing namespace std;templateclass List{public:List(int size);~List();void ClearList();bool isEmpty();//检测线性表是否为空int ListLength();//获取线性表的长度bool GetE...
2021-11-04
weixin_46216059的博客
11-04 324
线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。 例如：LOC(ai) = LOC(a1) + L 式中，LOC(ai)表示线性表中第i个元素的存储位置，L表示每个元素需占用L个存储单元，LOC(a1)是线性表中第一个数据元素的存储位置且被称为线性表的起始位置或基地址。 线性表的这种机内表示称做线性表的顺序存储结构或顺序映像，通常，称这种存储结构的线性表为顺序表。它的特点是，为表中相邻的元素 ai 和 a(i+1) 赋以相邻的存储位置 LOC(ai) 和 LOC[a(i+1)] 。
线性表的创建，添加，修改，清空，销毁，获得元素位置，前驱，后继--C指针链表
weixin_45661800的博客
09-27 4285
#include <iostream> #include "stdio.h" #define LIST_INIT_SIZE 10 typedef int ElemType;//可以更改线性表元素的类型 typedef struct { int* elem; //指向已分配的一片连续储存空间 int lengh; //线性表中已添加的数据元素个数 int listsize;//线性表中最多能储存的数据元素个数 }SqList; int InitList(SqLis.
C语言创建线性表的基本操作_建立、插入、删除、清空、销毁（操作结构体）
Cris_7的博客
02-17 6759
#include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; #include &amp;amp;lt;string.h&amp;amp;gt; typedef struct node { void **Array; int size; int capacity; }nodes; typedef struct info {
线性表中常见的插入与删除操作
最新发布
2301_79706485的博客
09-08 587
线性表中最重要的操作就是插入与删除操作了，但因为线性表中物理存储结构的多样性，导致我们经常精神错乱，今天我们就对其中的插入与删除操作进行总结一下。
线性表-顺序表删除元素的一些基本操作
m0_74776728的博客
10-19 1545
一、包含两行，第一行为顺序表的最小值，第二行为顺序表中的所有元素（没有为空），输入包含三行，第一行是顺序表元素个数。输出一行：为顺序表中的所有元素（没有为空）。二、若顺序表为空，则输出“Data Error”。输出一行：为顺序表中的所有元素（没有为空）。输出一行：为顺序表中的所有元素（没有为空）。输入包含两行，第一行是顺序表元素个数。输入包含三行，第一行是顺序表元素个数。输入包含两行，第一行是顺序表元素个数。个元素，最后一行是待删的元素。，接下来1行是顺序表中的。，第二行是顺序表中的。
数据结构——线性表顺序存储结构（C++代码）
09-28
线性表是数据结构中最基础且重要的概念之一，它是由n（n≥0）个相同类型元素构成的有限序列。顺序存储结构则是线性表的一种常见实现方式，它将线性表中的元素按照一定的顺序存放在一块连续的内存区域中。这种存储...
王道计算机考研数据结构线性表代码
10-03
王道计算机考研数据结构线性表代码 顺序表 单链表 双链表 循环链表 静态链表 带头节点和不带头节点链表的初始化 链表的节点增加、删除节点、销毁链表、双链表正向打印逆向打印！ 静态链表的初始化以及插入操作
SqLis.rar_数据结构_C/C++_
08-12
3. **C/C++实现**：展示如何用C或C++定义一个数组来表示线性表，包括定义数据结构（如结构体）和编写相关的操作函数，例如初始化线性表、插入元素、删除元素、查找元素等。 4. **数组动态扩展**：由于静态数组的...
数据结构之线性表基础与实现c++
04-05
在深入讨论标题“数据结构之线性表基础与实现c++”和描述“数据结构的线性表读书笔记，分别用代码实现了基于数组、malloc、链表、模板类的线性表”中涉及的知识点之前，需要先理解线性表在数据结构中的基本概念。...
个人笔记--线性表的基本操作（插入、删除、查找...）
Lzh4792的博客
10-22 2609
线性表的一些基本操作 这里只介绍以下操作 1----初始化 2----销毁线性表 3----清空线性表 4----判断线性表是否为空 5----求线性表长度 6----获取线性表中指定位置的元素 7----获取线性表元素的位置 8----求前驱 9----求后继 10----在线性表指定位置插入元素 11----删除线性表指定位置的元素 12----显示线性表 13----合并两个非递减有序的线性表 ------------------------------------------------------
【数据结构线性表 C/C++】顺序表的操作（初始化，删除，增加，求表长，判空，查找，初始化，清空，销毁）
beiqianqian的博客
07-02 2472
【数据结构线性表 C/C++】顺序表的操作（初始化，删除，增加，求表长，判空，查找，初始化，清空，销毁）
【C++数据结构与算法基础篇 -1】C++实现线性表的插入、删除、查找等操作
2301_76761656的博客
11-09 1129
实现线性表的插入、删除、求表长、查找给定值 e、查找第 i 个位置元素等基本操作，要求编写的程序以菜单方式工作；用链式存储结构实现一元多项式的相加运算；利用双向链表实现通讯录的建立、删除、检索和列表，并可保存至文件，可重新装入
线性表操作（增删改查清空）
壑壑哒的博客
11-16 3250
头插法创建链表  代码  #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define ERROR -1 typedef int Status; typedef int ElemType; typedef struct Lnode { ElemType data; struct Lnode *...
c++数据结构--线性表
geo436872的博客
04-09 293
这几天正好在讲数据结构，把实验代码记录一下。
【数据结构】线性表相关操作（C++实现）
passer__jw767的博客
08-28 890
线性表相关操作实现：InitList、ListEmpty、ClearList、GetElem、LocateElem、ListInsert、ListDelete、ListLength
线性表的基本操作
Toss_coppt的博客
02-22 1万+
在粗略学习一遍数据结构之后，压根就没有搞懂其中的逻辑，后来了明白学习数据结构的重要性，打算再利用一大段空闲时间重新拾起数据结构的学习。还站在IT行业门口的我，打算一步一步爬进去，跪着欣赏大佬的笔记和心得。对于数据结构初学者们来说，可能对你们有所帮助，如果有幸得到大佬的指点，也是在下吉人天相啊。 线性表的一些基本操作（同时补充下部分功能实现的逻辑和原理）： 构造线性表结构-----相当于C语言中的结构体，把实例的结构抽取、打框、定义类型、限制范围，最后取上别名 初始化线性表-----对定...
线性表的实现（C语言版）——详细代码
热门推荐
m0_63285686的博客
01-09 1万+
基于C语言实现的线性表（顺序表），在Devc++上进行了顺序表的增删改查基本操作的实现（附详细代码），本文介绍一下自己动手过程中的一些心得和这些代码的内容。提示：以下是本篇文章正文内容，下面案例可供参考#include //malloc()、free()和exit()函数在这个头文件之中int *data;//存放存储空间首地址的指针变量int length;//线性表当前的元素个数//线性表最大能存储的元素个数}Sqlist;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值