Java基础 - 线性表之链式存储结构-双向链表

最新推荐文章于 2022-05-10 10:34:51 发布
最新推荐文章于 2022-05-10 10:34:51 发布
阅读量481 收藏
点赞数
分类专栏： Java基础 文章标签： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ApatheCrazyFan/article/details/53054862
版权

如果为每个节点保留两个引用prev和next，让prev指向当前节点的上一个节点，让next指向当前节点的下一个节点，此时的链表既可以向后依次访问每个节点，也可以向前依次访问链表的每个节点，这种形式的链表被称为双向链表。示意图如下：


双向链表是一种对称结构，它克服了单链表上指针单向性的缺点，其中每个节点既可以向前引用，也可以向后引用，
这样可以方便地插入、删除数据元素。

与单链表相似的是，如果将链表的header节点与tail节点连在一起就构成了双向循环链表。

1、双向链表的查找
由于双向链表既可以从header节点开始依次向后搜索每个节点，也可以从tail节点依次向前搜索每个节点，因此
当程序试图从双向链表值搜索指定索引处的节点时，既可以从该链表的header节点开始搜索，也可以从该链表的tail
节点开始搜索。至于到底是应该从header节点开始搜索还是从tail节点开始搜索，则取决于被搜索的节点是更靠近header还是tial节点。

一般来说，可以通过被搜索index的值来判断它更靠近header还是更靠近tail。如果index < size/2;则说明它更靠近header；反之，，则可判断
它更靠近tail节点，那就应该从tail节点开始搜索。


2、双向链表的插入
双向链表的插入更加的复杂，向双向链表中插入一个新节点必须同时修改两个方向的指针（即引用）。如下图所示双向链表的插入操作：

3、双向链表的删除
在双向链表中删除一个节点也需要同时修改两个方向的指针，双向链表中的删除操作如下示意图：


下面是代码实现：

/**
 * 双向链表
 * @author wb
 *
 */
public class DuLinkList<T> {

	//定义一个内部类，也就是节点
	private class Node{
		//保存数据元素
		private T data;
		//向前引用
		private Node prev;
		//向下引用
		private Node next;

		@SuppressWarnings("unused")
		public Node(){
		}

		public Node(T data, Node prev, Node next){
			this.data = data;
			this.prev = prev;
			this.next = next;
		}
	}

	private Node header;
	private Node tail;
	public int size;
	//双向链表初始化1
	public DuLinkList(){
		header = null;
		tail = null;
		size = 0;
	}
	//双向链表初始化2
	public DuLinkList(T element){
		header = new Node(element, null, null);
		tail = header;
		size ++;
	}

	//返回该双向链表的长度
	public int size(){
		return size;
	}

	//判断双向链表是否为空链表
	public boolean isEmpty(){
		return size == 0;
	}

	//清空双向链表
	@SuppressWarnings("null")
	public void clear(){
		Node clearNode = header;
		for(int i = 0; i < size && clearNode != null; i ++,clearNode = clearNode.next){
			clearNode = null;
		}

		header = null;
		tail = null;
		size = 0;
	}
	//返回索引 index处的数据元素
	public T get(int index){
		return getNodeByIndex(index).data;
	}

	//返回索引 index处的节点
	private Node getNodeByIndex(int index) {
		errMsgForGetNodeByIndexOutOfArraysBounds(index);
		//根据索引的值判断是从header开始搜索还是从tail开始搜索
		if(index <= size/2){
			//从header开始搜索
			Node current = header;
			for(int i = 0; i <= size/2 && current != null; i ++,current = current.next){
				if(i == index){
					return current;
				}
			}
		}else{
			//从tail开始搜索
			Node current = tail;
			for(int i = size - 1; i > size/2 && current != null; i --,current = current.prev){
				if(i == index){
					return current;
				}
			}
		}
		return null;
	}

	//获取指定元素在双向链表中的第一个索引位置
	public int indexOf(T element){
		if(isEmpty()){
			return -1;
		}
		Node current = header;
		for(int i = 0; i < size && current != null; i ++, current = current.next){
			if(current.data == element){
				return i;
			}
		}
		return -1;
	}
	//获取指定元素在值相等的情况下的第一个在双向链表中的索引位置
	public int locate(T element){
		if(isEmpty()){
			return -1;
		}
		Node current = header;
		for(int i = 0; i < size && current != null; i ++, current = current.next){
			if(current.data.equals(element)){
				return i;
			}
		}
		return -1;
	}

