数据结构和算法(五)--线性表

已于 2023-02-12 21:29:32 修改
阅读量333 收藏 2
点赞数 3
分类专栏： 数据结构 算法 文章标签： 数据结构
于 2022-12-19 20:24:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42472027/article/details/128376578
版权

目录

一、线性表

1、顺序表

1.2、顺序表的遍历

1.3、顺序表的容量可变

1.4、顺序表的时间复杂度

2、链表

一、线性表

线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。

前驱元素：若A元素在B元素的前面，则称A为B的前驱元素。

后继元素：若B元素在A元素的后面，则称B为A的后继元素。

线性表的特征：数据元素之间具有一种"一对一"的逻辑关系。

1.第一个数据元素没有前驱，这个数据元素被称为头节点。

2.最后一个数据元素没有后继，这个数据元素被称为尾节点。

3.除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后驱。

线性表的分类：线性表中的数据可以是顺序存储，也可以是链式存储，按照数据的存储方式不同，可以把线性表分为顺序表和链表。

1、顺序表

顺序表是在计算机内存中以数组形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中在逻辑结构响应的数据元素存储在相邻的物理存储单元中，即通过数据元素存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

顺序表API设计：

类名SequenceList<T>
构造方法SequenceList(int capacity)：创建容量为capacity的SequenceList对象
成员方法

1.public void clear()：空置线性表

2.public boolean isEmpty()：判断线性表是否为空，是返回true,否返回false

3.private int length()：获取线性表中元素的个数

4.private T get(int i)：读取并返回线性表中第i个元素的值

5.private void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的元素

6.private void insert(T t)：向线性表中插入一个t的元素

7.private T remove(int i)：删除并返回线性表中第i个数据元素

8.private int indexOf(T t)：返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1

成员变量

1.private T[] eles：存储元素的数组

2.private int N：当前线性表的长度

代码实现：

public class SequenceList<T> {
	private T[] eles;

	private int N;

	// 构造方法
	@SuppressWarnings("unchecked")
	public SequenceList(int capacity) {
		// 初始化数组
		this.eles = (T[]) new Object[capacity];
		// 初始化长度
		this.N = 0;
	}

	// 空置线性表
	public void clear() {
		this.N = 0;
	}

	// 判断线性表是否为空，是返回true,否返回false
	public boolean isEmpty() {
		return N == 0;
	}

	// 获取线性表中元素的个数
	public int length() {
		return N;
	}

	// 读取并返回线性表中第i个元素的值
	public T get(int i) {
		return eles[i];
	}

	// 向线性表中插入一个t的元素
	public void insert(T t) {
		eles[N++] = t;
	}

	// 在线性表的第i个元素之前插入一个值为t的元素
	public void insert(int i, T t) {
		// 先把i索引处及其后面的元素依次向后移动一位
		for (int index = N; index > i; index--) {
			eles[index] = eles[index - 1];
		}
		// 再把t元素放到i索引处即可
		eles[i] = t;
		N++;
	}

	// 删除并返回线性表中第i个数据元素
	public T remove(int i) {
		// 记录索引i处的值，
		T current = eles[i];
		// 索引i后面元素依次向前移动一位
		for (int index = i; index < N - 1; index++) {
			eles[index] = eles[index + 1];
		}

		// 元素个数减一
		N--;

		return current;
	}

	// 返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1
	public int indexOf(T t) {
		for (int i = 0; i < N; i++) {
			if (eles[i].equals(t)) {
				return i;
			}
		}
		return -1;
	}
}

测试类：

public class SequenceListTest {

	public static void main(String[] args) {
		SequenceList<String> list = new SequenceList<>(10);
		list.insert("张无忌");
		list.insert("张翠山");
		list.insert("张三丰");
		list.insert("小昭");
		list.insert(1, "赵敏");

		System.out.println(list.get(1));
		System.out.println(list.remove(0));
		System.out.println(list.length());
		list.clear();
		System.out.println(list.length());
	}

}

1.2、顺序表的遍历

在java代码中，遍历集合的方式一般都是用的是foreach循环，如果想让我们的SequenceList也能支持foreach循环，则需要做如下操作：

