表ADT（抽象数据类型）

原创 已于 2023-04-09 22:28:50 修改 · 694 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言 #数组 #链表

于 2022-09-18 23:17:17 首次发布

1.抽象数据类型

抽象数据类型是指一系列操作的集合。抽象数据类型是数学上的抽象，在ADT的定义中并没有指出这些操作的具体实现，只给出了操作的功能。当需要使用ADT时，由程序员根据所需要的操作来进行编写，需要进行ADT中的操作时只需要调用已经写好的函数即可。

2.表ADT

一般处理的是形如 A1,A2...An 的表，这个表的大小为n，大小为0的表称为空表。对除空表外的表，称 Ai+1 为 Ai 的后继，称 Ai-1 为 Ai 的前驱，不定义 A1 的前驱，也不定义 An 的后继。表ADT中有：PrintList（打印表中元素）、Insert（向表中插入元素）、Delete（删除表中元素）、Find（找到表中对应元素）、FindKth（找到表中对应位置处的元素）、MakeEmpty（将表置空）等。这些操作可增可删，并且其具体实现应该由程序员自己决定。

3.表的简单数组实现

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

typedef struct arrList {
	int arr[100];//这个数组也可以使用动态内存的形式
	int num;
}al;//定义结构体，包含一个数组和记录表中元素个数的变量num

al* CreatListHead() {
	al* p = (al*)malloc(sizeof(al));
	p->num = 0;
	return p;
}//创建一个结构体，并对其初始化

int IsEmpty(al* L) {
	if (L->num == 0)
		return 1;
	return 0;
}//判断表是否为空，时间复杂度为常数

void InsertAhead(al* L, int i) {
	al* p = L;
	for (int j = L->num; j > 0; j--) {
		p->arr[j] = p->arr[j - 1];
	}
	p->arr[0] = i;
	p->num++;
}//在表头部插入一个元素，时间复杂度为O(N)

void PrintList(al* L) {
	for (int i = 0; i < L->num; i++) {
		printf("%d ", L->arr[i]);
	}
	printf("\n----------------------------\n");
}//打印表中的元素，时间复杂度为O(N)

void InsertBack(al* p, int i) {
	p->arr[p->num] = i;
	p->num++;
}//在表尾部插入一个元素，时间复杂度为常数

void InsertMid(al* p, int pos, int x) {
	for (int i = p->num; i > pos; i--) {
		p->arr[i] = p->arr[i - 1];
	}
	p->arr[pos] = x;
	p->num++;
}//在表中间插入一个元素，最坏时间复杂度为O(N)

void DeleteList(al* p, int x) {
	for (int i = 0; i < p->num; i++) {
		if (p->arr[i] == x) {
			for (int j = i; j < p->num - 1; j++) {
				p->arr[j] = p->arr[j + 1];
			}
		}
	}
	p->num--;
}//删除表中的一个元素，时间复杂度为O(N)

void MakeEmpty(al* p) {
	free(p);
}//释放表的内存



int main() {
	al* List = CreatListHead();
	if (IsEmpty(List)) {
		printf("The List is empty!\n");
		printf("-------------------\n");
	}

	//从前面插入元素
	for (int i = 9; i >= 5; i--) {
		InsertAhead(List, i);
	}
	PrintList(List);

	//从后面插入元素
	for (int i = 4; i >= 0; i--) {
		InsertBack(List, i);
	}
	PrintList(List);

	//从中间插入元素
	InsertMid(List, 5, 99);
	PrintList(List);

	//删除一个元素
	DeleteList(List, 7);
	PrintList(List);

	//查找某个位置的元素直接利用下标返回就行

	//删除表
	MakeEmpty(List);

	return 0;
}

Find所花费的最坏的时间复杂度为O(N)，最好的结果是要查找的元素在第一个，所以平均可能花费O(N/2)的时间，而按位置查找则花费常数时间。如果要用插入的方式来建立一个表，时间复杂度为O(N^2)（从头部插入，尾部应该为O(N)）。由于数组实现的表，插入和删除所花费的时间过长，所以一般的表（没有限制）一般不使用数组。

4.表的链表实现

由于数组中的元素是在内存中连续排列的，所以使用数组实现表时，不可避免地要对其中的元素进行移动，这就很明显的增加了不必要的开销。如果使用链表来实现，表中的元素在内存中并不是按照顺序存储的，那么对表进行插入和删除时，就不必再移动表中的元素，而只需要改变指针指向的地址即可。

但使用链表实现表ADT时，如果出现以下情况：

①在表的头部插入一个元素时

②删除表头的元素时

③在一般删除时，需要记住被删除元素之前的元素

①、②都有可能因为疏忽而丢失了表的位置，从而造成错误。