	//向双向链表的index索引位置插入数据元素 element
	public void insert(int index, T element){
		errMsgForInsertIndexOutOfArraysBounds(index);

		//如果还是空链表
		if(header == null){
			//采用尾插法
			addAtTail(element);
		}else{
			//插入的是双向链表的第一个位置
			if(index == 0){
				addAtHeader(element);
			}else{
				//插入位置前一个节点
				Node preNode = getNodeByIndex(index - 1);
				//要插入的新节点
				Node newNode = new Node(element, preNode, preNode.next);

				preNode.next = newNode;

				newNode.next.prev = newNode;

				size ++;
			}
		}
	}

	//采用头插法向双向链表插入数据元素 element
	public void addAtHeader(T element){
		//创建next指向原链表的第一个节点
		//并把它重新作为header
		header = new Node(element, null, header);
<span style="white-space:pre">		</span>header.next.prev = header;
		/**
		 * Node newNode = new Node(element, null, header);
		 * header.prev = newNode;
		 * header = newNode;
		 */

		//如果插入前为空链表
		if(tail == null){
			tail = header;
		}
		size ++;
	}
	//采用尾插法向双向链表插入数据元素 element
	public void addAtTail(T element){
		//如果插入前为空链表
		if(header == null){
			header = new Node(element, null, null);
			tail = header;
		}else{
			//完成新加的节点指向前面的节点
			Node newNode = new Node(element, tail, null);
			//完成节点指向后面的新添加的节点
			tail.next = newNode;
			//收尾
			tail = newNode;
		}
		size ++;
	}

	//删除并返回双向链表中指定索引处的元素
	public T delete(int index){
		errMsgForDeleteIndexOutOfArraysBounds(index);

		Node del;
		//要删除双向链表中的第一个元素+节点
		if(index == 0){
			del = header;
			header = header.next;
			header.prev = null;
			//要删除双向链表中的最后一个元素+节点
		}else if(index == size - 1){
			del = tail;
			tail = tail.prev;
			tail.next = null;
		}else{
			Node preNode = getNodeByIndex(index - 1);

			del = preNode.next;

			preNode.next = del.next<span style="font-family: Arial, Helvetica, sans-serif;">;</span>

			del.next.prev = preNode;
			

			del.next = null;
			del.prev = null;
		}

		return del.data;
	}

	//删除并返回双向链表中最后的元素
	public T remove(){
		return delete(size - 1);
	}

	//该双向链表的toString方法
	public String toString(){
		if(isEmpty()){
			return "[]";
		}else{
			StringBuffer sb = new StringBuffer("[");

			Node current = header;
			for(int i = 0; i < size && current != null;current = current.next){
				sb.append(current.data.toString() + ",");
			}
			return sb.toString().substring(0, sb.length() - 1) + "]";
		}
	}
	//该双向链表的headerToString方法
	public String headerToString(){
		if(isEmpty()){
			return "[]";
		}else{
			StringBuffer sb = new StringBuffer("[");

			for(Node current = header; current != null; current = current.next){
				sb.append(current.data.toString() + ",");
			}
			return sb.toString().substring(0, sb.length() - 1) + "]";
		}
	}
	//该双向链表的tailToString方法
	public String tailToString(){
		if(isEmpty()){
			return "[]";
		}else{
			StringBuffer sb = new StringBuffer("[");

			for(Node current = tail; current != null; current = current.prev){
				sb.append(current.data.toString() + ",");
			}
			return sb.toString().substring(0, sb.length() - 1) + "]";
		}
	}
	
	
	
	
	private void errMsgForGetNodeByIndexOutOfArraysBounds(int index){
		if(index < 0 || index > size - 1){
			throw new IndexOutOfBoundsException( "双向链表索引越界：" + index );
		}
	}
	private void errMsgForDeleteIndexOutOfArraysBounds(int index){
		if(index < 0 || index > size - 1){
			throw new IndexOutOfBoundsException( "双向链表索引越界：" + index );
		}
	}
	private void errMsgForInsertIndexOutOfArraysBounds(int index){
		if(index < 0 || index > size){
			throw new IndexOutOfBoundsException( "双向链表索引越界：" + index );
		}
	}

}

测试类如下： 

import com.yc.list.DuLinkList;