1、让SequenceList实现Iterable接口，重写Iterator方法

2、在SequenceList内部提供一个内部类SIterator，实现Iterator接口，重写hashNext方法和next方法

代码实现：

import java.util.Iterator;

public class SequenceList<T> implements Iterable<T> {
	private T[] eles;

	private int N;

	// 构造方法
	@SuppressWarnings("unchecked")
	public SequenceList(int capacity) {
		// 初始化数组
		this.eles = (T[]) new Object[capacity];
		// 初始化长度
		this.N = 0;
	}

	// 空置线性表
	public void clear() {
		this.N = 0;
	}

	// 判断线性表是否为空，是返回true,否返回false
	public boolean isEmpty() {
		return N == 0;
	}

	// 获取线性表中元素的个数
	public int length() {
		return N;
	}

	// 读取并返回线性表中第i个元素的值
	public T get(int i) {
		return eles[i];
	}

	// 向线性表中插入一个t的元素
	public void insert(T t) {
		eles[N++] = t;
	}

	// 在线性表的第i个元素之前插入一个值为t的元素
	public void insert(int i, T t) {
		// 先把i索引处及其后面的元素依次向后移动一位
		for (int index = N; index > i; index--) {
			eles[index] = eles[index - 1];
		}
		// 再把t元素放到i索引处即可
		eles[i] = t;
		N++;
	}

	// 删除并返回线性表中第i个数据元素
	public T remove(int i) {
		// 记录索引i处的值，
		T current = eles[i];
		// 索引i后面元素依次向前移动一位
		for (int index = i; index < N - 1; index++) {
			eles[index] = eles[index + 1];
		}

		// 元素个数减一
		N--;

		return current;
	}

	// 返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1
	public int indexOf(T t) {
		for (int i = 0; i < N; i++) {
			if (eles[i].equals(t)) {
				return i;
			}
		}
		return -1;
	}

	private class SIterator implements Iterator<T> {

		private int cusor;

		private SIterator() {
			this.cusor = 0;
		}

		@Override
		public boolean hasNext() {
			return cusor < N;
		}

		@Override
		public T next() {
			return eles[cusor++];
		}

	}

	@Override
	public Iterator<T> iterator() {
		return new SIterator();
	}
}

测试类：

public class SequenceListTest {

	public static void main(String[] args) {
		SequenceList<String> list = new SequenceList<>(10);
		list.insert("张无忌");
		list.insert("张翠山");
		list.insert("张三丰");
		list.insert("小昭");
		list.insert(1, "赵敏");

		for (String string : list) {
			System.out.println(string);
		}

		System.out.println("-----------------------------");
		System.out.println(list.get(1));
		System.out.println(list.remove(0));
		System.out.println(list.length());
		list.clear();
		System.out.println(list.length());
	}

}

1.3、顺序表的容量可变

考虑容器的容量伸缩性，其实就是改变存储数据元素的数组的大小，那我们需要考虑什么时候需要改变数组的大小？

1、添加元素时：添加元素时，应该检查当前数组的大小是否能容纳新的元素，如果不能容纳，则需要创建新的容量更大的数组，我们这里创建一个是原数组两倍容量的新数组存储元素。

2、移除元素时：移除元素时，应该检查当前数组的大小是否太大，比如正在用100个容量的数组存储10个元素，这样就会造成内存空间的浪费。应该创建一个更小的数组存储元素。如果我们发现数据元素的数量不足数组容量的1/4，则创建一个是原数组容量的1/2的新数组存储元素。

代码实现：

import java.util.Iterator;

public class SequenceList<T> implements Iterable<T> {
	private T[] eles;

	private int N;

	// 构造方法
	@SuppressWarnings("unchecked")
	public SequenceList(int capacity) {
		// 初始化数组
		this.eles = (T[]) new Object[capacity];
		// 初始化长度
		this.N = 0;
	}

	// 空置线性表
	public void clear() {
		this.N = 0;
	}

	// 判断线性表是否为空，是返回true,否返回false
	public boolean isEmpty() {
		return N == 0;
	}

	// 获取线性表中元素的个数
	public int length() {
		return N;
	}

