数据结构---列表

最新推荐文章于 2025-10-22 14:52:48 发布
原创 最新推荐文章于 2025-10-22 14:52:48 发布 · 4.9k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了数据结构中的列表，包括顺序列表和链表列表两种实现方式。内容涵盖列表的基本操作，如增加、删除元素，判断空列表，获取有效长度及末尾元素，改变特定位置元素，查找元素，以及扩容、缩容策略。同时，提供了相关代码实现。

1.列表

在基础数据结构中，列表作为最为基础的一个数据结构进行体现。

2.列表的模型
在这里插入图片描述
3.基本算法

1.增加元素（在头部/尾部/其余地方）	
2.删除元素（在头部/尾部/其余地方）
3.扩容/缩容
4.获取有效长度
5.判断列表是否为空
6.获取某位置元素（头部/尾部/其余地方）
7.改变某位置的元素
8.寻找元素，返回下标。
9.列表是否包含某元素
10.获取容积
11.清除列表
12.交换列表中两位置的元素
13.重写toString方法

4.实现方法

一，顺序列表
在这里插入图片描述
使用数组Date[ ]实现。

  1. 增加元素

    在头部增加，尾部增加，中间增加。

  2. 删除元素

    在头部删除，尾部删除，中间删除。

  3. 扩容/缩容

    -数组中增加元素时，数组已满，则需要扩容。
    -数组中删除元素时，一般删除到数组长度的四分之一时，一般将数组的长度删除到原来的一半。则需要缩容。

  4. 获取有效长度

    获取数组的有效长度。

  5. 判断列表是否为空

    获取数组的有效长度是否为0。

  6. 获取末位置元素

    获取数组的有效长度-1的位置的元素。

  7. 改变某位置的元素

    根据数组的下标改变某下标的元素。

  8. 寻找元素

    循环遍历数组判断元素是否相等。返回其下标。

  9. 列表是否包含某元素

    和寻找元素一样，循环遍历数组判断元素是否相等。

  10. 获取容积

    获取数组的总长度。

  11. 清除列表

    -数组的有效长度size是标记数组某位置是否存在元素。
    -直接将size置0。

  12. 交换列表中两位置的元素

    在数组中交换两位置之间的元素。

  13. 重写toString方法

    重新拼接字符串。打印输出。

代码：

public class ArrayList<E> implements List<E>{
	private E[] data;	//容器-存储元素 data.length 最大容量
	private int size;	//当前列表中元素的个数 有效长度
	private static final int DEFAULT_CAPACITY=10;
	public ArrayList(){	//默认构造函数中创建一个容量为10的列表
		this(DEFAULT_CAPACITY);
	}
	public ArrayList(int capacity){	//构造函数中创建一个容量为capacity的列表
		if(capacity<0){
			capacity=DEFAULT_CAPACITY;
		}
		this.data=(E[]) new Object[capacity];
		this.size=0;
	}
	//O(n)
	public void add(int index, E e) {	//增加元素
		if(index<0||index>size){
			throw new IllegalArgumentException("角标非法！");
		}
		if(size==data.length){
			resize(data.length*2);//重置容量
		}
		for(int i=size;i>index;i--){
			data[i]=data[i-1];
		}
		data[index]=e;
		size++;
	}
	public void addFirst(E e) {	//在头部增加
		add(0,e);
	}
	//O(1)
	public void addLast(E e) {	//在尾部增加
		add(size,e);
	}
	//O(n)
	public E remove(int index) {	//删除元素
		if(index<0||index>=size){
			throw new IllegalArgumentException("角标非法！");
		}
		E res=data[index];
		
		for(int i=index;i<size-1;i++){
			data[i]=data[i+1];
		}
		size--;
		if(size==data.length/4&&data.length>DEFAULT_CAPACITY){
			resize(data.length/2);
		}
		return res;
	}
	public E removeFirst() {	//在头部删除
		return remove(0);
	}
	public E removeLast() {	//删除尾部元素
		return remove(size-1);
	}
	//O(n)
	@Override
	public void removeElement(E e) {	//删除元素
		int index=find(e);//O(n)
		if(index!=-1){
			remove(index);//O(n)
		}
	}
	private void resize(int newLen) {	 //扩容/缩容
		E[] newData=(E[]) new Object[newLen];
		for(int i=0;i<Math.min(data.length,newData.length);i++){
			newData[i]=data[i];
		}
		data=newData;
	}
	public int getSize() {	//获取有效长度
		return this.size;
	}
	public boolean isEmpty() {	//判断是否为空
		return this.size==0;
	}
	//O(1)
	public E get(int index) {	//获取元素
		if(index<0||index>=data.length){
			throw new IllegalArgumentException("角标不存在！");
		}
		return data[index];
	}
	public E getFirst() {	//获取头元素
		return get(0);
	}
	public E getLast(){	//获取尾元素
		return get(size-1);
	}
	public void set(int index, E e) {	//改元素
		if(index<0||index>=size){
			throw new IllegalArgumentException("角标不存在！");
		}
		data[index]=e;
	}
	public int find(E e) {	//寻找某元素
		for(int i=0;i<size;i++){
			if(data[i]==e){
				return i;
			}
		}
		return -1;
	}
	public boolean contains(E e) {	//是否包含某元素
		return find(e)!=-1;
	}
	public int getCapacity(){	//获取数组总长度
		return data.length;
	}
	public void clear() {	//清空数组
		this.data=(E[]) new Object[DEFAULT_CAPACITY];
		this.size=0;
	}
	public void swap(int i,int j){	//将两位置元素交换
		if(i<0||i>=size||j<0||j>=size){
			throw new IllegalArgumentException("角标非法！");
		}
		E temp=data[i];
		data[i]=data[j];
		data[j]=temp;
	}
	@Override
	public String toString() {	//重写toString方法
		StringBuilder sb=new StringBuilder();
		if(isEmpty()){
			sb.append(String.format("ArrayList:[] %d/%d \n", size,data.length));
		}else{
			sb.append("ArrayList:[");
			for(int i=0;i<size;i++){
				if(i==size-1){
					sb.append(data[i]+"]");
				}else{
					sb.append(data[i]+",");
				}
			}
			sb.append(String.format(" %d/%d \n", size,data.length));
			
		}
		return sb.toString();
	}
}

