抽象数据类型线性表（顺序表）的定义构造

最新推荐文章于 2021-05-24 00:58:15 发布
最新推荐文章于 2021-05-24 00:58:15 发布
阅读量1.8k 收藏 23
点赞数 3
分类专栏： 数据结构（C语言版）严蔚敏 吴伟民 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AKK188888881/article/details/107236903
版权

抽象数据类型线性表（顺序表）的定义构造

main.cpp

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

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

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef int Status;

typedef struct
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;

Status InitList(SqList& L);//InitList
Status DestroyList(SqList& L);//DestroyList
Status ClearList(SqList& L);//ClearList
Status ListEmpty(SqList& L);//ListEmpty
Status ListLength(SqList& L);//ListLength
Status GetElem(SqList& L, int i, int& e);//GetElem
Status compare(ElemType a, ElemType b);//compare
Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));//LocateElem
Status PriorElem(SqList L, int cur_e, int &pre_e);//PriorElem
Status NextElem(SqList L, int cur_e, int& next_e);//NextElem
Status ListInsert(SqList& L, int i, ElemType e);//ListInsert
Status ListDelete(SqList& L,int i,ElemType& e);//ListDelete
Status visit(SqList& L);//visit
Status ListTraverse(SqList& L, Status(*p)(int, SqList));//ListTraverse
void output(SqList& L);//output

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;
}//InitList

Status DestroyList(SqList& L)
{
	free(&L);
	return OK;
}//DestroyList

Status ClearList(SqList& L)
{
	free(L.elem);//释放指针L.elem指向的内存，但是指针L.elem指向的地址还是不变，指向的是顺序表的第一个元素的节点
	//动态指针是在堆上维护的，动态指针定义后，程序为指针分配了一块内存，而且保证这块内存不会被其他乱七八糟的东西修改。
	//free或者delete的时候，是放弃了指针对这个内存的占用，放弃之后，内存的值（顺序表的第一个元素的节点的值）会改写成随机值。
	L.elem = NULL;//使顺序表的指针L.elem，使指针L.elem指向NULL（即0），防止产生野指针，避免误访问没有使用权的指针
	//野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
	L.length = 0;
	return OK;
}//ClearList

Status ListEmpty(SqList& L)
{
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}//ListEmpty

Status ListLength(SqList& L)
{
	return L.length;
}//ListLength

Status GetElem(SqList& L, int i, int& e)
{
	int j;
	for (j = 0; j < ListLength(L); j++)//遍历顺序表L
	{
		if (j == i)//用j定位i 
		{
			e = L.elem[j];//把L中第j个，也就是第i个数据元素的值赋值给整数e 
			return e;
			break;
		}
	}
	return ERROR;
}//GetElem

Status compare(ElemType a, ElemType b)
{
	if (a == b)
		return OK;
	else
		return ERROR;
}//compare

Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	int i = 0;
	ElemType *p = L.elem;
	while (i <= (L.length - 1) && !(*compare)(*p++, e))
		++i;
	if (i <= L.length - 1)
	{
		if (i == 0)
			return TRUE;//和else其他这种情况做个区分 
		else
			return i;
	}
	else
		return 0;
}//LocateElem

Status PriorElem(SqList L, int cur_e, int &pre_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != 0 && cur_e == L.elem[i])
		{
			judge = 1;
			pre_e = L.elem[i - 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return pre_e;
}//PriorElem

Status NextElem(SqList L, int cur_e, int& next_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != ListLength(L) - 1 && cur_e == L.elem[i])
		{
			judge = 1;
			next_e = L.elem[i + 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return next_e;
}//NextElem

Status ListInsert(SqList& L, int i, ElemType e)//在元素第i个（0<=i<=n-1）之前插入一个数据元素 ，和第n-1个元素之后插入一个数据元素 
{
	if (i<0 || i>L.length)
		return ERROR;
	if (L.length >= L.listsize)
	{
		ElemType* newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase)
			exit(OVERFLOW);
		L.elem = newbase;
		L.listsize += LISTINCREMENT;
	}

	ElemType* q = &(L.elem[i]);
	for (ElemType *p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;
	*q = e;
	++L.length;
	return OK;
}//ListInsert

Status ListDelete(SqList& L,int i,ElemType& e)
{
	if ((i<0)|| (i>ListLength(L) - 1))
		return ERROR;
	ElemType* p=&(L.elem[i]);
	e=*p;
	ElemType* q=L.elem+L.length-1;
	for(++p;p<=q;++p)
		*(p-1)=*p;
	--L.length;
	return OK;
}//ListDelete

Status visit(int i, SqList L)
{
	if (L.elem[i] != NULL)
		return OK;
	else
		return ERROR;
}//visit

Status ListTraverse(SqList& L, Status(*p)(int, SqList))
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		visit(i, L);
		if (visit(i, L) == 1)
			return OK;
		else
			return ERROR;
	}
	return ERROR;
}//ListTraverse