	// 读取并返回线性表中第i个元素的值
	public T get(int i) {
		return eles[i];
	}

	// 向线性表中插入一个t的元素
	public void insert(T t) {
		if (N == eles.length) {
			resize(2 * eles.length);
		}

		eles[N++] = t;
	}

	// 在线性表的第i个元素之前插入一个值为t的元素
	public void insert(int i, T t) {
		if (N == eles.length) {
			resize(2 * eles.length);
		}
		// 先把i索引处及其后面的元素依次向后移动一位
		for (int index = N; index > i; index--) {
			eles[index] = eles[index - 1];
		}
		// 再把t元素放到i索引处即可
		eles[i] = t;
		N++;
	}

	// 删除并返回线性表中第i个数据元素
	public T remove(int i) {
		// 记录索引i处的值，
		T current = eles[i];
		// 索引i后面元素依次向前移动一位
		for (int index = i; index < N - 1; index++) {
			eles[index] = eles[index + 1];
		}

		// 元素个数减一
		N--;

		if (N < eles.length / 4) {
			resize(eles.length / 2);
		}

		return current;
	}

	// 返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1
	public int indexOf(T t) {
		for (int i = 0; i < N; i++) {
			if (eles[i].equals(t)) {
				return i;
			}
		}
		return -1;
	}

	// 根据参数newSize，重置eles的大小
	@SuppressWarnings("unchecked")
	public void resize(int newSize) {
		// 定义一个临时数组，指向原数组
		T[] tmp = eles;
		// 创建新数组
		eles = (T[]) new Object[newSize];
		// 把原数组的数据拷贝到新数组即可
		for (int i = 0; i < N; i++) {
			eles[i] = tmp[i];
		}
	}

	private class SIterator implements Iterator<T> {

		private int cusor;

		private SIterator() {
			this.cusor = 0;
		}

		@Override
		public boolean hasNext() {
			return cusor < N;
		}

		@Override
		public T next() {
			return eles[cusor++];
		}

	}

	@Override
	public Iterator<T> iterator() {
		return new SIterator();
	}
}

1.4、顺序表的时间复杂度

get(i):时间复杂度O(1);

insert(int i,T t);时间复杂度O(n);

remove(i);时间复杂度O(n);

由于顺序表的底层由数组实现，数组的长度是固定的，所以在操作的过程中涉及到了容器扩容操作。这样会导致顺序表在使用过程中的时间复杂度不是线性的，在某些需要扩充的节点处，耗时会突增，尤其是元素越多，这个问题越明显。

2、链表

天下事有难易乎？为之，则难者亦易矣；不为，则易者亦难矣。

