详解双向循环链表的实现及概念

最新推荐文章于 2024-03-26 19:21:06 发布
最新推荐文章于 2024-03-26 19:21:06 发布
阅读量945 收藏 7
点赞数 2
分类专栏： 数据结构与算法 笔记 文章标签： 链表 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cout_s/article/details/118996243
版权

解剖双向循环链表！！！

在这里插入图片描述

双向循环链表概念

双向链表也叫双链表，是链表的一种，它的每个数据结点都有两个指针，分别指向后继和直接前区。所以，从双向链表中的任意一个结点开始，都可以很方便的访问到它的前驱结点和后继结点。如下图：
在这里插入图片描述
可以看出双向循环链表的继承体系，依然实现了List接口！
在这里插入图片描述

实现流程图

当此时只有一个结点元素
在这里插入图片描述
此时创建样式如下：
在这里插入图片描述

一.元素的添加，链表长度大于等于1时
1.在双向循环链表的表头添加元素
在这里插入图片描述
先断掉头结点的前继然后在指向新节点的前继
在这里插入图片描述
最后将head的前继指向新节点，新节点的后继指向head，再把head重新指向新节点，最后把tail结点的后继指向head结点
在这里插入图片描述
2.表尾添加一个新元素
在这里插入图片描述
表尾添加一个元素是先断掉表尾元素的后继重新指向新节点的后继
在这里插入图片描述
接着将tail的后继重新指向给新节点，新节点的前继指向tail结点，最后tail指向新节点，head的前继指向tail结点
在这里插入图片描述
3.中间添加元素
当前一个新节点，add添加到中间插入时
在这里插入图片描述
首先我们要找到当前插入结点位置的前一个结点，找到之后也就是图中的结点P，在找到后继结点q，此时把p的后继结点指向新节点，新节点的前继指向p，q的前继指向新节点，新节点的后继指向q。此时便，添加完成！
在这里插入图片描述
二.元素的删除
1.删除此时的头结点
在这里插入图片描述
删除头结点首先是将头结点的前继指向后一个node结点的前继续，此时将head的前继设为null，把头结点的后继置为null，再把head重新指向node结点，最后把尾节点的后继指向新head结点
在这里插入图片描述
最后删除头结点完成
在这里插入图片描述
2.删除尾节点
在这里插入图片描述
删除尾接点时，首先将尾节点的后继指向上一个结点的后继，并将尾结点的前继置为null，后继为null，最后把tail指向node结点，再把头结点的前继指向tail结点
在这里插入图片描述
在这里插入图片描述
3.删除中间元素
在这里插入图片描述
首先找到删除结点的前继和后继结点
在这里插入图片描述
将p的后继指向r结点，r的前继指向p结点
在这里插入图片描述
最后将q的前继和后继都置为null，中间删除元素便完成了！
在这里插入图片描述

实现代码

第一部分List接口

package com.my.接口;

import java.util.Comparator;

public interface
/*
 * List是线性结构的接口
 * 里面定义了该线性结构的一些通用操作 并支持泛型
 * 继承自Iterable接口（可迭代接口） 主要用于遍历数据结构
 * 其次还有让我们的类可以被foreach循环使用
 * 不是所有的数据结构都可以像数组一样通过角标来访问元素
 */
List<E> extends Iterable<E> {
	 /**
     * 在线性结构的末尾添加一个元素element
     * */
    public void add(E element);
    /**
     * 在线性结构指定角标index处添加一个元素element
     * */
    public void add(int index,E element);
    /**
     * 在线性结构中删除指定元素element
     * */
    public void remove(E element);
    /**
     * 在线性结构中删除指定角标index处的元素，并返回
     * */
    public E remove(int index);
    /**
     * 在线性结构中获取指定角标处index的元素
     * */
    public E get(int index);
    /**
     * 在线性结构中修改指定角标处index的元素为新元素element
     * */
    public E set(int index,E element);
    /**
     * 获取线性结构中有效元素的个数
     * */
    public int size();
    /**
     * 获取指定元素element在线性结构中的角标
     * */
    public int indexOf(E element);
    /**
     * 查看线性表中是否包含指定元素element
     * */
    public boolean contains(E element);
    /**
     * 查看线性结构是否为空
     * */
    public boolean isEmpty();
    /**
     * 清空线性结构
     * */
    public void clear();
    /**
     * 对线性结构按照比较器comparator的定义来进行排序
     * */
    public void sort(Comparator<E> comparator);
    /**
     * 获取线性结构中从指定fromIndex角标开始到toIndex角标结尾的所有元素
     * (0 <= fromIndex < toIndex < size)
     * [fromIndex,toIndex)
     * */
    public List<E> sublist(int fromIndex,int toIndex);

}

