线性表 代码展示

已于 2022-04-18 19:36:34 修改
阅读量263 收藏
点赞数
分类专栏： 算法 文章标签： c++ 链表
于 2022-03-21 16:12:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/one_above_all_/article/details/123638460
版权

1.顺式线性表

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASTABLE -1
#define OVERFLOW -2

typedef int status;
typedef int ElemType; //数据元素类型定义

#define LIST_INIT_SIZE 100
#define LISTINCREMENT  10
typedef struct {  //顺序表（顺序结构）的定义
	ElemType* elem;
	int length;
	int listsize;
}SqList;

status InitList(SqList& L);
status DestroyList(SqList& L);
status ClearList(SqList&L);
status ListEmpty(SqList L);
int ListLength(SqList L);
status GetElem(SqList L,int i,ElemType& e);
int LocateElem(SqList L,ElemType e); //简化过
status PriorElem(SqList L,ElemType cur,ElemType&pre_e);
status NextElem(SqList L,ElemType cur,ElemType&next_e);
status ListInsert(SqList&L,int i,ElemType e);
status ListDelete(SqList& L, int i, ElemType& e);
status ListTrabverse(SqList L);  //简化过
/*--------------------------------------------*/
void main(void) {
	SqList L;  int op = 1, i, r; ElemType e, p;
	while (op) {
		system("cls");	printf("\n\n");
		printf("      Menu for Linear Table On Sequence Structure \n");
		printf("-------------------------------------------------\n");
		printf("    	  1. InitList       7. LocateElem\n");
		printf("    	  2. DestroyList8. PriorElem\n");
		printf("    	  3. ClearList       9. NextElem \n");
		printf("    	  4. ListEmpty     10. ListInsert\n");
		printf("    	  5. ListLength     11. ListDelete\n");
		printf("    	  6. GetElem       12. ListTrabverse\n");
		printf("    	  0. Exit\n");
		printf("-------------------------------------------------\n");
		printf("    请选择你的操作[0~12]:");
		scanf("%d", &op);
		switch (op) {
		case 1:
			//printf("\n----IntiList功能待实现！\n");
			if (InitList(L) == OK) printf("线性表创建成功！\n");
			else printf("线性表创建失败！\n");
			getchar(); getchar();
			break;
		case 2:
			//printf("\n----DestroyList功能待实现！\n");
			if (DestroyList(L) == OK)printf("线性表销毁成功！\n");
			else printf("线性表销毁失败！\n");
			getchar(); getchar();
			break;
		case 3:
			//printf("\n----ClearList功能待实现！\n");
			if (ClearList(L) == OK)printf("线性表重置成功！\n");
			else printf("线性表重置失败！\n");
			getchar(); getchar();
			break;
		case 4:
			//printf("\n----ListEmpty功能待实现！\n");
			if (ListEmpty(L) == 1)printf("线性表为空！\n");
			else if (ListEmpty(L) == 0)printf("线性表不为空！\n");
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 5:
			//printf("\n----ListLength功能待实现！\n");
			if (ListLength(L) >= 0)printf("线性表的长度为：%d\n", ListLength(L));
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 6:
			//printf("\n----GetElem功能待实现！\n");
			printf("请输入待取元素的索引："); scanf("%d", &i); r = GetElem(L, i, e);
			if (r == OK)printf("元素获取成功！\n");
			else if (r == ERROR)printf("索引值越界！\n");
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 7:
			//printf("\n----LocateElem功能待实现！\n");
			printf("请输入想定位的元素："); scanf("%d", &e);
			if (LocateElem(L, e) > 0)printf("该元素位于第%d位。\n", LocateElem(L, e));
			else if (LocateElem(L, e) == 0)printf("该元素不在线性表中！\n");
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 8:
			//printf("\n----PriorElem功能待实现！\n");
			printf("请输入一个元素："); scanf("%d", &e);
			if (PriorElem(L, e, p) == OK)printf("该元素的前驱元素为：%d\n", p);
			else if (PriorElem(L, e, p) == ERROR)printf("该元素无前驱！\n");
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 9:
			//printf("\n----NextElem功能待实现！\n");
			printf("请输入一个元素："); scanf("%d", &e);
			if (NextElem(L, e, p) == OK)printf("该元素的后继元素为：%d\n", p);
			else if (NextElem(L, e, p) == ERROR)printf("该元素无后继！\n");
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 10:
			//printf("\n----ListInsert功能待实现！\n");
			printf("请输入待插入的位置：待插入元素："); scanf("%d %d", &i, &e); r = ListInsert(L, i, e);
			if (r == OK)printf("元素插入成功！\n");
			else if (r == ERROR)printf("索引值越界！\n");
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 11:
			//printf("\n----ListDelete功能待实现！\n");
			printf("请输入待删除元素的索引："); scanf("%d", &i); r = ListDelete(L, i, e);
			if (r == OK)printf("元素删除成功！\n");
			else if (r == ERROR)printf("索引值越界！\n");
			else printf("线性表不存在！\n");
			getchar(); getchar();
			break;
		case 12:
			//printf("\n----ListTrabverse功能待实现！\n");     
			if (!ListTrabverse(L)) printf("线性表是空表！\n");
			getchar(); getchar();
			break;
		case 0:
			break;
		}//end of switch
	}//end of while
	printf("欢迎下次再使用本系统！\n");
}//end of main()
/*--------page 23 on textbook --------------------*/
status InitList(SqList& L) {
	L.elem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));
	if (!L.elem) exit(OVERFLOW);
	L.length = 0;
	L.listsize = LIST_INIT_SIZE;
	return OK;
}
status ListTrabverse(SqList L) {
	int i;
	printf("\n-----------all elements -----------------------\n");
	for (i = 0; i < L.length; i++) printf("%d ", L.elem[i]);
	printf("\n------------------ end ------------------------\n");
	return L.length;
}
status DestroyList(SqList& L)
{
	if (!L.elem)return INFEASTABLE;
	free(L.elem);
	L.elem = NULL;
	L.length = 0;
	L.listsize = 0;
	return OK;
}
status ClearList(SqList& L)
{
	if (L.elem)
	{
		L.length = 0;
		return OK;
	}
	else return INFEASTABLE;
}
status ListEmpty(SqList L)
{
	if (L.elem)
		if (L.length != 0)return FALSE;
		else return TRUE;
	else return INFEASTABLE;
}
int ListLength(SqList L)
{
	if (L.elem)return L.length;
	else return INFEASTABLE;
}
status GetElem(SqList L, int i, ElemType& e)
{
	if (!L.elem)return INFEASTABLE;
	if (i <= 0 || i > L.length)return ERROR;
	e = L.elem[i - 1];
	return OK;
}
int LocateElem(SqList L, ElemType e)
{
	if (!L.elem)return INFEASTABLE;
	for (int i = 0; i < L.length; ++i)
		if (e == L.elem[i])return i + 1;
	return 0;
}
status PriorElem(SqList L, ElemType e, ElemType& pre)
{
	if (!L.elem)return INFEASTABLE;
	for (int i = 0; i < L.length; ++i)
	{
		if (e == L.elem[i] && i == 0)return ERROR;
		else if (e == L.elem[i])
		{
			pre = L.elem[i - 1];
			return OK;
		}
	}
	return ERROR;
}
status NextElem(SqList L, ElemType e, ElemType& next)
{
	if (!L.elem)return INFEASTABLE;
	for (int i = 0; i < L.length - 1; ++i)
		if (e == L.elem[i])
		{
			next = L.elem[i + 1];
			return OK;
		}
	return ERROR;
}
status ListInsert(SqList& L, int i, ElemType e)
{
	ElemType* newbase;
	int* q, * p;
	if (!L.elem)return INFEASTABLE;
	if (i<1 || i>L.length + 1)return ERROR;
	if (L.length >= L.listsize)
	{
		newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase)return ERROR;
		L.elem = newbase;
		L.listsize += LISTINCREMENT;
	}
	q = &(L.elem[i - 1]);
	for (p = &(L.elem[L.length - 1]); p >= q; --p)*(p + 1) = *p;
	*q = e;
	++L.length;
	return OK;
}
status ListDelete(SqList& L, int i, ElemType& e)
{
	if (!L.elem)return INFEASTABLE;
	if (i<1 || i>L.length)return ERROR;
	int* q, * p;
	e = L.elem[i - 1];
	p = &(L.elem[i - 1]), q = L.elem + L.length - 1;
	for (; p < q; ++p)*p = *(p + 1);
	--L.length;
	return OK;
}