杀神lwz
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
Java语言——顺序表的实现
weixin_46944732的博客
03-06 748
顺序表是线性表的顺序存储结构，它使用一堆数组依次存放线性表中的数据元素 以下为线性表的设计代码可实现数据元素增、删、减、查 代码如下： /** *author 小鱼骨头 *data 2022-3-6 */ //顺序表类：T 表示数据元素的数据类型。默认继承Object类 public class SequenceList<T> extends Object { //顺序表元素个数（长度） protected int n; //对象数组存储顺序表的数据元素，保护成员
java SequenceList实现代码
zhandeen的专栏
11-10 1253
import java.util.Arrays; public class SequenceList { private final int DEFAULT_SIZE=16; private int capacity; private Object[] elementData; private int size=0; public SequenceList() { capacity
算法-线性表-顺序表
jjl77的博客
03-06 311
目录 一、线性表 1、1 顺序表 一、线性表 线性表是最基本、最简单、也是最常用的一种数据机构，一个线性表是n个具有相同特性的数据元素的有限序列 前驱元素： 若A元素再B元素的前面，则称A为B的前驱元素。 后继元素： 若B元素再A元素的前面，则称B为A的前驱元素。 线性表的特征：数据元素之间具有一种“一对一”的逻辑关系。 1、第一个数据元素没有前驱，这个数据元素被称为头结点。 2、最后一个数据元素没有后继，这个数据元素被称为尾结点。 3、除了第一个和最后一个数据元素外，其他数据元
数据结构--线性表--顺序表
一名小白的博客
07-20 96
顺序表 ​ 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。 顺序表的实现 顺序表的API 方法名 方法功能 public void clear() 空置线性表 public boolean isEmpty() 判断线性表是否为空，是返回true，否返回false publi
java中顺序表的泛型类
asdhoh的博客
03-12 1342
泛型类 package Jiegou; public class sequenceList<T> { //顺序表中一维数组的初始长度 final int maxSize = 10; //存储元素的数组对象 private T[] listArray; //保存顺序表的当前长度 private int length; //构造一个空的线性表 public sequenceList() { //线性表初始为空 ...
数据结构与算法（一）——线性表
一只蝼蚁的博客
05-26 375
数据结构与算法（一）——线性表顺序表1.顺序表声明2.顺序表初始化3.顺序表操作（一）插入链式表 顺序表 顺序表：顺序表，全名顺序存储结构，是线性表的一种。线性表用于存储逻辑关系为“一对一”的数据，顺序表自然也不例外。 不仅如此，顺序表对数据的物理存储结构也有要求。顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。 顺序表操作类似与数组，只是顺序表大部分时间操作的是动态数组。。。 第一次写，真有点蒙，直接上才艺把 1.顺序表声明 //顺序表 s
数据结构与算法（二）——线性表
站在远方看童年的博客
12-13 194
线性表，栈-顺序表、链表 1、Collection接口——（译：聚集） Collections API位于java. util 包中。集合( collection)的概念在Collection接口中得 到抽象，它存储一组类型相同的对象。图3-5显示该接口一些最重要的部分(但一些方法未 被显示)。 在collection接口中的许多方法所做的工作由它们的英文名称可以看出，因此size返 回集合中的项...
数据结构与算法分析--线性表实现
04-01
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素构成的序列，元素之间存在一对一的...通过理解这些概念，开发者可以更好地设计和实现适应不同场景的线性表数据结构，提高程序的性能和可维护性。
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
从键盘输入数据，建立两个有序线性表(每个线性表的输入数据按由小到大次序输入来建立线性表，不必考虑排序算法)；输出建好的这两个有序线性表；将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 ...
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构与算法笔记-线性表定义和特点
01-07
线性表示相当灵活的数据结构，其长度可以根据需要适当的增长或者缩短，即对线性表的数据元素不仅可以进行访问，而且可以进行擦汗如和删除等操作。 一、下列给出线性表的抽象数据类型定义： ADT 线性表 （list） Data...
头歌C++数据结构与算法 - 线性表
03-04
头歌C++数据结构与算法 - 线性表
Java数据结构-顺序表(SequenceList)（五）
weixin_45987961的博客
10-28 486
什么是顺序表 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系； 常见的如数组： 在Java中顺序表一般体现为两种 数组 与 集合，数组是固定长度的顺序表，集合是动态长度的顺序表，这里实现动态长度的顺序表； 顺序表的实现(直接上代码) public class Sequenc...
顺序表(java)
m0_49042213的博客
09-02 286
一、线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种“一对一”的逻辑关系。 1 . 第一个数据元素没有前驱，这个数据元素被称为头结点； 2. 最后一个数据元素没有后继，这个数据元素被称为尾结点； 3. 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。 如果把线性表用数学语言来
SequenceList 的一个简单实现
coding
06-04 1048
java实现的SequenceList主要是顺序线性表一个简单例子，欢迎大家一起讨论更好的实现，和JDK源码的讨论！
【数据结构】线性表之顺序线性表
weixin_33810006的博客
03-01 80
2019独角兽企业重金招聘Python工程师标准>>> ...
c语言（7.23）
fhgfyrsg的博客
07-23 593
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 345
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
最新发布
m0_71703182的博客
07-24 768
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
数据结构与算法解析-线性表插入操作
"这篇资源主要讨论的是算法与数据结构的主题，包括线性表的插入操作以及数据结构在计算机科学中的重要性。提供的代码是C语言实现的线性表顺序插入函数Insert_SqList，该函数将元素插入到指定位置并更新线性表长度。...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杀神lwz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值