二，链表列表

使用链表实现列表。
在这里插入图片描述

  1. 增加元素

    在头部增加，尾部增加，中间增加。

  2. 删除元素

    在头部删除，尾部删除，中间删除。

  3. 获取有效长度

    获取链表的有效长度。

  4. 判断列表是否为空

    获取链表的有效长度是否为0。

  5. 获取末位置元素

    尾指针所指的元素。

  6. 改变某位置的元素

    根据链表的下标改变某下标的元素。

  7. 寻找元素

    循环遍历链表判断元素是否相等。返回其下标。

  8. 列表是否包含某元素

    和寻找元素一样，循环遍历l链表判断元素是否相等。

  9. 获取容积

    获取链表的有效长度=总长度。

  10. 清除列表

    -链表的有效长度size是标记链表某位置是否存在元素。
    -直接将size置0。

  11. 重写toString方法

    重新拼接字符串。打印输出。

代码：

package p02.动态链表;

import p01.动态数组.List;

public class LinkedList<E> implements List<E>{
	private Node head;	//头指针
	private Node rear;	//尾指针
	private int size;	//元素个数
	public LinkedList(){
		head=new Node();	//创建虚拟头结点
		rear=head;
		size=0;
	}
	private class Node{
		E data;
		Node next;
		public Node(){
			this(null,null);
		}
		public Node(E data){
			this(data,null);
		}
		public Node(E data,Node next){
			this.data=data;
			this.next=next;
		}
	}

	@Override
	public int getSize() {	//获取有效长度
		return size;
	}

	@Override
	public boolean isEmpty() {	//是否为空
		return size==0;
	}

	@Override
	public void add(int index, E e) {	//增加元素
		if(index<0||index>size){
			throw new IllegalArgumentException("角标非法！");
		}
		Node n=new Node(e);//封装节点
		if(index==0){	//头插
			n.next=head.next;
			head.next=n;
			if(isEmpty()){//第一次添加元素 要更新尾指针
				rear=n;
			}
		}else if(index==size){	//尾插
			n.next=rear.next;
			rear.next=n;
			rear=n;
		}else{	//其余地方插
			Node p=head;
			for(int i=0;i<index;i++){
				p=p.next;
			}
			n.next=p.next;
			p.next=n;
		}
		size++;
	}

	@Override
	public void addFirst(E e) {	//头插
		add(0,e);
	}

