单向链表，双向链表

最新推荐文章于 2024-10-04 18:59:43 发布
最新推荐文章于 2024-10-04 18:59:43 发布
阅读量86 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45107175/article/details/132425922
版权

3.单向链表，双向链表

动态数组有一个明显的缺点，内存空间的大量浪费

能否用到多少就申请多少内存？

  • 链表可以办到这一点

链表是一种链式存储的线性表，所有元素的内存地址不一定是连续的;

在这里插入图片描述

链表的接口设计

在这里插入图片描述

由于链表的大部分接口和动态数组一致，我们抽取出一个共同的 List 接口；

可以使用继承，但是仅仅只是对外接口差不多，但实际实现的代码肯定是不尽相同，所以弄一个父类没有意义

所以可以创建一个接口类，只声明不实现

package com.mj;

public interface List<E> {
	static final int ELEMENT_NOT_FOUND = -1;
	/**
	 * 清除所有元素
	 */
	void clear();

	/**
	 * 元素的数量
	 * @return
	 */
	int size();

	/**
	 * 是否为空
	 * @return
	 */
	boolean isEmpty();

	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	boolean contains(E element);

	/**
	 * 添加元素到尾部
	 * @param element
	 */
	void add(E element);

	/**
	 * 获取index位置的元素
	 * @param index
	 * @return
	 */
	E get(int index);

	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	E set(int index, E element);

	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	void add(int index, E element);

	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	E remove(int index);

	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	int indexOf(E element);
}

再将一些通用的字段与方法放到一个抽象类中，无论是动态数组还是链表都只需要继承这个抽象类即可。

package com.zj;

/**
 * 单向链表
 * @author yusael
 */
public class LinkedList<E> extends AbstractList<E> {

	private Node<E> first;

	// 链表中的节点
	private static class Node<E> {
		E element; // 节点元素
		Node<E> next; // 节点指向下一个节点

		public Node(E element, Node<E> next) {
			this.element = element;
			this.next = next;
		}
	}

	/**
	 * 根据索引找到节点对象
	 */
	private Node<E> node(int index) {
		rangeCheck(index);
		Node<E> node = first;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		return node;
	}

	public void clear() {
		size = 0;
		first = null;
	}