使用表头能够很好的解决上面的问题，添加一个表头（哑节点）来记住表的位置，就可以很大程度上避免一些错误。（表头的地址是不会改变的）

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

typedef struct Lnode {
	int value;
	struct Lnode* next;
}Lnode;

typedef struct List {
	Lnode* head;
	int numofele;
}List;

List* CreatList() {
	List* ret = (List*)malloc(sizeof(List));
	if (ret == NULL) {
		perror("malloc:");
		return NULL;
	}
	ret->head = (Lnode*)malloc(sizeof(Lnode));
	if (ret->head == NULL) {
		perror("malloc:");
		return NULL;
	}
	ret->head->next = NULL;
	ret->numofele = 0;
	return ret;
}

void DestroyList(List* l) {
	if (l == NULL) {
		printf("表不存在\n");
		return;
	}
	Lnode* tmp = l->head;
	while (tmp) {
		tmp = tmp->next;
		free(l->head);
		l->head = tmp;
	}
	free(l);
	l = NULL;
}

List* ClearList(List* l) {
	if (l == NULL) {
		printf("表不存在\n");
		return NULL;
	}
	l->numofele = 0;
	Lnode* tmp = l->head->next;
	Lnode* tmpp = l->head->next;
	while (tmp) {
		tmp = tmp->next;
		free(tmpp);
		tmpp = tmp;
	}
	l->head->next = NULL;
	return l;
}

bool IsEmpty(List* l) {
	if (l == NULL) {
		printf("表不存在\n");
		return false;
	}
	return l->head->next == NULL;
}

int GetListLength(List* l) {
	if (l == NULL) {
		printf("表不存在\n");
		return -1;
	}
	return l->numofele;
}

int GetElem(List* l, int pos) {//获得表中第pos个元素
	if (l == NULL) {
		printf("表不存在\n");
		return -1;
	}
	if (IsEmpty(l)) {
		printf("表为空\n");
		return -1;
	}
	if (pos < 1) {
		printf("输入位置不合法\n");
		return -1;
	}
	else {
		Lnode* tmp = l->head;
		while (tmp && pos--) {
			tmp = tmp->next;
		}
		if (tmp == NULL) {
			printf("不存在第 %d 个元素\n", pos);
			return -1;
		}
		else {
			return tmp->value;
		}
	}
}

Lnode* GetElemPos(List* l, int k) {
	if (l == NULL) {
		printf("表不存在\n");
		return NULL;
	}
	if (IsEmpty(l)) {
		printf("表为空\n");
		return NULL;
	}
	Lnode* tmp = l->head->next;
	while (tmp) {
		if (tmp->value == k)
			return tmp;
		tmp = tmp->next;
	}
	printf("不存在元素 %d\n", k);
	return NULL;
}

Lnode* GetPre(List* l, int k) {
	if (l == NULL) {
		printf("表不存在\n");
		return NULL;
	}
	Lnode* tmp = l->head;
	while (tmp->next) {
		if (tmp->next->value == k)
			return tmp;
		tmp = tmp->next;
	}
	printf("元素 %d 不存在，所以它在表中没有前驱\n", k);
	return NULL;
}

//在指定结点处后插
void BackInsert(List* l, Lnode* object, int k) {

	Lnode* tmp = (Lnode*)malloc(sizeof(Lnode));
	if (tmp == NULL) {
		perror("malloc");
		return;
	}
	tmp->value = k;
	tmp->next = object->next;
	object->next = tmp;

}

//在指定结点前插
void PreInsert(List* l, Lnode* object, int k) {

	Lnode* tmp = (Lnode*)malloc(sizeof(Lnode));
	if (tmp == NULL) {
		perror("malloc");
		return;
	}
	tmp->next = object->next;
	object->next = tmp;
	tmp->value = object->value;
	object->value = k;

}

//在指定位置的插入
void Insert(List* l, int k, int pos) {
	if (l == NULL) {
		printf("表不存在\n");
		return;
	}
	if (pos < 1 || pos > l->numofele + 1) {
		printf("插入位置不合法\n");
		return;
	}
	else {
		Lnode* tmp = l->head;
		int count = pos - 1;
		while (count--) {
			tmp = tmp->next;
		}
		Lnode* p = (Lnode*)malloc(sizeof(Lnode));
		if (p == NULL) {
			perror("malloc:");
			return;
		}
		p->value = k;
		p->next = tmp->next;
		tmp->next = p;
		l->numofele++;
	}
}