public class DuLinkListTest {
	public static void main(String[] args) {
		DuLinkList<Student> list = new DuLinkList<Student>();
		
		Student s = new Student("WB","湖南工学院",22);
		list.addAtTail( s );
		list.addAtTail(new Student("SJX","高铁学院",22));
		System.out.println( list.tailToString());
		System.out.println( list.headerToString());
		System.out.println();
		
		
		list.addAtHeader(new Student("QYB", "湖南工学院", 23));
		System.out.println( list.tailToString());
		System.out.println( list.headerToString());
		System.out.println();
		
		list.insert(1, new Student());
		System.out.println( list.tailToString());
		System.out.println( list.headerToString());
		System.out.println();

		list.remove();
		System.out.println( list.tailToString());
		System.out.println( list.headerToString());
		System.out.println();
		
		
		list.delete(1);
		System.out.println( list.tailToString());
		System.out.println( list.headerToString());
		System.out.println();
		
		System.out.println(list.indexOf(new Student("WB","湖南工学院",22)));
		System.out.println(list.locate(new Student("WB","湖南工学院",22)));
	}
}


测试结果为：

从上面的程序可以看出，由于双向链表需要同时维护两个方向的指针，因此添加节点、删除节点时的指针维护成本更大;但双向链表具有两个方向的指针，
因此可以向两个方向搜索节点，因此双向链表在搜索节点。删除指定索引处的节点时具有较好的性能。