void output(SqList& L)
{
	int i;
	printf("Result:");
	for (i = 0; i < ListLength(L); i++)
		printf("%d ", L.elem[i]);
	printf("\n");
}//output


int main()
{
	SqList *Li = (SqList*)malloc(sizeof(SqList));
	printf("InitList Li Status: %d\n", InitList(*Li));
	int a = 5;//随便设一个 
	int i, n, *r = &a;
	printf("Enter List Li Length: ");
	scanf("%d", &n);
	printf("Enter %d numbers: ", n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &Li->elem[i]);
		Li->length++;
	}

	printf("ListLength: %d\n", ListLength(*Li));
	printf("ListEmpty Status: %d\n", ListEmpty(*Li));
	printf("GetElem: %d\n", GetElem(*Li, 3, *r));//此时e是8，即*r是8 
	printf("LocateElem: %d\n", LocateElem(*Li, 6, compare));//此时e是6 
	printf("PriorElem %d\n", PriorElem(*Li, 6, *r));//此时pre_e是10，即*r是10 
	printf("NextElem: %d\n", NextElem(*Li, 6, *r));//此时next_e是8，即*e是8 
	printf("ListInsert Status: %d\n", ListInsert(*Li, 1, 15));//在i=1的位置之前插入一个数字15 
	output(*Li);
	printf("ListDelete Status: %d\n", ListDelete(*Li, 2, *r));//删除i=2位置上的元素的值 
	output(*Li);
	printf("ListTraverse Status: %d\n", ListTraverse(*Li, visit));
	output(*Li);
	printf("ClearList Status: %d\n", ClearList(*Li));
	output(*Li);
	printf("ListEmpty Status: %d\n", ListEmpty(*Li));
	output(*Li);
	printf("DestroyList Status: %d\n", DestroyList(*Li));
//	output(*Li);//线性表销毁，不要再输出此线性表 
	return 0;
}

在这里插入图片描述

在VS2019下，需将源文件的scanf改为scanf_s：

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

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

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef int Status;

typedef struct
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;

Status InitList(SqList& L);//InitList
Status DestroyList(SqList& L);//DestroyList
Status ClearList(SqList& L);//ClearList
Status ListEmpty(SqList& L);//ListEmpty
Status ListLength(SqList& L);//ListLength
Status GetElem(SqList& L, int i, int& e);//GetElem
Status compare(ElemType a, ElemType b);//compare
Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));//LocateElem
Status PriorElem(SqList L, int cur_e, int& pre_e);//PriorElem
Status NextElem(SqList L, int cur_e, int& next_e);//NextElem
Status ListInsert(SqList& L, int i, ElemType e);//ListInsert
Status ListDelete(SqList& L, int i, ElemType& e);//ListDelete
Status visit(SqList& L);//visit
Status ListTraverse(SqList& L, Status(*p)(int, SqList));//ListTraverse
void output(SqList& L);//output

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;
}//InitList

Status DestroyList(SqList& L)
{
	free(&L);
	return OK;
}//DestroyList

