Java实现带头结点的双向循环链表

最新推荐文章于 2022-11-07 20:01:14 发布
最新推荐文章于 2022-11-07 20:01:14 发布
阅读量1.8k 收藏 22
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44668898/article/details/102628312
版权

文章目录



一、什么是双向循环链表？

  1. 双向链表是每个结点除后继指针外还有一个前驱指针。和单链表类同，双向链表也有带头结点结构和不带头结点结构两种，带头结点的双向链表更为常用；另外，双向链表也可以有循环和非循环两种结构，循环结构的双向链表更为常用。

  2. 在双向链表中，每个结点包括三个域，分别是element域、next域和prior域，其中element域为数据元素域，next域为指向后继结点的对象引用，prior域为指向前驱结点的对象引用。

如下图是带头结点的循环双向链表的图示结构。循环双向链表的next和prior各自构成自己的循环单链表。
在这里插入图片描述



二、带头结点的双向循环链表的实现

1、接口的定义：

interface IList1{		//线性表的抽象数据Java接口
	public void clear();
	public boolean isEmpty();
	public int length();
	public Object get(int i) throws Exception;
	public void insert(int i, Object x) throws Exception;
	public void remove(int i) throws Exception;
	public int indexOf(Object x);
	public void display();
}

2、结点的定义：

class DuLNode{
	public Object data;
	public DuLNode prior;
	public DuLNode next;
	public DuLNode() {
		this(null);
	}
	public DuLNode(Object data) {
		this.data = data;
		this.prior = null;
		this.next = null;
	}
}

3、构造带头结点的双向循环链表：

class DuLinkList implements IList1{
	public DuLNode head;
	public DuLinkList() {
		head = new DuLNode();
		head.prior = head;
		head.next = head;
	}
}

4、插入元素：

public void insert(int i, Object x) throws Exception {
		// TODO Auto-generated method stub
		DuLNode p = head.next;
		int j = 0;
		while(!p.equals(head) && j<i) {
			p = p.next;
			++j;
		}
		if(j!=i && !p.equals(head))
			throw new Exception("插入位置不合法");
		DuLNode s = new DuLNode(x);
		p.prior.next = s;
		s.prior = p.prior;
		s.next = p;
		p.prior = s;
	}

5、用头插法创建带头结点双向循环链表：

public DuLinkList(int n) throws Exception{
		this();
		Scanner sc = new Scanner(System.in);
		for(int j=0; j<n; j++)
			insert(0,sc.next());
	}

6、清空双向循环链表：

public void clear() {
	head.data = null;
	head.next = null;
}

7、判断双向循环链表是否为空：

public boolean isEmpty() {
	return head.next == null;
}

8、返回双向循环链表的长度：

public int length() {
	DuLNode p = head;
	int len = 0;
	while(p.next!= head) {
		p = p.next;
		++len;
	}
	return len;
}

10、返回指定位置的元素：

public Object get(int i) throws Exception {
	DuLNode p = head.next;
	int j = 0;
	while(p != null && j<i) {
		p = p.next;
		++j;
	}
	if(j>i || p == null) {
		throw new Exception("第" +  i + "个元素不存在");
	}
	return p.data;
}

11、删除指定位置的元素：

public void remove(int i) throws Exception {
	DuLNode p = head.next;
	int j = 0;
	while(!p.equals(head) && j<i) {
		p = p.next;
		++j;
	}
	if(j!=i)
		throw new Exception("删除位置不合理");
	p.prior.next = p.next;
	p.next.prior = p.prior;
}

12、返回指定元素的位置：

public int indexOf(Object x) {
	DuLNode p = head;
	int j=0;
	while(p.next!=head) {
		if(p.next.data.equals(x))
			break;
		p = p.next;
		++j;
	}
	if(p.next != head)
		return j;
	else
		return -1;
}

13、遍历输出元素：

public void display() {
	DuLNode node = head.next;
	while(!node.equals(head)) {
		System.out.print(node.data + "");
		node = node .next;
	}
	System.out.println();
}


附上全部代码：