2.链式线性表

#define _CRT_SECURE_NO_WARNINGS
/* Linear Table On Sequence Structure */
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

/*---------page 10 on textbook ---------*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int status;
typedef int ElemType; //数据元素类型定义

/*-------page 22 on textbook -------*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT  10
typedef int ElemType;
typedef struct LNode {  //单链表（链式结构）结点的定义
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;
/*-----page 19 on textbook ---------*/
status InitLinkList(LinkList& L);
status DestroyLinkList(LinkList& L);
status ClearLinkList(LinkList& L);
status LinkListEmpty(LinkList L);
int LinkListLength(LinkList L);
status GetElem(LinkList L, int i, ElemType& e);
int LocateElem(LinkList L, ElemType e);
status PriorElem(LinkList L, ElemType e, ElemType& pre);
status NextElem(LinkList L, ElemType e, ElemType& next);
status LinkListInsert(LinkList& L, int i, ElemType e);
status LinkListDelete(LinkList& L, int i, ElemType& e);
status LinkListTraverse(LinkList L);
/*--------------------------------------------*/
int main(void) {
	LinkList L = NULL;  int op = 1, i, r; ElemType e, p;
	while (op) {
		system("cls");	printf("\n\n");
		printf("      Menu for Linear Table On Sequence Structure \n");
		printf("-------------------------------------------------\n");
		printf("    	  1. InitLinkList       7. LocateElem\n");
		printf("    	  2. DestroyLinkList    8. PriorElem\n");
		printf("    	  3. ClearLinkList      9. NextElem \n");
		printf("    	  4. LinkListEmpty      10. LinkListInsert\n");
		printf("    	  5. LinkListLength     11. LinkListDelete\n");
		printf("    	  6. GetElem            12. LinkListTrabverse\n");
		printf("    	  0. Exit\n");
		printf("-------------------------------------------------\n");
		printf("    请选择你的操作[0~12]:");
		scanf("%d", &op);
		switch (op) {
		case 1:
			if (InitLinkList(L) == OK) printf("链表创建成功！\n");
			else printf("链表创建失败！\n");
			getchar(); getchar();
			break;
		case 2:
			if (DestroyLinkList(L) == OK)printf("链表销毁成功！\n");
			else printf("链表销毁失败！\n");
			getchar(); getchar();
			break;
		case 3:
			if (ClearLinkList(L) == OK)printf("链表重置成功！\n");
			else printf("链表重置失败！\n");
			getchar(); getchar();
			break;
		case 4:
			if (LinkListEmpty(L) == 1)printf("链表为空！\n");
			else if (LinkListEmpty(L) == 0)printf("链表不为空！\n");
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 5:
			if (LinkListLength(L) >= 0)printf("链表的长度为：%d\n", LinkListLength(L));
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 6:
			printf("请输入待取元素的索引："); scanf("%d", &i); r = GetElem(L, i, e);
			if (r == OK)printf("元素%d获取成功！\n", e);
			else if (r == ERROR)printf("索引值越界！\n");
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 7:
			printf("请输入想定位的元素："); scanf("%d", &e);
			if (LocateElem(L, e) > 0)printf("该元素位于第%d位。\n", LocateElem(L, e));
			else if (LocateElem(L, e) == 0)printf("该元素不在链表中！\n");
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 8:
			printf("请输入一个元素："); scanf("%d", &e);
			if (PriorElem(L, e, p) == OK)printf("该元素的前驱元素为：%d\n", p);
			else if (PriorElem(L, e, p) == ERROR)printf("该元素无前驱！\n");
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 9:
			printf("请输入一个元素："); scanf("%d", &e);
			if (NextElem(L, e, p) == OK)printf("该元素的后继元素为：%d\n", p);
			else if (NextElem(L, e, p) == ERROR)printf("该元素无后继！\n");
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 10:
			printf("请输入待插入的位置：待插入元素："); scanf("%d %d", &i, &e); r = LinkListInsert(L, i, e);
			if (r == OK)printf("元素插入成功！\n");
			else if (r == ERROR)printf("索引值越界！\n");
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 11:
			printf("请输入待删除元素的索引："); scanf("%d", &i); r = LinkListDelete(L, i, e);
			if (r == OK)printf("元素删除成功！\n");
			else if (r == ERROR)printf("索引值越界！\n");
			else printf("链表不存在！\n");
			getchar(); getchar();
			break;
		case 12:
			if (!LinkListTraverse(L)) printf("链表是空表！\n");
			getchar(); getchar();
			break;
		case 0:
			break;
		}//end of switch
	}//end of while
	printf("欢迎下次再使用本系统！\n");
	return 0;
}//end of main()
/*--------page 23 on textbook --------------------*/
status InitLinkList(LinkList& L)
{
	if (L)return INFEASIBLE;
	else
	{
		LinkList p = (LinkList)malloc(sizeof(LNode));
		p->next = NULL;
		L = p;
		return OK;
	}
}
status LinkListTraverse(LinkList L)
{
	if (!L)return INFEASIBLE;
	else
	{
		if (!L->next)return OK;
		L = L->next;
		printf("-------------------------------------------------\n");
		while (L->next)
		{
			printf("%d ", L->data);
			L = L->next;
		}
		printf("%d\n", L->data);
		printf("-------------------------------------------------\n");
		return OK;
	}
}
status DestroyLinkList(LinkList& L)
{
	if (!L)return INFEASIBLE;
	else
	{
		LNode* p = L;
		while (p)
		{
			p = L->next;
			free(L);
			L = p;
		}
		return OK;
	}
}
status ClearLinkList(LinkList& L)
{
	if (!L)return INFEASIBLE;
	else
	{
		LNode* tail = L->next, * p = tail->next;
		while (p)
		{
			free(tail);
			tail = p;
			p = p->next;
		}
		free(tail);
		L->next = NULL;
		return OK;
	}
}
status LinkListEmpty(LinkList L)
{
	if (!L)return INFEASIBLE;
	else if (L->next == NULL)return TRUE;
	else return FALSE;
}
int LinkListLength(LinkList L)
{
	if (!L)return INFEASIBLE;
	else
	{
		int count = 0;
		LNode* p = L->next;
		while (p)
		{
			++count;
			p = p->next;
		}
		return count;
	}
}
status GetElem(LinkList L, int i, ElemType& e)
{
	if (!L)return INFEASIBLE;
	else if (i <= 0)return ERROR;
	else
	{
		LNode* p = L;
		for (int j = 1; j <= i; ++j)
		{
			if (!p->next)return ERROR;
			p = p->next;
		}
		e = p->data;
		return OK;
	}
}
int LocateElem(LinkList L, ElemType e)
{
	if (!L)return INFEASIBLE;
	else
	{
		LNode* p = L->next;
		for (int i = 1; p; ++i)
		{
			if (p->data == e)return i;
			p = p->next;
		}
		return ERROR;
	}
}
status PriorElem(LinkList L, ElemType e, ElemType& pre)
{
	if (!L)return INFEASIBLE;
	else
	{
		if (!L->next || !L->next->next)return ERROR;
		LNode* p = L->next, * tail = p->next;
		while (tail)
		{
			if (tail->data == e)
			{
				pre = p->data;
				return OK;
			}
			p = tail, tail = tail->next;
		}
		return ERROR;
	}
}
status NextElem(LinkList L, ElemType e, ElemType& next)
{
	if (!L)return INFEASIBLE;
	else
	{
		if (!L->next || !L->next->next)return ERROR;
		LNode* p = L->next, * tail = p->next;
		while (tail)
		{
			if (p->data == e)
			{
				next = tail->data;
				return OK;
			}
			p = tail, tail = tail->next;
		}
		return ERROR;
	}
}
status LinkListInsert(LinkList& L, int i, ElemType e)
{
	if (!L)return INFEASIBLE;
	else if (i <= 0)return ERROR;
	else
	{
		LNode* p = L;
		for (int j = 1; j < i && p; ++j)p = p->next;
		if (!p)return ERROR;
		LNode* temp = (LNode*)malloc(sizeof(LNode));
		temp->data = e, temp->next = p->next;
		p->next = temp;
		return OK;
	}
}
status LinkListDelete(LinkList& L, int i, ElemType& e)
{
	if (!L)return INFEASIBLE;
	else if (i <= 0)return ERROR;
	else
	{
		LNode* p = L;
		for (int j = 1; j < i && p; ++j)
		{
			p = p->next;
		}
		if (!p || !p->next)return ERROR;
		e = p->next->data;
		LNode* temp = p->next->next;
		free(p->next);
		p->next = temp;
		return OK;
	}
}

