数据结构

最新推荐文章于 2023-02-21 00:50:13 发布

Wagsn8

最新推荐文章于 2023-02-21 00:50:13 发布

阅读量1k

点赞数 1

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/Wagsn8/article/details/85286773

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

数据结构

文章更新中

文档版本	修订时间	修订内容	修订人
1.0.0	18/12/27	初稿	Wagsn

文章目录

数据结构

通常来说，一个数据结构DS 可以表示为一个二元组：
DS=(D,S) //data-structure=(data-part,logic-structure-part)
这里D是数据元素的集合（或者是“结点”，可能还含有“数据项”或“数据域”），S是定义在D（或其他集合）上的关系的集合，S = { R | R : D×D×…}，称之为元素的逻辑结构。
逻辑结构有四种基本类型：
集合结构、线性结构、树状结构和网络结构。
表和树是最常用的两种高效数据结构，许多高效的算法可以用这两种数据结构来设计实现。
表是线性结构的（全序关系），树(偏序或层次关系)和图（局部有序(weak/local orders)）是非线性结构。

四种基本结构 1

通常有下列四类基本的逻辑结构：

⑴集合结构。该结构的数据元素间的关系是“属于同一个集合”。
⑵线性结构。该结构的数据元素之间存在着一对一的关系。
⑶树型结构。该结构的数据元素之间存在着一对多的关系。
⑷图形结构。该结构的数据元素之间存在着多对多的关系，也称网状结构。

容器分类：

无序重复 Collection
有序重复 List
无序互异 Set
有序互异 Ordered Set

存储结构：

顺序 Array
链式 Link

顺序存储和链接存储是数据的两种最基本的存储结构。

Collection

// Collection 容器 无序 重复
Collection<E> : Iterable<E> {
	push (E) => Void;
	remove (E) => E;
	contains (E) => Bool;
	foreach (action: E => Void) => Void;
	count () => Int;
}

集合结构

定义

若x是集合A的元素，则记作x∈A。集合中的元素有三个特征：

1).确定性（集合中的元素必须是确定的）
2).互异性（集合中的元素互不相同。例如：集合A={1，a}，则a不能等于1）
3).无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,5,4}算作同一个集合。

伪代码

// Set 集合结构（无序，互异）Collection<E>（无序，重复）Iterable<E>（可迭代）继承树中限制越小越在上层
Set<E> : Collection<E> {
	// 子集，如果集合A的任意一个元素都是集合B的元素（任意a∈A则a∈B），那么集合A称为集合B的子集，记为A⊆B或 B⊇A，读作“集合A包含于集合B”或集合B包含集合A”。
	// 即：∀a∈A有a∈B，则A⊆B。
	containsAll (other: Set<E>) => Bool {
		for(ele in other) {
			if(!caller.contains(ele)) {  // contains x∈A
				return false;
			}
		}
		// 如果other为空集，空集是任意集合（包括空集）的子集。
		return true;
	}
	// 并集 -由所有属于集合A或属于集合B的元素所组成的集合
	// A∪B={x|x∈A,或x∈B}；∅∪A=A
	addAll (other: Set<E>) => Set<E> {
		result: Set<E> := Set<E>();
		for(ele in caller) {  // "caller" is the instance of type Set<E> 
			result.push(ele);
		}
		for(ele in other) {
			if(!result.contains(ele)) {
				result.push(ele);
			}
		}
		return result;
	}
	// 交集，由属于A且属于B的相同元素组成的集合
	retainAll (other: Set<E>) => Set<E> {
		result: Set<E> := Set<E>();
		for(ele in other) {
			if(caller.contains(ele)) {
				result.push(ele);
			}
		}
		return result;
	}
	// 相对补集，由属于A而不属于B的元素组成的集合，称为B关于A的相对补集
	removeAll (other: Set<E>) => Set<E> {
		result: Set<E> := Set<E>();
		for(ele in caller) {  // "caller" is the instance of type Set<E> 
			result.push(ele);
		}
		for(ele in other) {
			if(caller.contains(ele)) {
				result.remove(ele);
			}
		}
	}
}

线性结构

线性表

伪代码

// List 线性表，可索引的 Indexable<Int, E> <=> this(index: Int)=>E
List<E> : Colletion<E>, Indexable<Int, E> {
	// var list = List<Int>(); var int0 = list(0); 00
	this (index: Int) => E;
	get (index: Int) => E;
	set (index: Int, e: E) => Void;
	remove (index: Int) => E;
	// 查询元素的索引
	indexOf (e: E) => Int {
		for(i=0; i<caller.count(); i++) {
			if (caller.get(i).equals(e)) {
				return i;
			}
		}
		return -1;
	}
	// 获取子表
	subList (fromIndex: Int, toIndex: Int) => List<E>{
		result := Lsit<E>();
		for(i=fromIndex; i<toIndex; i++){
			result.push(caller.get(i));
		}
		return result;
	}
}