import java.util.Scanner;
interface IList1{		//线性表的抽象数据Java接口
	public void clear();
	public boolean isEmpty();
	public int length();
	public Object get(int i) throws Exception;
	public void insert(int i, Object x) throws Exception;
	public void remove(int i) throws Exception;
	public int indexOf(Object x);
	public void display();
}
class DuLNode{
	public Object data;
	public DuLNode prior;
	public DuLNode next;
	public DuLNode() {
		this(null);
	}
	public DuLNode(Object data) {
		this.data = data;
		this.prior = null;
		this.next = null;
	}
}
class DuLinkList implements IList1{
	public DuLNode head;
	public DuLinkList() {
		head = new DuLNode();
		head.prior = head;
		head.next = head;
	}
	public DuLinkList(int n) throws Exception{
		this();
		Scanner sc = new Scanner(System.in);
		for(int j=0; j<n; j++)
			insert(0,sc.next());
	}

	public void clear() {
		// TODO Auto-generated method stub
		head.data = null;
		head.next = null;
	}

	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return head.next == null;
	}
	
	public int length() {
		// TODO Auto-generated method stub
		DuLNode p = head;
		int len = 0;
		
		while(p.next!= head) {
			p = p.next;
			++len;
		}
		return len;
	}

	public Object get(int i) throws Exception {
		// TODO Auto-generated method stub
		DuLNode p = head.next;
		int j = 0;
		while(p != null && j<i) {
			p = p.next;
			++j;
		}
		if(j>i || p == null) {
			throw new Exception("第" +  i + "个元素不存在");
		}
		return p.data;
	}

	public void insert(int i, Object x) throws Exception {
		// TODO Auto-generated method stub
		DuLNode p = head.next;
		int j = 0;
		while(!p.equals(head) && j<i) {
			p = p.next;
			++j;
		}
		if(j!=i && !p.equals(head))
			throw new Exception("插入位置不合法");
		DuLNode s = new DuLNode(x);
		p.prior.next = s;
		s.prior = p.prior;
		s.next = p;
		p.prior = s;
	}

	public void remove(int i) throws Exception {
		// TODO Auto-generated method stub
		DuLNode p = head.next;
		int j = 0;
		while(!p.equals(head) && j<i) {
			p = p.next;
			++j;
		}
		if(j!=i)
			throw new Exception("删除位置不合理");
		p.prior.next = p.next;
		p.next.prior = p.prior;
	}

	public int indexOf(Object x) {
		DuLNode p = head;
		int j=0;
		while(p.next!=head) {
			if(p.next.data.equals(x))
				break;
			p = p.next;
			++j;
		}
		if(p.next != head)
			return j;
		else
			return -1;
	}

	public void display() {
		// TODO Auto-generated method stub
		DuLNode node = head.next;
		while(!node.equals(head)) {
			System.out.print(node.data + "");
			node = node .next;
		}
		System.out.println();
	}
}
public class Task_7_2 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		Scanner cin = new Scanner(System.in);
		System.out.print("输入双向循环链表的长度：");
		int n = cin.nextInt();
		
		DuLinkList L = new DuLinkList();
		System.out.print("用头插法依次输入双向循环链表的值：");
		for(int i=0; i<n; i++)
			L.insert(0, cin.nextInt());
		System.out.print("此时双向循环链表各元素的值：");
		L.display();
		
		L.insert(3,3);
		System.out.print("插入元素'3'后的双向循环链表：");
		L.display();
		
		System.out.println("此时双向循环链表的长度：" + L.length());
		
		L.remove(6);
		System.out.print("删除位置'6'后的双向循环链表：");
		L.display();
		
		System.out.print("输入要查找的位置：");
		int m = cin.nextInt();
		if(m>L.length() || L.get(m)==null) 
			System.out.println("该元素不存在！");
		else
			System.out.println("查找的位置上的值：" + L.get(m));
		
		System.out.print("输入要查找的值：");
		int k = L.indexOf(cin.nextInt());
		if(k!=-1)
			System.out.println("查找的值所在的位置：" + k);
		else
			System.out.println("该元素不存在！");
	}
}

运行结果：
在这里插入图片描述