第二部分LinkedList双向循环链表

package com.my.线性结构;

import java.util.Comparator;
import java.util.Iterator;

import com.my.接口.List;

public class LinkedList<E> implements List<E> {

	private class Node{
		Node pre;
		Node next;
		E data;
		public Node(E data) {
			this.data =data;
			next = null;
			pre = null;
		}
		@Override
		public String toString() {
			// TODO 自动生成的方法存根
			return data.toString();
		}
	}
	private Node head;
	private Node tail;
	private int size;
	public LinkedList() {
		head =null;
		tail = null;
		size =0;
	}
	@Override
	public Iterator<E> iterator() {
		// TODO 自动生成的方法存根
		return null;
	}

	@Override
	public void add(E element) {
		// TODO 自动生成的方法存根
		add(size,element);
	}

	@Override
	public void add(int index, E element) {
		// TODO 自动生成的方法存根
		if(index<0||index>size) {
			throw new IndexOutOfBoundsException("Index is bound!");
		}
		Node node  = new Node(element);
		if(size==0) {//此时表中无元素
			node.pre = node;
			node .next=node;
			head = node;
			tail = node;
		}else if(index==0) {//表头添加元素
			node.pre = head.pre;
			node.next = head;
			head.pre = node;
			head = node;
			tail.next = head;
		}else if(index == size) {//表尾添加
			node.next = tail.next;
			tail.next = node;
			node.pre=tail;
			tail =node;
			head.pre =tail;
		}else {//其他情况 也就是在中间添加元素
			Node p =head;
			for(int i=0;i<index-1;i++) {
				p = p.next;
			}
			Node q = p.next;
			p.next=node;
			node.pre=p;
			q.pre=node;
			node.next=p;
		}
		size++;
	}

	@Override
	public void remove(E element) {
		// TODO 自动生成的方法存根
		remove(size);
	}

	@Override
	public E remove(int index) {
		// TODO 自动生成的方法存根
		if(index<0||index>=size) {
			throw new IndexOutOfBoundsException("Index is bound!");
		}
		E ret =null;
		if(size==1) {//只有一个元素
			ret = head.data;
			head =null;
			tail =null;
			size =0;
		}
		else if(index==0) {
			ret = head.data;
			Node node = head.next;
			node.pre = head.pre;
			head.next=null;
			head.pre =null;
			head =node;
			tail.next = head;
		}else if(index==size-1) {
			Node node = tail.pre;
			ret = tail.data;
			node.next = tail.next;
			tail.pre = null;
			tail.next = null;
			tail =node;
			head.pre = tail;
		}else {
			Node p,q,r,node =head;
			for(int i=0;i<index-1;i++) {
				head = head.next;
			}
			p = node;
			q=p.next;
			ret = q.data;
			r=q.next;
			p.next=r;
			r.pre=p;
			q.next=null;
			q.pre=null;
		}
		size--;
		return ret;
	}
	@Override
	public String toString() {
	// TODO 自动生成的方法存根
	StringBuilder sb =new StringBuilder();
	sb.append('{');
	Node node =head;
	while(node.next!=head) {
		sb.append(node.data);
		node =node.next;
		sb.append(',');
	}
	sb.append(node.data);
	sb.append('}');
	return sb.toString();
	}
	@Override
	public E get(int index) {
		// TODO 自动生成的方法存根
		if(index<0||index>=size) {
			throw new IndexOutOfBoundsException("Index is bound!");
		}
		E ret = null ;
		if(index<size/2) {
			Node p = head;
			for(int i=0;i<index;i++) {
				p =p.next;
			}
			ret = p.data;
		}else {
			Node q = tail;
			for(int i=size-1;i>index;i--) {
				q = q.pre;
			}
			ret = q.data;
		}
		return ret;
	}