Status ClearList(SqList& L)
{
	free(L.elem);//释放指针L.elem指向的内存，但是指针L.elem指向的地址还是不变，指向的是顺序表的第一个元素的节点
	//动态指针是在堆上维护的，动态指针定义后，程序为指针分配了一块内存，而且保证这块内存不会被其他乱七八糟的东西修改。
	//free或者delete的时候，是放弃了指针对这个内存的占用，放弃之后，内存的值（顺序表的第一个元素的节点的值）会改写成随机值。
	L.elem = NULL;//使顺序表的指针L.elem，使指针L.elem指向NULL（即0），防止产生野指针，避免误访问没有使用权的指针
	//野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
	L.length = 0;
	return OK;
}//ClearList

Status ListEmpty(SqList& L)
{
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}//ListEmpty

Status ListLength(SqList& L)
{
	return L.length;
}//ListLength

Status GetElem(SqList& L, int i, int& e)
{
	int j;
	for (j = 0; j < ListLength(L); j++)//遍历顺序表L
	{
		if (j == i)//用j定位i 
		{
			e = L.elem[j];//把L中第j个，也就是第i个数据元素的值赋值给整数e 
			return e;
			break;
		}
	}
	return ERROR;
}//GetElem

Status compare(ElemType a, ElemType b)
{
	if (a == b)
		return OK;
	else
		return ERROR;
}//compare

Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	int i = 0;
	ElemType* p = L.elem;
	while (i <= (L.length - 1) && !(*compare)(*p++, e))
		++i;
	if (i <= L.length - 1)
	{
		if (i == 0)
			return TRUE;//和else其他这种情况做个区分 
		else
			return i;
	}
	else
		return 0;
}//LocateElem

Status PriorElem(SqList L, int cur_e, int& pre_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != 0 && cur_e == L.elem[i])
		{
			judge = 1;
			pre_e = L.elem[i - 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return pre_e;
}//PriorElem

Status NextElem(SqList L, int cur_e, int& next_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != ListLength(L) - 1 && cur_e == L.elem[i])
		{
			judge = 1;
			next_e = L.elem[i + 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return next_e;
}//NextElem

Status ListInsert(SqList& L, int i, ElemType e)//在元素第i个（0<=i<=n-1）之前插入一个数据元素 ，和第n-1个元素之后插入一个数据元素 
{
	if (i<0 || i>L.length)
		return ERROR;
	if (L.length >= L.listsize)
	{
		ElemType* newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase)
			exit(OVERFLOW);
		L.elem = newbase;
		L.listsize += LISTINCREMENT;
	}

	ElemType* q = &(L.elem[i]);
	for (ElemType* p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;
	*q = e;
	++L.length;
	return OK;
}//ListInsert

Status ListDelete(SqList& L, int i, ElemType& e)
{
	if ((i < 0) || (i > ListLength(L) - 1))
		return ERROR;
	ElemType* p = &(L.elem[i]);
	e = *p;
	ElemType* q = L.elem + L.length - 1;
	for (++p; p <= q; ++p)
		*(p - 1) = *p;
	--L.length;
	return OK;
}//ListDelete

Status visit(int i, SqList L)
{
	if (L.elem[i] != NULL)
		return OK;
	else
		return ERROR;
}//visit

Status ListTraverse(SqList& L, Status(*p)(int, SqList))
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		visit(i, L);
		if (visit(i, L) == 1)
			return OK;
		else
			return ERROR;
	}
	return ERROR;
}//ListTraverse

void output(SqList& L)
{
	int i;
	printf("Result:");
	for (i = 0; i < ListLength(L); i++)
		printf("%d ", L.elem[i]);
	printf("\n");
}//output