程序员史迪仔
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java实现带头结点的双向链表
《落程魄序》作者“落魄哥”的博客
01-02 497
在上一篇文章中，我们分享了如何使用java创建带头结点的单向链表,今天我们分享如何使用java实现双向链表，双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。它的实现与单向链表及其相似，不同的就在add值，与remove值，具体的实现代码如下： ​ p...
带头节点的双向循环链表的基本操作
Ksaila的博客
08-30 1万+
双向循环链表： 双向循环链表中每一个节点都有一个直接的前驱和一个直接的后继 双向循环链表中的节点有两个指针域和一个存放数据的地方，两个指针域一个存放下一个节点的地址，一个存放前一个指针的地址 下面是双向循环链表的基本操作： CircularList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include&lt;stdlib.h...
java实现双向循环链表（循环双链表）
初心不忘、始终方得
04-20 5608
若是不清楚链表的结构，该篇文章不适合观看，这里只做文字说明，没有链表结构的图示
java实现双向链表(图解以及分析)
qq_54469537的博客
10-02 1808
详细分析以图解实现双向链表
带头双向循环链表讲解-思路清晰+画图+代码实现
Javaxaiobai的博客
11-07 675
更好去理解带头结点的双向循环链表的实现思路！精准的，有效的，高效的文章...
带头结点的双向循环链表
07-17
为了实现带头结点的链表，我们需要一个额外的头结点，其数据部分通常不存储有效信息，而是用来方便操作链表。 接下来，我们需要实现链表的一些基本操作，如创建、插入、删除节点以及遍历链表。创建链表时，首先创建...
java双向循环链表的实现代码
09-05
}/*** 获取双向循环链表的第一个节点* @return 链表头节点*/public BothwayLoopLinked getFirst(){if (linkedId == null) return null;BothwayLoopLinked first = this;while (first.prev != first) first = first....
带头结点的双向循环链表数据结构
01-08
总的来说，无论是C++还是Java实现，带头结点的双向循环链表都需要考虑链表的初始化、插入、删除、查找等基本操作，同时为了方便遍历，还需要实现相应的迭代器机制。这样的数据结构在处理需要双向访问数据的场景时...
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
双向循环链表--java实现
ZK_小小世界的专栏
12-23 4034
双向循环链表示意图： 双向循环链表实现代码：public class DoubleLink<E> { private class Node<E>{ public E value; //节点值 public Node<E> prev; //前一个节点 public Node<E> next; //后一个节点 public No
数据结构之带头结点的双向循环链表（含全部代码）
qq_61635026的博客
04-12 1050
数据结构之带头结点的双向循环链表
java数据结构与算法之双链表设计与实现
zejian的博客
11-06 2万+
转载请注明出处（万分感谢！）： http://blog.csdn.net/javazejian/article/details/53047590 出自【zejian的博客】 关联文章:java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现  上一篇文章分析顺序表和单链表，本篇就接着上篇继续聊链表，在单链表分析中，我们可以知道每个结点只有一个指向后
JAVA详解双向循环链表（参照java.util.LinkedList）
tu451953337的专栏
07-03 7736
public class DbLinkedList { //定义内部类，用作链表的节点 private class Node { Node pre; //指向前一个节点 Node next; //指向后一个节点 T value; //当前节点的值 public Node(T value, Node next, Node pre) { this.value
线性表的链式存储结构——双链表
melodyzhan的博客
10-06 159
线性表的链式存储结构——双链表
java基础-双向循环链表
热门推荐
专注于Java架构学习 https://gitee.com/laokouyun https://github.com/KouShenhai
10-29 3万+
小伙伴们，你们好呀！我是老寇！ 前文介绍了java基础-链表 双向循环链表就是链表的升级版，多了有头，尾指针之分，指针的方向是双向的！！！ 首先创一个节点类： package cn.itcast.huahai.linklist; //AnyType表示任意类型 public class DulNode<AnyType>{ public AnyType data;//数值 public DulNode<AnyType> next;//前驱节点 publi.
循环单链表基本操作的java代码实现（使用java语言实现循环单链表的创建【头插】【尾插】、插入）
weixin_38334306的博客
07-10 660
循环双链表节点结构定义 /** * className:Node * * @author:zjl * @version:0.1 * @date:2020/7/1016:35 * @since:jdk1.8 */ public class Node { private Object data; private Node next; public Node(Object data, Node next) { this.data = data;
java实现带头双向循环链表(附完整源码)
最新发布
06-08
以下是Java实现带头双向循环链表的完整源码，供参考： ``` public class DoublyCircularLinkedList<T> { private Node<T> head; // 头节点 // 节点类 private static class Node<T> { T data; Node<T> prev; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值