//删除指定结点
int ObjectDelete(List* l, Lnode* object) {

	int ret = object->value;
	if (object->next == NULL) {
		Lnode* tmp = l->head->next;
		while (tmp && tmp->next != object)
			tmp = tmp->next;
		if (tmp) {
			tmp->next = NULL;
			free(object);
			object = NULL;
		}
		else {
			printf("该节点不存在\n");
			return -1;
		}
	}
	else {
		Lnode* tmp = object->next;
		object->next = tmp->next;
		object->value = tmp->value;
		free(tmp);
		tmp = NULL;
	}
	return ret;
}

//删除某个位置的结点
int Delete(List* l, int i) {
	if (l == NULL) {
		printf("表不存在\n");
		return -1;
	}
	if (IsEmpty(l)) {
		printf("表为空，无法删除\n");
		return -1;
	}
	if (i<1 || i>l->numofele) {
		printf("该位置不合法\n");
		return -1;
	}
	Lnode* tmp = l->head;
	i--;
	while (i--) {
		tmp = tmp->next;
	}
	Lnode* de = tmp->next;
	int ret = de->value;
	tmp->next = de->next;
	free(de);
	de = NULL;
	return ret;

}

void Print(List* l) {
	if (l == NULL) {
		printf("表不存在\n");
		return;
	}
	if (IsEmpty(l)) {
		printf("表为空\n");
		return;
	}
	Lnode* tmp = l->head->next;
	while (tmp) {
		printf("%d ", tmp->value);
		tmp = tmp->next;
	}
	printf("\n");
}


int main() {

	List* l = CreatList();
	for (int i = 0; i <= 10; i++) {
		Insert(l, i, i + 1);
	}
	Print(l);

	Insert(l, 123, 6);
	Print(l);

	Delete(l, 12);
	Print(l);


	return 0;
}

5.数组和链表的对比

①数组需要在使用前指定大小，而链表可以动态开辟空间

②数组的元素是在内存中连续存储的，而链表不是

③插入和删除链表的时间复杂度都小于数组

④数组FindKth的时间复杂度为O(1)，而链表最坏为O(N)

⑤对于已知的相同数量的元素，链表所占用的空间要大于数组，因为链表中的每个结构体打都需要多存储一个指针，用来指向下一个元素