	@Override
	public void addLast(E e) {	//尾插
		add(size,e);
	}

	@Override
	public E get(int index) {	//获取元素
		if(index<0||index>=size){
			throw new IllegalArgumentException("角标非法！");
		}
		if(index==0){	//表头
			return head.next.data;
		}else if(index==size-1){	//表尾
			return rear.data;
		}else{	//其余
			Node p=head;
			for(int i=0;i<=index;i++){
				p=p.next;
			}
			return p.data;
		}
	}

	@Override
	public E getFirst() {	//头部
		return get(0);
	}

	@Override
	public E getLast() {	//尾部
		return get(size-1);
	}

	@Override
	public E remove(int index) {	//删除元素
		if(index<0||index>=size){
			throw new IllegalArgumentException("角标非法！");
		}
		E res=null;
		if(index==0){	//删头
			Node n=head.next;
			res=n.data;
			head.next=n.next;
			n=null;
			if(size==1){	//删除最后一个元素，要更新尾指针
				rear=head;
			}
		}else if(index==size-1){	//删尾
			res=rear.data;
			Node p=head;
			while(p.next!=rear){
				p=p.next;
			}
			p.next=rear.next;
			rear=p;
		}else{	//删其余
			Node p=head;
			for(int i=0;i<index;i++){
				p=p.next;
			}
			Node n=p.next;
			res=n.data;
			p.next=n.next;
			n=null;
		}
		size--;
		return res;
	}

	@Override
	public E removeFirst() {	//删头
		return remove(0);
	}

	@Override
	public E removeLast() {	//删尾
		return remove(size-1);
	}

	@Override
	public void set(int index, E e) {	//改变元素
		if(index<0||index>=size){
			throw new IllegalArgumentException("角标非法");
		}
		Node p=head;
		for(int i=0;i<=index;i++){
			p=p.next;
		}
		p.data=e;
	}

	@Override
	public boolean contains(E e) {	//判断是否包含某元素
		return find(e)!=-1;
	}

	@Override
	public int find(E e) {	//查找某元素
		if(isEmpty()){
			return -1;
		}
		int index=-1;
		Node p=head;
		while(p.next!=null){
			index++;
			p=p.next;
			if(p.data.equals(e)){
				return index;
			}
		}
		return -1;
	}

	@Override
	public void removeElement(E e) {	//删除某元素
		int index=find(e);
		if(index!=-1){
			remove(index);
		}
	}