ApacheCrazyFan
关注
专栏目录
线性表的Java实现--链式存储（双向链表）
生命在于折腾
05-06 1300
线性表的Java实现--链式存储（双向链表） 有了单向链表的基础，双向链表的实现就容易多了。   双向链表的一般情况：  增加节点：   删除节点：   双向链表的Java实现： package com.liuhao.algorithm; public class DuLinkList { /** * 内部类：链表中的一个节点 * * @auth
数据结构与算法学习总结-线性表的链式存储与实现
空谷回响的编码史
02-21 880
　　实现线性表的另一种方法时链式存储，即用指针将存储线性表中数据元素的那些单元依次串联在一起。这种方法避免了再数组中用练习的单元存储元素的缺点，因而在执行插入或删除运算时，不再需要移动元素来腾出空间或填补空缺。相应的，我们需要再每个单元中设置指针来表示表中元素之间的逻辑关系，因而增加了额外的存储空间的开销。 1.单链表 　　链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至...
线性表(单向)链式存储 - Java实现
淦淦淦！
06-19 143
单向链式存储实现 package com.kiger.Link; /** * @ClassName LinkList * @Description 单向链表实现 * @Author zk_kiger * @Date 2019/6/19 9:36 * @Version 1.0 */ public class LinkList<T> { // 定义一个内部类Node...
线性表的链式存储结构（java版）
小学徒成长专栏
02-27 178
在前面，我们已经讲了线性表的顺序存储结构（java版） ，我们也知道了他的代码实现，在了解之后，我们很容易就能够发现他有一个最大的缺点，就是插入和删除需要移动大量的元素，这显然是很耗费时间的，于是，为了解决这个问题，就出现了链式存储结构。   我学习的时候是看程杰的《大话数据结构》的，同时结合我们的经典教材清华出版社的《数据结构》，但是在学习过程中，我不小心把“插入到第i个位置之后”理解成了...
java实现线性表链式存储结构
m0_37860420的博客
11-08 383
定义结点 public class Node { private int data; private Node next; public Node() {} public Node(int data){ this.data= data; } public Node(int data,Node next) { this.data=data; this.n...
漫话数据结构-线性表的链式存储.pptx
最新发布
11-03
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型的数据元素构成，元素之间存在着一对一的线性关系。线性表的链式存储是相对于顺序存储的一种方式，尤其适用于动态变化的数据集合。 在链式存储中...
线性表之链表原理与实现
Lessen的博客
05-23 985
1、链表的存储结构   之前我们讲过顺序表，顺序表的特点就是数据之间逻辑上的相邻关系在物理位置上也是相邻的，因此它可以通过寻址公式随机存取任意一个元素，但是这种特点也为元素的删除和插入带来了极大的不便。链表的特点就是：元素之间逻辑上的相邻关系在物理位置上并不一定相邻，元素的物理地址可以是任意一个合法的地址，这些元素通过指针联系在一起形成了一条链式结构，这样的结构在插入和删除操作时就不需要挪动元素位置，只是通过简单的修改指针的指向就可以了，因此理论上它的时间复杂度为O(1)，同时，由于这种特性，因此每个元素的
线性表的链式存储与实现
07-29
在链式存储的线性表中，主要有单链表和双向链表两种形式： 1. 单链表：每个节点只有一个指向下一个节点的指针，最后一个节点的指针为空，表示链表的结束。单链表的插入和删除操作相对简单，只需要修改相邻节点的...
Java数据结构与算法-线性表（详细实现）
qq_41649001的博客
07-25 3388
线性表（Linear List） 2.1 什么是线性表 零个或多个数据元素的有限序列。 非空线性表的逻辑结构特征 有且仅有一个开始结点，无直接前趋，有且只有一个直接后继 有且仅有一个结束结点，有且只有一个直接前趋，无直接前驱。 内部结点都有且只有一个直接前趋和一个直接后继 对于同一线性表，数据类型一直，数据元素长度一致。 2.2 线性表基本运算 基本运算包括 initList 初始化操作，建立一个空的线性表 listEmpty 若线性表为空，返回true，否则返回false
java双向链链_线性表的Java实现--链式存储（双向链表）
weixin_28831399的博客
03-08 77
有了单向链表的基础，双向链表的实现就容易多了。双向链表的一般情况：增加节点：删除节点：双向链表的Java实现：packagecom.liuhao.algorithm;publicclassDuLinkList{/***内部类：链表中的一个节点**@authorliuhaodata节点中的数据prev指向前一个节点的引用next指向下一个节点的引用*/privatecla...
Java数据结构之线性结构-线性表-双向链式存储（双向链表）
jiu_yu的博客
08-08 161
双向链表结构 添加节点 删除节点 删除节点要注意判断待删除节点的下一个节点是否为空，因为他最终要指向待删除节点的前一个结点。尤其要注意数组空指针异常。 源代码 package linearSturcture; /** * 线性结构-线性表-双向链式存储（双向链表） * @author cx998 * */ public class BidirectionalLinkedStorage { private BidirectionalNode root;//根节点 private int .
JAVA数据结构之线性表的链式存储结构——双向链表
Gold_Roc的博客
07-06 270
1、结点类Node的代码如下所示： public class Node { public Object data;//结点中的数据 public Node pre;//指向前一个结点的指针域 public Node next;//指向下一个结点的指针域 public Node(Object data){ this.data = data; } } 2、双向链表的实现类DLink
一个可以增删改查插的线性表（二）
HanMamnHanah的博客
03-28 309
    美好一天度过了一半，写完这个增加了新功能的线性表我就去收被子了，再晒就热的盖不了了orz    接着上次的功能继续添加，过段时间我会更新一下，加入测试函数和BubbleSortEx( )，好了开始吧，首先介绍一下各个函数的功能：给一个顺序表进行初始化void SeqListInit(SeqList* seq);  将一个元素插入到顺序表的末尾 void SeqListPushBack(Se...
线性表顺序结构增删改查
Hanani_Jia的博客
09-24 4101
上次的博客我写了对于线性表的两种简单实现，今天我写一下对于线性表顺序结构的增、删、改、查的几种方式的实现。 #include char v[30];//上来你要设定一个数组来存储你的数据，这个数组的长度一定要大于你的数据个数。 int n; void build();//声明两个函数 一个是创建这个数组来存储数据 void display();//声明输出函数 void main()
【数据结构】——链式存储结构之双向链表
维欣~fighting✔
04-12 3209
文章目录一、双向链表存储结构1、了解2、定义3、结构二、双链表的结构设计三、初始化四、插入操作1、开辟新结点pnewnode2、分析3、头插:将元素插入头结点之后3、尾插：将元素插入整个链表的尾部4、获取当前的链表长度：判断位置是否合理5、按位置插入（pos为插入位置）四、删除操作1、判空2、头删：删除头结点的下一个结点3、尾删：删除尾部结点4、按位置删除五、查询单链表 一、双向链表存储结构 1、...
java双向链表详解
wang20010104的博客
05-10 2774
java双向链表详解
java使用数组实现线性表功能（增、删、查、改）
funcy的专栏
04-03 2355
新建一个Array类：package demo; public class Array { private int elements; //元素下标 private long[] arr; //数组 public Array(){ arr=new long[50]; //默认初始长度为50 } public Array(int maxleng){ //自定义
Java数据结构深度解析：线性表与链式存储
单链表是一种简单的链式存储结构，每个节点包含两部分：数据域，用于存储数据元素；指针域，用于存储指向下一个节点的引用。在Java中，我们可以定义一个接口`Node`来规范节点的行为，如获取和设置数据的方法。接着，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值