int main()
{
	SqList* Li = (SqList*)malloc(sizeof(SqList));
	printf("InitList Li Status: %d\n", InitList(*Li));
	int a = 5;//随便设一个 
	int i, n, * r = &a;
	printf("Enter List Li Length: ");
	scanf_s("%d", &n);
	printf("Enter %d numbers: ", n);
	for (i = 0; i < n; i++)
	{
		scanf_s("%d", &Li->elem[i]);
		Li->length++;
	}

	printf("ListLength: %d\n", ListLength(*Li));
	printf("ListEmpty Status: %d\n", ListEmpty(*Li));
	printf("GetElem: %d\n", GetElem(*Li, 3, *r));//此时e是8，即*r是8 
	printf("LocateElem: %d\n", LocateElem(*Li, 6, compare));//此时e是6 
	printf("PriorElem %d\n", PriorElem(*Li, 6, *r));//此时pre_e是10，即*r是10 
	printf("NextElem: %d\n", NextElem(*Li, 6, *r));//此时next_e是8，即*e是8 
	printf("ListInsert Status: %d\n", ListInsert(*Li, 1, 15));//在i=1的位置之前插入一个数字15 
	output(*Li);
	printf("ListDelete Status: %d\n", ListDelete(*Li, 2, *r));//删除i=2位置上的元素的值 
	output(*Li);
	printf("ListTraverse Status: %d\n", ListTraverse(*Li, visit));
	output(*Li);
	printf("ClearList Status: %d\n", ClearList(*Li));
	output(*Li);
	printf("ListEmpty Status: %d\n", ListEmpty(*Li));
	output(*Li);
	printf("DestroyList Status: %d\n", DestroyList(*Li));
	//	output(*Li);//线性表销毁，不要再输出此线性表 
	return 0;
}
AKK188888881
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验一顺序表的抽象数据类型的实现
m0_57124079的博客
04-13 1328
顺序表的抽象数据类型的实现 （插入、删除、查找、倒置、合并、交集）
数据结构(Java版)线性表1(顺序表).ppt
11-15
线性表的抽象数据类型是指线性表的数据元素集合和该数据元素集合上操作的集合。线性表的数据元素集合可以表示为序列 a0，a1，… ai，ai+1… an-1，每个数据元素可以是任意类型的。在 Java 中，可以用类定义数据元素...
设计练习 线性表（顺序表）的抽象数据类型定义构造
Made in Code
06-17 1904
数据结构（C语言版） 严蔚敏 吴伟民 设计练习 线性表的定义构造 代码块： #include <stdio.h> #include <stdlib.h> //Function result status code #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASALBE -1 #define OVERFLOW -2 //Status is the type of function
作业3-线性表抽象数据类型定义与顺序表操作
weixin_46047462的博客
12-11 599
判断题 1-1 对于顺序存储的长度为N的线性表，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。（T） 提示：访问直接根据结点位置，增加需要后移 1-2 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用顺序表存储最节省时间。（T） 1-3 对于顺序存储的长度为N的线性表，删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。（F） 1-4 (neuDS)在顺序表中逻辑上相邻的元素，其对应的物理位置也是相邻的。 （T） 1-5 (neuDS)
抽象数据类型之表（List）
Ctios的博客
11-25 1559
抽象数据类型之表（List）什么是抽象数据类型抽象数据类型（ADT)是一些操作的集合 数学的抽象 数据上的抽象 程序上的抽象 表ADT表的定义：ADT List { Data object：D = {ai | ai∈Elemset, (i=1,2,…,n, n≥0)} Data relationshis：R1 = {＜ai-1,ai＞|ai-1,ai ∈D, (i=2,3,…,n)
线性表抽象数据类型定义与顺序表操作
qq_45591813的博客
11-28 1415
作业3-线性表抽象数据类型定义与顺序表操作 1-1 对于顺序存储的长度为N的线性表， 访问结点和增加结点的时间复杂度 分别对应为O(1)和O(N)。(T) [解析]增加结点,不同位置复杂度不同,但平均复杂度在O(N) 1-2 若某线性表最常用的操作是 存取任一指定序号的元素和在最后进行插入和删除运算， 则利用顺序表存储最节省时间。(T) [解析]顺序表的一个很大的缺点就是增删结点需要移动, 但是此题只在表的末尾插入和删除,不需要移动,访问任意指定序号 的元素用顺序表更方便 1-3 对于顺序存储的长度为N的线
数据结构课件-线性表顺序表.ppt
09-28
线性表的抽象数据类型（ADT）定义了它的数据对象、数据关系以及一组基本操作。数据对象 L 是由元素集合构成的，数据关系 R 描述了元素之间的前后关系。基本操作包括构造空表、销毁线性表、清空表、求长度、取指定...
数据结构课件：第2章 线性表0顺序.pptx
05-31
4. **线性表的抽象数据类型（ADT）**：在计算机科学中，线性表的抽象数据类型定义了一组操作，如构造空表（InitList）、销毁表（DestroyList）、清空表（ClearList）、获取元素（GetElem）、设置元素（PutElem）、...
抽象数据类型与面向对象概念.pptx
09-23
抽象数据类型可以是基本数据类型，如整型、浮点型等，也可以是构造数据类型，如数组、链表等。 面向对象概念是指一种编程范式，强调将数据和操作封装在一起，以提高代码的可读性和维护性。面向对象概念包括类、对象...
数据结构（C#）第二章线性表ppt
05-09
本文将深入探讨线性表的定义、抽象数据类型描述以及顺序存储结构。 线性表（Linear List）是由相同特性的数据元素组成的一个有序集合。在非空线性表中，每个元素都有其确定的位置，如第一个元素被称为表头元素，...
数据结构 顺序表 （c++实现）代码讲解
09-27
这是讲解代码中函数关系的Keynote 为了大家方便，已转换为ppt 博客地址blog.csdn.net/u012350104
c语言 线性表抽象数据类型定义，存储结构，应用
10-04
线性表的讲解，分析。 线性表的抽象数据类型定义 线性表的存储结构 线性表的应用
数据结构#include
01-05
#include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; #include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList;
抽象数据类型线性表的定义—评论为顺序表
chenzhen1213的专栏
03-17 1792
ADT List { InitList (&L);//构造一个空线性表L DestroyList(&L);//销毁已存在的空线性表L ClearList(&L);//将L重置为空表 ListEmpty(L);//判断若存在的表L为空表，返回TRUE，否则返回FALSE Listlength(L);//返回已存在线性表L中的数据元素个数 GetElem(L,i,&e);//用e返回L中第
线性表的抽象数据类型
weixin_30564901的博客
05-10 236
线性表的抽象数据类型 线性表的抽象数据类型定义： ADT 线性表 (List) Data …. Operation InitList (*L) 初始化操作，建立一个空的线性表L ListEmpty(L) 如果线性表为空 ，返回true ,否则返回fal...
定义抽象数据类型
weixin_30262255的博客
03-18 820
在C++语言中，我们使用类定义自己的数据类型。通过定义新的类型来反映待解决问题中的各种概念，可以使我们更容易编写，调试，和修改程序。 类的基本思想是数据抽象和封装。数据抽象是一种依赖于接口和实现分离的编程技术。累得接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及类所需的各种私有函数。 封装实现了类的接口和实现的分离。封装后的类隐藏了他的实现细节，也就是说，类...
线性表
项象多的博客
02-03 345
一、线性表描述 线性结构是最常用、最简单的一种数据结构。而线性表是一种典型的线性结构。其基本特点是线性表中的数据元素是有序且是有限的。 在这种结构中： ①存在一个唯一的被称为“第一个”的数据元素； ②存在一个唯一的被称为“最后一个”的数据元素； ③除第一个元素外，每个元素均有唯一一个直接前驱；
数据结构摧毁线性表用c语言,[简述]数据结构-线性表(c语言实现)
weixin_27252001的博客
05-24 1413
[简述]数据结构-线性表(c语言实现)second60 201804221.线性表的定义线性表是具有相同特性的数据元素的一个有限序列。2.线性表抽象数据类型描述ADT List{数据对象：D = { ai | 1<= i <= n,n>=0,ai 属于ElemType类型}数据关系：R={ | ai, ai+1属于D, i=1...n-1}基本运算：initList(&am...
5. 抽象数据类型线性表的定义
最新发布
05-31
线性表是一种抽象数据类型，它是由n个数据元素组成的有限序列，其中n≥0。线性表中每个数据元素可以为不同的数据类型，如整数、实数、字符等。线性表中的数据元素之间具有相邻关系，除了第一个元素之外，每个元素均...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值