表的抽象数据类型（abstract data type，ADT）
杨春建的博客
09-03 1541
抽象数据类型（abstract data type，ADT）是带有一组操作的一些对象的集合。 表ADT   我们将处理形如A0，A1，A2，A3，...，AN-1的一般的表，我们说这个表的大小是N。我们将大小为0的特殊的表称为空表（empty list）。   我们说Ai后继Ai-1（或继Ai-1之后，ii-1前驱Ai（i>0）。我们可以添加一些操作，比如next和previou
用c语言定义ADT抽象数据类型,抽象数据类型定义（ADT）
weixin_27960253的博客
05-21 1576
类C语言语法示例1、预定义常量和类型#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef in Status; //Status是函数的类型，其值是函数结果状态代码。2、数据结构的存储结构typedef ElemType first;3、基本操作...
表ADT
nupt_zhangtao的博客
10-16 650
基本概念   我们将处理形如A0, A1, A2, … , AN-1的一般的表.这个表的大小是N. 我们将称大小为0的表为空表(empty list).对于除空表外的任何表, 我们说Ai后继Ai-1(或继Ai-1之后),并称Ai-1前驱Ai(i>1).表中的第一个元素是A0, 而最后一个元素是AN-1. 我们将不定义A0的前驱元,也不定义AN-1的后继元. 元素Ai在表中的位置(posit
【数据结构】回顾表ADT
weixin_34032621的博客
05-07 169
1.对于表的所有操作来说，都可以使用数组来实现，而且数组虽然是静态分配的，但内部存储数组的vector类却允许在需要时将数组的大小增加一倍。 2.正是因为数组的实现，使得printList以线性时间来执行，而findkth甚至是通过常数时间。最不济的是插入和删除了，如果位置不好，比如说在0号位置插入就需要将整个数组的所有元素都向后移，...
DataStructures-ADT:抽象数据类型（ADT）算法的实现
03-25
抽象数据类型（ADT）是某种编程语言中与实现无关的数据类型的规范。 ADT的接口是根据类型和对该类型的一组操作定义的。 每个操作的行为取决于其输入和输出。 ADT没有指定如何实现数据类型。 这些实现细节对ADT的...
c语言写报告抽象数据类型,C语言抽象数据类型ADT
weixin_42354108的博客
05-19 992
根据编程的问题匹配合适的数据类型。数据项连接构成了链表，定义了一个结构代表单独的项。设计了一些方法把一系列结构构成一个链表。本质上，我们使用C语言的功能设计了一种符合程序要求的新的数据类型。但是上述的做法不系统。我们要使用更系统的方法定义数据类型。类型指两种信息：属性和操作。定义一个新的数据类型，首先必须提供储存数据的方法。其次必须提供操控数据的方法。计算机科学领域已开发了一种定义新类型的好方法，...
ADT.zip_ADT 复数_复数ADT_复数ADT的描述_复数adt定义_抽象数据类型
09-22
复数抽象数据类型ADT的描述及实现 复数ADT的描述： ADT complex{ 数据对象：D={ c1,c2 c1,c2∈FloatSet } 数据关系：R={ <c1,c2> c1 c2 } 基本操作：创建一个复数 creat(a) 输出一个复数 outputc(a) ...
ADT（抽象数据类型）--二叉树
Turtle's trail
03-05 1753
二叉树是树的一种特殊形式，它的每个子节点至多具有2个孩子，分别是左孩子和右孩子，另外，每个节点的值比它的左子树的所有节点都大，但比它的右子树的所有节点都小，所以有了这个规则，树中就不会有重复的元素，这个特性也使二叉搜索树成为一种用关键值快速查找数据的优秀工具。 ...
抽象数据类型——表ADT(一)
little_nine的博客
07-28 1218
（一）表的相关定义 大小为N,形如A1A1A_{1}, A2A2A_{2}, A3A3A_{3}, ········, ANANA_{N}。大小为0的表成为空表。 对于除空表外的任何表，我们 Ai+1Ai+1A_{i+1} 后继 AiAiA_i（或继AiAiA_i之后）并称 Ai−1Ai−1A_{i-1}（i &amp;amp;amp;amp;amp;lt; N ）前驱 AiAiA_i(i &amp;amp;amp;amp;amp;gt; 1)。 （二）表的实现 1.
数据结构-一-抽象数据类型ADT
文耀的博客
08-12 1548
title: 数据结构 一 抽象数据类型ADT tags: [数据结构,ADT] categories: 数据结构 ADT date: 2021-06-24 13:48:40 抽象数据类型ADT 计算机科学领域已开发了一种定义新类型的好方法，用 3 个步骤完成从抽象到具体的过程。 提供类型属性和相关操作的抽象描述。这些描述既不能依赖特定的实现，也不能依赖特定的编程语言。这种正式的抽象描述被称为抽象数据类型 （ADT）。 开发一个实现 ADT 的编程接口。也就是说，指明如何储存数据和执行所需操作的函.
抽象数据类型 (ADT)
weixin_60151280的博客
06-04 1366
一、Abstraction and User-Defined Types二、Classifying Types and Operations不可变数据类型： 其操作不可改变内部值，而是构造新的对象 六、Testing an Abstract Data TypeHow to test an ADT:测试creators, producers, and mutators：调用observers来观察这些operations的结果是否满足spec；测试observers：调用creators, produce
抽象数据类型（ADT）
hit_zjx的博客
06-01 1201
关于面向对象编程ADT的思考
ADT抽象数据类型
weixin_51404363的博客
06-04 827
一.ADT:抽象数据类型1.除了编程语言所提供的基本数据类型和对象数据类型，程序员可定义自己的数据类型2.抽象数据类型被其操作定义,操作和规约刻画其特征3.抽象数据类型与表示独立性：能够分离数据结构和对其使用的方式4.ADT特性：不变量、表示泄露、、抽象函数AF、表示不变量RI二.可变和不可变数据类型1.可变类型的对象：提供了可改变其内部数据的值的操作2.不可变数据类型：其操作不可改变内部值3.抽象类型的操作:构造器(从无到有),构造器可能需要一个对象参数，但这个参数类型不是要构造的类型生产器(从有到新),
抽象数据类型 ADT
FOR 的博客
08-25 4959
5. 抽象数据类型（ADT） 抽象数据类型 (ADT，Abstract Data Type)是指一个 数学模型 以及定义在此数学模型上的一组操作。 它通常是对数据的某种抽象，定义了数据的 取值范围 及其结构形式，以及对 数据操作 的集合 。抽象数据类型是描述数据结构的一种理论工具，其目的是使人们能够独立于程序的实现细节来理解数据结构的特性。 抽象数据类型 （ abstract data type ） 是从数据使用者的角度去看数据类型。抽象数据类型是对数据的一种抽象描述，是一种数学上的约束。数据结构是ADT的
抽象数据类型ADT
weixin_52364115的博客
06-12 202
抽象数据类型的一些内容
线性表详解：ADT抽象数据类型与元素关系
在讨论线性表之前，我们首先要理解抽象数据类型（ADT）的概念。ADT是数学模型以及在该模型上的一组操作的集合，它将数据和操作封装在一起，对使用者隐藏了数据表示和实现细节。ADT定义了数据类型的行为，而不用描述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值