	public E get(int index) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		return node(index).element;
	}

	public E set(int index, E element) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		E old = node(index).element;
		node(index).element = element;
		return old;
	}

	public void add(int index, E element) {
		/*
		 * 最好：O(1)
		 * 最坏：O(n)
		 * 平均：O(n)
		 */
		rangeCheckForAdd(index);
		if (index == 0) { // 给空链表添加第一个元素的情况
			first = new Node<E>(element, first);
		} else {
			Node<E> prev = node(index - 1);
			prev.next = new Node<E>(element, prev.next);
		}
		size++;
	}

	public E remove(int index) {
		/*
		 * 最好：O(1)
		 * 最坏：O(n)
		 * 平均：O(n)
		 */
		rangeCheck(index);
		Node<E> node = first;
		if (index == 0) { // 删除第一个元素是特殊情况
			first = first.next;
		} else {
			Node<E> prev = node(index - 1); // 找到前一个元素
			node = prev.next; // 要删除的元素
			prev.next = node.next; // 删除元素
		}
		size--;
		return node.element;
	}

	public int indexOf(E element) {
		// 有个注意点, 如果传入元素为null, 则不能调用equals方法, 否则会空指针
		// 因此需要对元素是否为null做分别处理
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == null) return i;
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element.equals(element)) return i;
				node = node.next;
			}
		}
		return ELEMENT_NOT_FOUND;
	}

	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("[size=").append(size).append(", ");
		Node<E> node = first;
		for (int i = 0; i < size; i++) {
			if (i != 0) {
				string.append(", ");
			}
			string.append(node.element);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

虚拟头结点

有时候为了让代码更加精简，统一所有节点的处理逻辑，可以在最前面增加一个虚拟的头结点（不存储数据）。

在这里插入图片描述

带虚拟头结点的单向链表与普通单向链表代码类似：但是 add、reomove 略有不同；

package com.zj;

/**
 * 增加一个虚拟头结点
 * 单向链表
 * @author yusael
 */
public class LinkedList2<E> extends AbstractList<E> {

	private Node<E> first;

	public LinkedList2(){
		first = new Node<E>(null,null);
	}
	// 链表中的节点
	private static class Node<E> {
		E element; // 节点元素
		Node<E> next; // 节点指向下一个节点

		public Node(E element, Node<E> next) {
			this.element = element;
			this.next = next;
		}
	}

	/**
	 * 根据索引找到节点对象
	 */
	private Node<E> node(int index) {
		rangeCheck(index);
		Node<E> node = first.next;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		return node;
	}

	public void clear() {
		size = 0;
		first = null;
	}

	public E get(int index) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		return node(index).element;
	}

	public E set(int index, E element) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		E old = node(index).element;
		node(index).element = element;
		return old;
	}

	public void add(int index, E element) {
		/*
		 * 最好：O(1)
		 * 最坏：O(n)
		 * 平均：O(n)
		 */
		rangeCheckForAdd(index);
//		if (index == 0) { // 给空链表添加第一个元素的情况
//			first = new Node<E>(element, first);因为有了虚拟头结点，所以所有结点统一处理，不需要额外对第0个结点单独处理
			Node<E> prev = index == 0 ? first : node(index - 1);
			prev.next = new Node<E>(element, prev.next);
		size++;
	}

	public E remove(int index) {
		/*
		 * 最好：O(1)
		 * 最坏：O(n)
		 * 平均：O(n)
		 */
		rangeCheck(index);
//		Node<E> node = first;
//		if (index == 0) { // 删除第一个元素是特殊情况
//			first = first.next;因为有了虚拟头结点，所以所有结点统一处理，不需要额外对第0个结点单独处理
		Node<E> prev = index == 0 ? first : node(index - 1); // 找到前一个元素
		Node<E> node = prev.next; // 要删除的元素
		prev.next = node.next; // 删除元素
		size--;
		return node.element;
	}

	public int indexOf(E element) {
		// 有个注意点, 如果传入元素为null, 则不能调用equals方法, 否则会空指针
		// 因此需要对元素是否为null做分别处理
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == null) return i;
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element.equals(element)) return i;
				node = node.next;
			}
		}
		return ELEMENT_NOT_FOUND;
	}

	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("[size=").append(size).append(", ");
		Node<E> node = first;
		for (int i = 0; i < size; i++) {
			if (i != 0) {
				string.append(", ");
			}
			string.append(node.element);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

动态数组、链表复杂度分析

数组的随机访问速度非常快：elements[n] 的效率与 n 是多少无关；
在这里插入图片描述

动态数组缩容

如果内存空间有点紧张，动态数组有比较多的剩余空间（比如说剩余元素占总空间的一半的时候），可以考虑缩容的操作

private void trim(){
		int capacity = elements.length;
		int newCapacity = capacity >> 1;
		if (size >= (newCapacity) && capacity <= DEFAULT_CAPACITY){
			E[] newElements = (E[]) new Object[newCapacity];
			for (int i = 0; i < size; i++) {
				newElements[i] = elements[i];
			}
			elements = newElements;
		}
	}

如果扩容倍数，缩容时机设计的不恰当，可能会导致复杂度震荡

双向链表

双向链表可以提升链表的综合性能；
在这里插入图片描述
双向链表只有一个元素的情况：first、last 指向同一个节点
在这里插入图片描述

Demo

package com.zj;


/**
 * 双向链表
 * @author yusael
 */
public class DoubleLinkedList<E> extends AbstractList<E> {

	private Node<E> first;
	private Node<E> last;

	private static class Node<E> {
		E element;
		Node<E> prev; // 指向前驱节点
		Node<E> next; // 指向后继节点

		public Node(Node<E> prev, E element, Node<E> next) {
			this.prev = prev;
			this.element = element;
			this.next = next;
		}
		@Override
		public String toString(){
			StringBuilder sb = new StringBuilder();
			if(prev != null){
				sb.append(prev.element);
			}else{
				sb.append("null");
			}
			sb.append("_").append(element).append("_");
			if(next != null){
				sb.append(next.element);
			}else{
				sb.append("null");
			}
			
			return sb.toString();
		}
	}
	
	@Override
	public void clear() {
		size = 0;
		first = null;
		last = null;
	}

	@Override
	public E get(int index) {
		return node(index).element;
	}

	@Override
	public E set(int index, E element) {
		Node<E> node = node(index);
		E old = node.element;
		node.element = element;
		return old;
	}

	@Override
	public void add(int index, E element) {
		rangeCheckForAdd(index);

		// size == 0
		// index == 0
		if (index == size) { // 往最后面添加元素
			Node<E> oldLast = last;
			last = new Node<>(oldLast, element, null);
			if (oldLast == null) { // 这是链表添加的第一个元素
				first = last;
			} else {
				oldLast.next = last;
			}
		} else { // 正常添加元素
			Node<E> next = node(index);
			Node<E> prev = next.prev;
			Node<E> node = new Node<>(prev, element, next);
			next.prev = node;
			if (prev == null) { // index == 0
				first = node;
			} else {
				prev.next = node;
			}
		}
		size++;
	}

	@Override
	public E remove(int index) {
		rangeCheck(index);

		Node<E> node = node(index);
		Node<E> prev = node.prev;
		Node<E> next = node.next;
		
		if (prev == null) { // index == 0
			first = next;
		} else {
			prev.next = next;
		}
		
		if (next == null) { // index == size - 1
			last = prev;
		} else {
			next.prev = prev;
		}
		size--;
		return node.element;
	}

	@Override
	public int indexOf(E element) {
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == element) return i;
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element.equals(element)) return i;
				node = node.next;
			}
		}
		return ELEMENT_NOT_FOUND;
	}

	/**
	 * 根据索引找到节点
	 * 
	 * @param index
	 * @return
	 */
	private Node<E> node(int index) {
		rangeCheck(index);
		
		if (index < (size >> 1)) { // 索引小于一半从前往后找
			Node<E> node = first;
			for (int i = 0; i < index; i++) {
				node = node.next;
			}
			return node;
		} else { // 索引大于一半从后往前找
			Node<E> node = last;
			for (int i = size - 1; i > index; i--) {
				node = node.prev;
			}
			return node;
		}
	}
	
	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("[size=").append(size).append(", ");
		Node<E> node = first;
		for (int i = 0; i < size; i++) {
			if (i != 0) {
				string.append(", ");
			}
			string.append(node);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

双向链表 vs 单向链表
粗略对比一下删除的操作数量：操作数量缩减了近一半

有了双向链表，单向链表是否就没有任何用处了？

并非如此，在哈希表的设计中就用到了单链表
至于原因，在哈希表章节中会讲到

双向链表 vs 动态数组
动态数组：开辟、销毁内存空间的次数相对较少，但可能造成内存空间浪费（可以通过缩容解决）
双向链表：开辟、销毁内存空间的次数相对较多，但不会造成内存空间的浪费

如果频繁在尾部进行添加、删除操作，动态数组、双向链表均可选择
如果频繁在头部进行添加、删除操作，建议选择使用双向链表
如果有频繁的 （在任意位置）添加、删除操作，建议选择使用双向链表
如果有频繁的查询操作（随机访问操作），建议选择使用动态数组

加瓦糕手
关注
VC 单向链表 双向链表的例子.rar
07-10
VC 单向链表 双向链表的例子，一个很早的VC 代码了，用来演示如何创建链表和双向链表，供感兴趣的朋友参考吧。以下是部分代码： 　list.RemoveAll(); 　list.Insert(0,1); 　list.Insert(1,2); 　list.Insert(2,3); ...
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
单向链表与双向链表
qq_57106106的博客
07-29 924
可以解决顺序表存储空间上限，插入和删除效率低的问题链表：链式存储的线性表链表的组成：由一个个节点组成节点：由数据域和指针域组成数据域：存放数据的区域指针域：存放下一个节点地址的指针单向链表，双向链表，循环链表只能通过头节点或者头指针单向的访问后继节点的链表，称为单向链表。每个节点的指针域只记录其后继节点的地址。（火车结构）头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域。
java 单向链表 双向链表_单向链表和双向链表的区别的意义 - Java篇
weixin_29521135的博客
02-19 1517
链表是常用的数据结构，在Java中有很多基于链表的容器实现类，例如HashMap、LinkedList。但是这些链表有的是单向链表，有的是双向链表，那么他俩有什么不同呢？(以下源码均属于jdk1.8.0_101)单向链表只有后一节点指针，在节点删除，移动的时候，需要暂存前一节点，删除的时候将前一节点和后一节点连接，因为比双向链表少维护一个前节点，只在删除的时候暂存，所以比单向链表节省资源，但是增加...
单向链表和双向链表
XXYBMOOO的博客
12-11 1311
否则，遍历链表找到最后一个节点，然后将新节点插入到最后一个节点的后面。在 main 函数中，首先将头节点初始化为 NULL，然后使用 insert 函数向链表插入节点，并使用 printList 函数打印链表的内容。定义一个单向链表的节点结构体 Node，包含一个整型数据 data 和一个指向下一个节点的指针 next。双向链表相比于单向链表的优势在于它可以在常数时间内进行逆向遍历，因为每个节点都有一个指向前一个节点的指针。函数也与单向链表的实现相同，从头节点开始遍历链表，并打印每个节点的数据。
单向、双向链表
大树
12-08 2970
链表 一、介绍 1、介绍 ​ 链表是一种非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域 （1）单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针 （2）双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链
单向链表双向链表优缺点
qq_44981598的博客
09-06 439
2、缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。2、缺点：增加删除节点复杂，多需要分配一个指针存储空间。1、优点：可以找到前驱和后继，可进可退；1、优点：单向链表增加删除节点简单。
单向链表与双向链表区别
大伟伟的博客
10-25 7935
单向链表： 由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为null,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。 双向链表： 对于双向链表来说，它的每个节点要指向“直接前驱”和“直接后继”，所以节点类需要含有两个指针域。指向直接前驱的指针使用pre表示，指向后继的指针使用next表示。双向链表是在单向链表基础上的一个改进，每个节点指向其直接前驱和直接后继节点。因此，从双向链表的任
java 单向链表 双向链表_java 单向链表与双向链表的实现
weixin_31093677的博客
02-19 241
链表单向链表单向链表概念链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。这是一种物理结构，不是树那样的逻辑结构。链表和顺序表两种物理结构，说明的是数据元素在内存中是如何存储的。顺序表是连续顺序存储，例如数组。而链表是非连续非顺序的。基本API的java代码实现代码如下，实现基本的增查删改的功能。public class SinglyLinked...
深入解析双向链表与单向链表的区别：示例详解
qq_35320456的博客
07-14 998
深入解析双向链表与单向链表的区别：示例详解。。 链表是一种灵活的数据结构，它通过指针连接一系列节点，实现了动态数组的特性。在众多链表类型中，单向链表和双向链表是最为常见的两种。本文将重点探讨这两种链表的区别，并通过示例进行详细说明。
【数据结构与算法02】单向链表与双向链表
一个正在努力学习的iter
05-19 600
1. 单向链表 1.1 单向链表介绍 单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。 1.2 单向链表的API设计 1.3 单向链表的代码实现 import java.util.Iterator; public class LinkList<T> implements Iterable<T>{ //记录头结点 pri
【数据结构篇】手写双向链表、单向链表（超详细）
热爱编程、热爱生活、热爱探索
08-05 3162
什么是链表？链表（Linked List）是用链式存储结构实现的线性表。链表的组成数据域引用域（数据域和引用域合称结点或元素）数据域存放数据元素自身的数据引用域存放相邻结点的地址链表的特点链表中元素的联系依靠引用域具有线性结构的特点，链表所使用的逻辑结构是线性结构具有链式存储结构的特点，所使用的物理存储结构是链式存储链表的分类单向链表：单链表是一种最简的链表，只有一个引用域1next特点：通过next可以访问到后继结点，终端结点的引用域指向null双向链表：具有两个引用域prev和next。
数据结构 单向链表 双向链表 源程序
05-11
本文将深入探讨两种重要的线性数据结构——单向链表和双向链表，以及它们在实际编程中的应用。 单向链表是一种线性数据结构，它的每个元素（称为节点）包含两部分：数据域，用于存储实际的数据；指针域，用于存储下...
C语言自学链表，单向链表，双向链表，适合新手学习。
06-18
本资源提供的是针对初学者设计的链表学习材料，包括单向链表和双向链表的实现。下面将详细讲解这两种链表的数据结构及其操作。 1. **单向链表**： 单向链表是一种线性数据结构，每个节点包含两部分：数据域和指针...
【算法竞赛】堆
Sakura_ding的博客
10-01 995
堆是一种树形结构,树的根是堆顶,堆顶始终保持为所有元素的最优值。有最大堆和最小堆,最大堆的根节点是最大值,最小堆的根节点是最小值。本节都以最小堆为例进行讲解。堆一般用二叉树实现,称为二叉堆。二叉堆的典型应用有堆排序和优先队列。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 357
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 265
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 685
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1089
本文介绍了数据结构中的AVL树，给出了C++的代码实现
Python链表详解：单向与双向链表的实现
"Python单向链表和双向链表原理与用法实例详解" 在计算机科学中，链表是一种基础的数据结构，与数组不同，链表的元素不是在内存中连续存储的。它们通过指针相互链接，使得在插入和删除元素时具有较高的灵活性。本文...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值