one_above_all_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——线性表
FREEDOM’s blog
06-08 1044
1.线性表的定义与操作 2.顺序表 3.单链表 4.双链表 5.循环链表 6.静态链表 7.顺序表VS链表
数据结构——线性表代码总结
Acc222222的博客
07-29 2736
1.线性表结构定义 typedef struct { int a[100];//或定义MaxSize int length; }SqList; 其中length记录线性表长度，a是数据域。 2.根据位置i获取相应位置数据元素的内容
线性表详解（附代码）
羽的博客
05-15 2840
文章目录最简单的结构：线性表线性表的概念操作顺序表1、定义顺序表结构2、定义顺序表的操作3、初始化顺序表4、顺序表的长度5、添加节点6、插入节点7、删除节点8、按序号查找节点9、按照关键字查找节点10、遍历顺序表：运用实例： 最简单的结构：线性表 线性表有两种形式： 顺序线性表 链式线性表 线性表的概念 ​ 由若干个数据组成的集合可以看做是一个线性表。线性表中的数据元素之间的关系是一对一，即除了第一个和最后一个元素外，其他元素都是首尾相接的。例如学生的学号组成的数据就是一个线性表。如下图： 20
数据结构——线性表（顺序表）
weixin_42823298的博客
09-26 791
线性表的顺序存储结构又称为顺序表，它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。注：线性表从1开始，而数组从0开始。数组大小有两种方式指定，一是静态分配，二是动态扩展。优点：随机访问特性，查找O(1)时间，存储密度高；逻辑上相邻的元素，物理上也相邻；缺点：插入删除需移动大量元素。顺序表相关的操作跟数组有关，一般都是移动数组元素。
王道_线性表代码合集
LYY_Blog
10-03 821
线性表 线性表的基本操作 InitList(&L) //初始化表，构造一个空的线性表 Length(L) //求表长，返回线性表L长度 LocateElem(L,e) //按值查找操作，在表L中查找具有给定关键字个数 GetElem(L,i) //按位查找操作，在表L中查找第i个位置元素的值 ListInsert(&L,i,e) //插入操作，在表L中第i个位置插入指定元素 ListDelete(&L,i,&e) //删除操作，
数据结构实验1--线性表的操作与实现.doc
06-15
3. 实验结果的展示：我们需要展示实验的结果，包括顺序表和链表的操作结果。 本实验的目的是为了熟练掌握线性表在顺序存储和链式存储结构下的基本操作和简单应用。通过实验，我们可以更好地理解线性表的实现和应用...
数据结构与算法-线性表（完整代码） 定义线性表节点的结构.pdf
04-18
数据结构与算法-线性表（完整代码） 数据结构是计算机科学中的一门重要课程，它研究的是如何组织和存储数据，以便于高效的存取和处理。线性表是数据结构中的一种基本结构，它是由一组排列有序的数据元素组成的集合...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
实验1 线性表 2学时.doc
最新发布
10-10
实验结果的目的是为了展示学生信息管理系统的实现效果，包括系统的界面、功能、性能等方面。 七、思考题 思考题包括： 1. 如果采用顺序表作为存储结构，学生信息如何存储，请给出学生信息的存储结构表示。 2. 你...
数据结构实验一（线性表的操作）c语言
04-25
数据结构实验一（线性表的操作）C语言 在这篇文章中，我们将通过C语言来实现一个线性表的操作实验，包括顺序表...这个实验展示了C语言在实现线性表操作方面的应用，旨在帮助学生更好地理解数据结构的概念和实现方法。
线性表的基本操作
奔跑吧犀牛的博客
12-24 1650
实验目的：了解线性表的基本概念，掌握线性表的两种存储结构——顺序存储和链式存储，掌握在两种存储结构上实现线性表的基本操作，掌握用C上机调试线性表操作的基本方法。 实验内容： a．输入一组整型元素序列，建立线性表。 b．实现该线性表的遍历。 c．在该线性表中查找某一元素,查找成功显示查找元素，否则显示查找失败。 d．在该线性表中删除或插入指定元素。 实验要求：分别采用线性表的两种存储结构（
数据结构--关于线性表插入元素
小小的天有大大的梦想
10-16 4541
#include using namespace std; #define LIST_INIT_SIZE 100 //初始化分配量 #define LISTINCREMENT 10 //存储空间的分配增量 typedef int Status; typedef int ElemType; typedef struct{ ElemType *elem
线性表的顺序显示
nonoiamyoufather的博客
10-17 477
详情注释都有，下次有时间将合并写好一些 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; //----------线性表的动态分配 顺序 存储结构------------- #define LIST_INT_SIZE 100 #define LISTINCREATMENT 10 #define OVERFLOW -2 #define ...
线性表完整代码
weixin_30760895的博客
07-30 5414
顺序存储： #include<stdio.h> #include<stdlib.h> typedef int Position; typedef int ElementType; typedef struct LNode *PtrToLNode; #define MAXSIZE 10 struct LNode{ Elem...
线性表 （一） 线性表定义与线性表插入与删除
qq_44639974的博客
03-02 1231
本文主要通俗地介绍了线性表的特征
C语言代码：线性表的定义与操作--顺序表
柴柴的博客
03-27 496
课程来源于浙江大学MOOC《数据结构与算法》 typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; }; /* 初始化 */ List MakeEmpty() { List L; L = (List)malloc(sizeof...
线性表的代码
Supreme_One的博客
09-22 962
#include using namespace std; class List { public: List(int liang); ~List(); void clearlist(); bool emptylist(); int listlength(); bool getelem(int i,int *e); int locateelem(int *e); bool bef
数据结构-线性表-顺序表的代码详解
飞鸟无痕丶的博客
10-23 1720
数据结构中的一大重点   线性表： 一。顺序表      数据存储是连续的，有多少数据开辟多少储存空间，所以不存在资源浪费      查找速度快，但是在增删数据的时候可能会移动大量数据，所以增删操作速度慢 二。链表    数据存储是离散的，所以数据的存储不连续，无规则，可能存在空间大于数据数目，浪费资源      但是增加跟删除元素的时候不影响其他元素，速度快    根据划分条件不同： ...
【数据结构】线性表|顺序表|（全）测试代码|用C语言/C++实现动态及静态顺序表的定义、插入、删除、查找、打印输出等基本操作
dxy1128的博客
08-12 675
1、静态顺序表的代码 #include<stdio.h> #define Maxsize 10 //定义最大长度 typedef struct { int data[Maxsize]; //定义一个长度为Maxsize的数组用来存放数据元素 int length; //顺序表的当前长度 }SqList; //基本操作——初始化一个顺序表 void InitList(SqList &L) { for (int i = 0;i < Maxsize;i++) {
线性表基本操作展示c语言
04-21
好的，以下是线性表基本操作展示C语言的代码示例： ``` #include <stdio.h> #include <stdlib.h> #define MAXSIZE 10 // 线性表的最大长度 typedef struct { int data[MAXSIZE]; // 存储数据元素 int length; // 线性表长度 } SqList; // 初始化线性表 void InitList(SqList *L) { L->length = 0; } // 插入元素 int ListInsert(SqList *L, int i, int e) { if (i < 1 || i > L->length+1 || L->length == MAXSIZE) { return 0; // 插入位置不合法或线性表已满，插入失败 } for (int j = L->length; j >= i; j--) { L->data[j] = L->data[j-1]; // 将第i个元素及其之后的元素后移 } L->data[i-1] = e; // 在第i个位置插入元素e L->length++; // 线性表长度加1 return 1; // 插入成功 } // 删除元素 int ListDelete(SqList *L, int i) { if (i < 1 || i > L->length) { return 0; // 删除位置不合法，删除失败 } for (int j = i; j < L->length; j++) { L->data[j-1] = L->data[j]; // 将第i个元素及其之后的元素前移 } L->length--; // 线性表长度减1 return 1; // 删除成功 } // 查找元素 int LocateElem(SqList L, int e) { for (int i = 0; i < L.length; i++) { if (L.data[i] == e) { return i+1; // 返回元素的位置 } } return 0; // 没有找到元素，返回0 } // 打印线性表 void PrintList(SqList L) { for (int i = 0; i < L.length; i++) { printf("%d ", L.data[i]); } printf("\n"); } int main() { SqList L; InitList(&L); ListInsert(&L, 1, 1); ListInsert(&L, 2, 2); ListInsert(&L, 3, 3); ListInsert(&L, 4, 4); ListInsert(&L, 5, 5); printf("插入元素后："); PrintList(L); // 输出：1 2 3 4 5 ListDelete(&L, 3); printf("删除元素后："); PrintList(L); // 输出：1 2 4 5 int pos = LocateElem(L, 4); printf("元素4的位置：%d\n", pos); // 输出：3 return 0; } ``` 以上代码实现了线性表的基本操作，包括初始化、插入元素、删除元素、查找元素和输出线性表。可以根据实际需求进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值