	@Override
	public E set(int index, E element) {//根据指定下标修改元素
		// TODO 自动生成的方法存根
		if(index<0||index>=size) {
			throw new IndexOutOfBoundsException("Index is bound!");
		}
		E ret = null ;
		if(index<size/2) {
			Node p = head;
			for(int i=0;i<index;i++) {
				p =p.next;
			}
			ret = p.data;
			p.data = element;
		}else {
			Node q = tail;
			for(int i=size-1;i>index;i--) {
				q = q.pre;
			}
			ret = q.data;
			q.data = element;
		}
		return ret;
	}

	@Override
	public int size() {//获取有效长度
		// TODO 自动生成的方法存根
		return size;
	}

	@Override
	public int indexOf(E element) {//查找元素的下标
		// TODO 自动生成的方法存根
		if(isEmpty()) {
			try {
				throw new IllegalAccessException("NULL!");
			} catch (IllegalAccessException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
		Node node =head;
		for(int i=0;i<size;i++) {
			if(node.data.equals(element)) {
				return i;
			}
			node = node.next;
		}
		return -1;
	}

	@Override
	public boolean contains(E element) {
		// TODO 自动生成的方法存根
		return indexOf(element)!=-1;
	}

	@Override
	public boolean isEmpty() {
		// TODO 自动生成的方法存根
		return size==0;
	}

	@Override
	public void clear() {
		// TODO 自动生成的方法存根
		head =null;
		tail =null;
		size =0;
		
	}

	@Override
	public void sort(Comparator<E> comparator) {
		// TODO 自动生成的方法存根
		if(comparator==null) {
			throw new IndexOutOfBoundsException("Is NULL!");
		}
		if(size<2) {
			return;
		}
		Node i = head.next;
        Node j = null;
        Node k = null;
        E e = null;
        while(i!=head) {
        	e = i.data;
        	j =i;
        	k = j.pre;
        	while(k!=tail&&comparator.compare(k.data, e)>0) {
        		j.data = k.data;
                j = j.pre;
                k = j.pre;
        	}
        	j.data = e;
            i = i.next;
        }
		
	}

	@Override
	public List<E> sublist(int fromIndex, int toIndex) {
		// TODO 自动生成的方法存根
		if (fromIndex < 0 || toIndex >= size || fromIndex >= toIndex) {
            throw new IllegalArgumentException("sublist index outof range");
        }
		Node nodeA = head;
		for(int i=0;i<fromIndex;i++) {
			nodeA = nodeA.next;
		}
		Node nodeB = head;
		for(int i=0;i<toIndex;i++) {
			nodeB = nodeB.next;
		}
		LinkedList<E> newList = new LinkedList<>();
		while(nodeA!=nodeB) {
			newList.add(nodeA.data);
			nodeA = nodeA.next;
		}
		return newList;
	}

}

测试代码

package com.my.线性结构;

public class TestS {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		LinkedList list =new LinkedList<>();
		list.add(new Integer(1));
		list.add(new Integer(2));
		list.add(new Integer(3));
		list.add(new Integer(4));
		list.add(new Integer(5));
		list.add(new Integer(6));
		list.set(5, 10);
		LinkedList list1 =new LinkedList<>();
		list1 = (LinkedList) list.sublist(0, 3);
		System.out.println(list.remove(0));
		System.out.println(list.get(4));
		System.out.println(list.indexOf(new Integer(3)));
		System.out.println(list);
	}

}

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

牛牛最爱喝兽奶
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
C语言单循环链表的表示与实现实例详解
01-20
这种方式在单向和双向链表中皆可实现。要转换一个循环链表，可以选择开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点。再来看另一种方法，循环链表可以被视为“无头无尾”。这种列表很利于节约数据存储...
双向循环链表详解及C语言简单实现
Serendipity_Shy
12-27 688
双向循环链表详解及C语言简单实现
数据结构——双向循环链表
qq_67611811的博客
08-28 2067
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
linux内核之双向循环链表
weixin_44235286的博客
10-30 817
list内核链表操作
[C语言数据结构]双向循环链表
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-10 1389
上次我们学习了单链表的实现，相对于双向循环链表来说，单链表的各中操作，比如说增删查改等都显得非常麻烦。所以接下来来学习一下双向循环链表吧！
双向循环链表详解及其基本功能的实现
m0_56808122的博客
01-25 3492
文章目录循环链表概念定义节点类型及初始化销毁链表链表头插链表尾插特定位置插入链表头删链表尾删特定位置删除查找节点获取节点个数判断链表是否为空打印链表 循环链表概念 在单链表详解中我们提到了链表的几种基本的结构，在这里要详细讲到的就是带头双向循环链表，其结构如下： 该链表拥有1个头节点，且每个节点都有一个前驱指针和一个后继指针，分别用来保存前一个节点的地址和后一个节点的地址，这样就能够实现链表的双向访问的功能，需要注意的是链表的最后一个节点的后继指针指向头节点，头节点的前驱指针指向最后一个节点，带头双向循环
c++ STL 之双向循环链表—— list 详解
最新发布
zhhg0123的博客
03-26 544
list 是stl的一个关联容器,名叫“双向循环链表”，何为“双向循环链表”？其实就是一个数组，但有了数组何必还需链表？
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5213
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
【C语言数据结构】双链表详解（带头双向循环链表）
谁在夜里看海.的博客
04-05 2270
我们把要存放的数据类型重命名，接着定义一个含有三个参数的结构体，分别用于存放数据，指向下一节点与指向上一节点。}ListNode;我们在进行插入操作以及建立头节点的时候都需要进行申请节点的操作，因此我们可以把它分装成一个函数。不管是进行插入还是删除操作，我们都需要传入哨兵位头节点，我们可以把哨兵位头节点的创立也分装成一个函数。然后剩下的的就是链表的通用功能：增删查改，pos位置的插入与删除以及链表的销毁。//双链表申请一个新节点// 创建返回链表的头结点// 双向链表打印。
C语言——详解带头双向循环链表 增删查改
qq_62476499的博客
01-08 759
详细讲解带头循环双向链表的增删查改等基本操作
算法学习资料：详解Linux内核之双向循环链表
09-20
本文详解了 Linux 内核中双向循环链表的实现原理和使用方法，包括双循环链表的传统实现方式和 Linux 内核中的实现方式。双循环链表是一种常用的数据结构，广泛应用于操作系统、数据库、图形处理等领域。 Linux 内核...
C语言之双向链表详解及实例代码
12-31
一般我们都构造双向循环链表。 2，例子要求： 完成双向链表的插入、删除以及查找，将学生管理系统使用的数组，以双向链表的方式实现，能够支持无限制的学生人数的增删改查以及保存。 3，代码实现。 #include #...
详细理解中缀表达式并实现
cout_s的博客
07-17 7890
中缀表达式的实现及概念 中缀表达式的定义 中缀表达式是一个通用的算术或逻辑公式表示方法。
详细理解双端队列的实现及原理
cout_s的博客
07-20 4216
双端栈的实现原理及概念 双端栈的定义
全排列思路详解
cout_s的博客
08-03 565
详解全排列
ConcurrentHashMap1.7和ConcurrentHashMap1.8的异同
cout_s的博客
10-04 464
ConcurrentHashMap ConcurrentHashMap在与HashMap的不同之处在于多线程下更安全，而针对于Hashtable的基础上进行了一次升级。Hashtable的安全机制过于粗暴，导致性能很低。根据不同版本采用的方式也有不同。 public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable
用栈实现队列_LeetCode和队列实现栈
cout_s的博客
07-18 153
栈实现队列——LeetCode第232题
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

牛牛最爱喝兽奶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值