	@Override
	public void clear() {	//清除元素
		head.next=null;
		rear=head;
		size=0;
	}
	@Override
	public String toString() {	//重写toString方法
		StringBuilder sb=new StringBuilder();
		if(isEmpty()){
			return "[]";
		}else{
			sb.append("[");
			Node p=head;
			while(true){
				p=p.next;
				if(p==rear){
					sb.append(p.data+"]");
					break;
				}else{
					sb.append(p.data+",");
				}
			}
		}
		return sb.toString();
	}
}
〖Python 数据库开发实战 - Redis篇⑧〗- Redis数据结构 - 列表类型
易编橙 · 终身成长社群，相遇已是上上签！
09-17 4万+
接下来我们继续来学习 redis 的数据类型，这一次我们将要学习的是 "列表类型" 。比如说 "秒杀" 这种业务，就需要用到 "列表" 这种数据类型，我们可以使用 "列表" 来保存用户的抢购记录，所以就需要先掌握列表这种数据类型。后续才能够在 Python 程序中编写模拟 "秒杀" 的代码。接下来就让我们学习 "redis" 的 "列表类型" 吧。
数据结构 - 双向列表与循环列表
陆讯
04-28 3799
循环链表 循环链表(Circular Linked List)：是一种头尾相接的链表。其特点是最后一个结点的指针域指向链表的头结点，整个链表的指针域链接成一个环。 从循环链表的任意一个结点出发都可以找到链表中的其它结点，使得表处理更加方便灵活。 循环链表的操作 对于单循环链表，除链表的合并外，其它的操作和单线性链表基本上一致，仅仅需要在单线性链表操作算法基础上作以下简单修改：
Python数据结构： 列表（List）详解
热门推荐
Snailandfish的专栏
11-10 1万+
在Python中，列表（List）是一种有序、可变的数据类型，被广泛用于存储和处理多个元素。列表是一种容器，可以包含任意数据类型的元素，包括数字字符串列表字典等。本文将深入讨论列表的各个方面，包括基本语法、常见操作，以及实际应用场景。将覆盖列表的创建访问修改列表推导式和嵌套列表推导式等关键内容。
软件设计师知识点总结：数据结构与算法（超级详细）
最新发布
hy20060720的博客
10-22 2790
本文系统梳理了数据结构与算法核心知识点，涵盖线性结构、树、图、排序与查找算法。主要内容包括：1.数据结构三要素（逻辑结构、存储结构、运算）和算法复杂度分析（时间/空间复杂度）；2.线性结构（顺序表、链表、栈、队列）的实现与操作；3.树结构（二叉树、哈夫曼树）的性质与遍历；4.图的存储（邻接矩阵/表）与遍历（DFS/BFS）；5.经典排序算法（插入、交换、选择、归并类）的原理与实现；6.查找算法（顺序、二分、哈希）的适用场景。重点解析了快速排序、堆排序等核心算法的实现细节与优化策略
Python数据结构：列表详解（创建、访问、修改、列表方法）
公众号：该用户快成仙了
07-16 9235
Python中的列表是一个非常强大的数据结构，它允许我们存储、访问和操作一系列的数据。列表可以包含任何类型的对象，包括数字、字符串、甚至其他列表。本文将详细介绍Python列表的创建、访问、修改以及列表方法，并附上一个综合的例子，全面展示列表在实际编程中的应用。
数据结构之列表
TSzero的博客
03-29 1123
Python里的列表
数据结构——列表
z7sz的博客
06-22 931
python基础——列表的基本使用
anyline-数据结构
09-17
文件名称列表中的“anyline-data-dialect-kv”可能指向键值对数据模型（Key-Value Model），这是一种简单的数据结构，通常用在数据库中存储键与值的对应关系，如Redis数据库。"anyline-log"可能与记录日志文件相关，...
nop-app-mall-数据结构资源
04-06
nop-app-mall-数据结构资源是一个专门针对nop-app-mall项目的资源集合，其中包含了一系列与数据结构相关的开发工具、构建脚本和配置文件。 nop-app-mall可能是一个特定的项目名称或应用商城的名称，而数据结构作为...
model-arithmetic-parent-数据结构资源
03-14
本文档内容涉及数据结构资源，标题为“model-arithmetic-parent-数据结构资源”，在描述和标签中也出现了相同的关键词，表明该压缩包文件集中的内容是围绕数据结构展开的。具体来说，它可能包括了某种数据结构的算法...
anyline-数据结构资源
03-12
1. "anyline-数据结构资源"文件包的标题表明，这个压缩包中包含的是一组关于数据结构的资源。数据结构是计算机科学中组织、管理和存储数据的一种方式，使得数据可以高效地被访问和修改。它对于算法设计与分析、软件...
数据结构-列表
前端御书房
06-07 405
列表数据结构
第六讲 数据结构之列表
weixin_50587406的博客
12-12 535
List item
列表-数据结构
shark的专栏
06-11 713
数据结构中的列表一般指线性列表的简称. 列表是一种数据项构成的有限序列,即按照一定的线性顺序,排列而成的数据项的集合,在这种数据结构上进行的基本操作包括对元素的的查找,插入,和删除 列表的两种主要表现是数组和链表,栈和队列是两种特殊类型的列表
数据结构-列表简介
weixin_47364956的博客
11-02 789
数据结构-列表简介 列表介绍 列表是数据结构中常见的一种，基本操作包括增加元素、插入元素、删除元素、查看元素；我在网上看别人写的关于列表的介绍，稍微有点头大，有些博主写的代码比较乱，最主要还没注释，且基本操作介绍也不全面，缺东少西的；我尽量简单的把列表讲清楚，基本操作讲全面； #include <stdio.h> #include <malloc.h> #include "stdlib.h" //定义列表结构体 struct plist { int A[1000]; i
数据结构——列表list
weixin_44830542的博客
05-28 845
列表是用来储存一组有序数据元素的数据结构，列表内容可变。
湖南大学数据结构2016-2019年期末试题汇编
资源摘要信息:"湖南大学-数据结构-期末试题【2016-2019】.zip"是一份包含了2016年至2019年湖南大学数据结构课程期末考试试题的压缩文件。该文件为学生提供了过去五年内的考试试题，帮助他们复习和准备未来的考试。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值