Java双链表编程练习

最新推荐文章于 2022-02-13 21:12:43 发布
最新推荐文章于 2022-02-13 21:12:43 发布
阅读量178 收藏
点赞数
分类专栏： Eclipse JAVA基础

问题

实现一个嵌套类DoubleNode用来构造双向链表，其中每个结点都含有一个指向前驱元素的引用和一个指向后续元素的引用（如果不存在则为null）。
为以下任务实现若干静态方法：

在头插入结点

在表尾插入结点

从表头删除结点

从表尾删除结点

在指定结点前插入新结点

在指定结点之后插入新结点

删除指定结点

代码：

package test;

public class DoubleList<Item> {
	public static class DoubleNode<Item>
	{
		public Item item;
		public DoubleNode<Item> next;//下一个节点
		public DoubleNode<Item> prev;//上一个节点
	}

	private DoubleNode<Item> first;
	private DoubleNode<Item> last;
	
	public DoubleList()
	{//构造函数，初始化链表
		first=null;
		last=null;
	}
	
	public static<Item> void insertAsFirst(DoubleList<Item> d1, Item e)
	{
		DoubleNode<Item> nodenew= new DoubleNode<Item>();
		nodenew.item=e;
		nodenew.next=d1.first;
		nodenew.prev=null;
		if(d1.first==null)
			d1.last=nodenew;
		else
			d1.first.prev=nodenew;
		d1.first=nodenew;	
	}
	
	public static<Item> void insertAsLast(DoubleList<Item> d1,Item e)
	{
		DoubleNode<Item> nodenew=new DoubleNode<Item>();
		nodenew.item=e;
		nodenew.prev=d1.last;
		nodenew.next=null;
		if(d1.last==null)
			d1.first=nodenew;
		else
			d1.last.next=nodenew;
		d1.last=nodenew;	
	}
	
	public static<Item> void deleteFirst(DoubleList<Item> d1)
	{
		if(d1.first==null)
			return;
		if(d1.first==d1.last)
		{
			d1.first=null;
			d1.last=null;
		}
		else
		{
			d1.first=d1.first.next;
			d1.first.prev.next=null;//释放连接
			d1.first.prev=null;	
		}
	}
	
	public static<Item> void deleteLast(DoubleList<Item> d1)
	{
		if(d1.last==null)
			return;
		if(d1.last==d1.first)
		{
			d1.first=null;
			d1.last=null;
		}
		else
		{
			d1.last=d1.last.prev;
			d1.last.next.prev=null;
			d1.last.next=null;
		}
	}
	
	public static<Item> void insertBefore(DoubleList<Item> d1,DoubleNode<Item> node, Item e)
	{
		if(node==null) return;
		if(d1.first==node) insertAsFirst(d1,e);
		else
		{
			DoubleNode<Item> nodenew=new DoubleNode<Item>();
			nodenew.item=e;
			nodenew.next=node;
			nodenew.prev=node.prev;
			node.prev.next=nodenew;
			node.prev=nodenew;//这个容易忘
		}
	}
	
	public static<Item> void insertAfter(DoubleList<Item> d1,DoubleNode<Item> node, Item e)
	{
		if(node==null) return;
		if(d1.last==node) insertAsLast(d1,e);
		else
		{
			DoubleNode<Item> newnode=new DoubleNode<Item>();
			newnode.item=e;
			newnode.prev=node;
			newnode.next=node.next;
			node.next.prev=newnode;
			node.next=newnode;
			
		}
	}
	
	public static<Item> void deleteNode(DoubleList<Item> d1,DoubleNode<Item> node)
	{
		if(node==null) return;
		else if(node==d1.first) deleteFirst(d1);
		else if(node==d1.last) deleteLast(d1);
		else
		{
			node.prev.next=node.next;
			node.next.prev=node.prev;
			node.prev=null;//释放连接
			node.next=null;//释放连接
		}
	}
	
	public static<Item> DoubleNode<Item> search(DoubleList<Item> d1,Item e)
	{ 
		DoubleNode<Item> newnode=d1.first;
		while(newnode!=null)
		{
			if(newnode.item.equals(e))
				return newnode;
			newnode=newnode.next;
		}
		return null;
	}
	
	public static<Item> void print(DoubleList<Item> d1)
	{
		DoubleNode<Item> newnode=d1.first;
		while(newnode!=null)
		{
			System.out.println(newnode.item);
			newnode=newnode.next;
		}
	}
	
}

测试代码：

package test;

public class Q100331 {
	public static void testInsertAsFirst()
	{
        System.out.println("--------------------");
        System.out.println("testInsertAsFirst:");
        DoubleList<String> dl = new DoubleList<String>();
        DoubleList.insertAsFirst(dl, "a");
        DoubleList.insertAsFirst(dl, "b");
        DoubleList.insertAsFirst(dl, "c");
        DoubleList.insertAsFirst(dl, "d");
        System.out.println("After insert a, b, c, d:");
        DoubleList.print(dl);
	}
    public static void testInsertAsLast()
    {
        System.out.println("--------------------");
        System.out.println("testInsertAsLast:");
        DoubleList<String> dl = new DoubleList<String>();
        DoubleList.insertAsLast(dl, "a");
        DoubleList.insertAsLast(dl, "b");
        DoubleList.insertAsLast(dl, "c");
        DoubleList.insertAsLast(dl, "d");
        System.out.println("After insert a, b, c, d:");
        DoubleList.print(dl);
    }
    
   public static void testInsertAsFirstAndLast()
   {
       System.out.println("--------------------");
       System.out.println("testInsertAsFirstAndLast:");
       DoubleList<String> dl = new DoubleList<String>();
       DoubleList.insertAsLast(dl, "a");
       DoubleList.insertAsLast(dl, "b");
       DoubleList.insertAsLast(dl, "c");
       DoubleList.insertAsLast(dl, "d");
       DoubleList.insertAsFirst(dl, "1");
       DoubleList.insertAsFirst(dl, "2");
       DoubleList.insertAsFirst(dl, "3");
       DoubleList.insertAsFirst(dl, "4");
       System.out.println("After insertAsLast a, b, c, d and insertAsFirst 1, 2, 3, 4:");
       DoubleList.print(dl);
   }
     
   public static void testDeleteFirst()
   {
       System.out.println("--------------------");
       System.out.println("testDeleteFirst:");
       DoubleList<String> dl = new DoubleList<String>();
       DoubleList.insertAsLast(dl, "a");
       DoubleList.insertAsLast(dl, "b");
       DoubleList.insertAsLast(dl, "c");
       DoubleList.insertAsLast(dl, "d");
       System.out.println("list is: ");
       DoubleList.print(dl);
       System.out.println("After deleteFrist:");
       DoubleList.deleteFirst(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteFrist again:");
       DoubleList.deleteFirst(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteFrist again:");
       DoubleList.deleteFirst(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteFrist again:");
       DoubleList.deleteFirst(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteFrist again:");
       DoubleList.deleteFirst(dl);
       DoubleList.print(dl);
   }
   
   public static void testDeleteLast()
   {
       System.out.println("--------------------");
       System.out.println("testDeleteLast:");
       DoubleList<String> dl = new DoubleList<String>();
       DoubleList.insertAsLast(dl, "a");
       DoubleList.insertAsLast(dl, "b");
       DoubleList.insertAsLast(dl, "c");
       DoubleList.insertAsLast(dl, "d");
       System.out.println("list is: ");
       DoubleList.print(dl);
       System.out.println("After deleteLast:");
       DoubleList.deleteLast(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteLast again:");
       DoubleList.deleteLast(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteLast again:");
       DoubleList.deleteLast(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteLast again:");
       DoubleList.deleteLast(dl);
       DoubleList.print(dl);
       
       System.out.println("After deleteLast again:");
       DoubleList.deleteLast(dl);
       DoubleList.print(dl);
   }
    
   public static void testSearch()
   {
       System.out.println("--------------------");
       System.out.println("testSearch:");
       DoubleList<String> dl = new DoubleList<String>();
       DoubleList.insertAsFirst(dl, "a");
       DoubleList.insertAsFirst(dl, "b");
       DoubleList.insertAsFirst(dl, "c");
       DoubleList.insertAsFirst(dl, "d");
       
       System.out.println("List is :");
       DoubleList.print(dl);
       
       DoubleList.DoubleNode<String> node = DoubleList.search(dl, "c");
       System.out.println("Search c: ");
       if (node != null)
       {
           System.out.println("Find " + node.item);
       }
       else
       {
           System.out.println("Not found");
       }
               
       node = DoubleList.search(dl, "d");
       System.out.println("Search d: ");
       if (node != null)
       {
           System.out.println("Find " + node.item);
       }
       else
       {
           System.out.println("Not found");
       }
       
       node = DoubleList.search(dl, "a");
       System.out.println("Search a: ");
       if (node != null)
       {
           System.out.println("Find " + node.item);
       }
       else
       {
           System.out.println("Not found");
       }
        
       node = DoubleList.search(dl, "x");
       System.out.println("Search x: ");
       if (node != null)
       {
           System.out.println("Find " + node.item);
       }
       else
       {
           System.out.println("Not found");
       }
   }
   
   public static void testInsertBeforeAndAfter()
   {
       System.out.println("--------------------");
       System.out.println("testInsertBeforeAndAfter:");
       DoubleList<String> dl = new DoubleList<String>();
       DoubleList.insertAsLast(dl, "a");
       DoubleList.insertAsLast(dl, "b");
       DoubleList.insertAsLast(dl, "c");
       DoubleList.insertAsLast(dl, "d");
       
       System.out.println("List is :");
       DoubleList.print(dl);
       
       DoubleList.DoubleNode<String> node = DoubleList.search(dl, "c");
       DoubleList.insertAfter(dl, node, "C");
       System.out.println("After insert C after c:");
       DoubleList.print(dl);
       
       node = DoubleList.search(dl, "d");
       DoubleList.insertAfter(dl, node, "D");
       System.out.println("After insert D after d:");
       DoubleList.print(dl);
       
       node = DoubleList.search(dl, "c");
       DoubleList.insertBefore(dl, node, "B");
       System.out.println("After insert B before c:");
       DoubleList.print(dl);
       
       node = DoubleList.search(dl, "a");
       DoubleList.insertBefore(dl, node, "A");
       System.out.println("After insert A before a:");
       DoubleList.print(dl);
   }
    
   public static void testDeleteNode()
   {
       System.out.println("--------------------");
       System.out.println("testDeleteNode:");
       DoubleList<String> dl = new DoubleList<String>();
       DoubleList.insertAsLast(dl, "a");
       DoubleList.insertAsLast(dl, "b");
       DoubleList.insertAsLast(dl, "c");
       DoubleList.insertAsLast(dl, "d");
       
       System.out.println("List is :");
       DoubleList.print(dl);
       
       DoubleList.DoubleNode<String> node = DoubleList.search(dl, "c");
       DoubleList.deleteNode(dl, node);
       System.out.println("After delete c:");
       DoubleList.print(dl);
       
       node = DoubleList.search(dl, "a");
       DoubleList.deleteNode(dl, node);
       System.out.println("After delete a:");
       DoubleList.print(dl);

       node = DoubleList.search(dl, "d");
       DoubleList.deleteNode(dl, node);
       System.out.println("After delete d:");
       DoubleList.print(dl);
   }
  
   
   public static void main(String[] args)
   {
//       testInsertAsFirst();
//       testInsertAsLast();
//       testInsertAsFirstAndLast();
//       testDeleteFirst();
//       testDeleteLast();
//       testSearch();
         testInsertBeforeAndAfter();
//       testDeleteNode();
   }
}

参考：大神博客

__Forever__
关注
专栏目录
Java算法实例-双向链表操作
08-22
本实例聚焦于Java中的一个重要数据结构——双向链表，它在很多场景下都有着广泛的应用。双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的...
基于java的循环双链表
12-22
在Java编程中，我们可以使用面向对象的设计思想来实现循环双链表。通常，这样的数据结构会包含三个主要部分：一个接口定义链表的基本操作，一个类实现这个接口来构建具体的链表结构，还有一个测试类用于验证链表功能...
java 双向链表例子_Java双向链表按照顺序添加节点的方法实例_Java_软件编程
weixin_39713805的博客
02-24 314
分析过程：首先需要比较待添加的节点编号与已有的节点编号的大小，若待添加的节点编号已经存在，则不能加入。为防止出现空指针的情况，需要对节点的位置进行判断。示例代码：package linkedlist;public class DoubleLinkedListDemo {public static void main(String[] args) {// 测试System.out.println("...
【数据结构】双向链表——Java实现一个简单的双向链表
一条会编程的鱼
02-05 322
目录前言编码 前言 昨天写完单向链表和栈结构之后，看了看程杰大大的书中有介绍双向链表的部分。虽然是c语言写的，但是我还是用Java给翻译出来了。思路如下： 首先，双向链表和单向链表的最大区别就是，双向链表比单链表多了个指向前一节点的指针。代码量其实并不比单链表多很多，只是思路的转变需要克服一下。 其次就是在插入元素的时候，我们可以在链表的头部插入，也可以在链表的尾部插入（因为有两个指针嘛） 编码 代码其实和单链表差不多，如果感兴趣的话可以去看看我之前写的单链表的文章。虽然文笔很烂，但是代码货真价实。 pac
Java链表练习题
tdongmu的博客
11-15 442
题目 1.逆序输出链表 1->2->3->4->5 print() 5 4 3 2 1 2.逆置链表 1->2->3->4->5 reverse() 5->4->3->2->1 3.查找单链表中倒数第K个元素 4.合并两个有序的单链表，保证合并后的依然有序 5.不允许遍历链表, 在 pos之前插入 6.找两条相交链表的相交节点 7.判断链表是否有环，有环输出环的入口节点，无环返回null 题目分析与实现 1.使
Java小练习，双向链表实现
Zoe_Cpp的博客
02-13 622
import java.lang.*; public class MainJava { public static void main(String[] args) { TList list = new TList(); for(int i = 0; i < 10; i++){ list.push_back(i); } for(int i = -1; i >= -10; i--){
JAVA -- 链表习题（三）
weixin_45975659的博客
05-15 193
链表习题一定要画图！ 例一 ：反转链表 OJ链接 题目详述： PS：核心代码是 逆置。 class Solution { public ListNode reverseList(ListNode head) { ListNode cur = head; ListNode prev = null; while(cur != null) { ListNode next = cur.next; cur.nex
基于Java的编程练习与算法实现.zip
最新发布
09-05
基于Java的编程练习与算法实现 项目概述 本项目是一个综合性的编程练习项目，涵盖了数据结构、算法、操作系统、计算机网络、Java编程、数据库、框架、中间件、工具等多个方面的内容。项目通过实现各种数据结构和...
java实现自己的单链表、双链表、Map存储
09-02
本主题将深入探讨如何使用Java实现自己的单链表、双链表以及Map存储。 首先，我们来讨论单链表。单链表是一种线性数据结构，其中每个元素（节点）包含两个部分：一个是数据部分，用于存储实际的数据；另一个是引用...
Java双向链表实现贪吃蛇源码详解与代码示例
"在Java编程中，利用双向链表数据结构实现贪吃蛇游戏是一个常见的练习，它能够锻炼对链表操作的理解和面向对象编程技巧。本文将详细介绍如何通过定义链表节点并结合Java GUI进行编写一个贪吃蛇游戏的源码。首先，...
使用嵌套类DoubleNode实现双向链表
dwwzone
10-10 423
每一个节点都含有指向前驱节点的引用pre 每一个节点都含有指向后继节点的引用next 实现以下功能： 1.在表头插入节点 2.在表尾插入节点 3.从表头删除节点 4.从表尾删除节点 5.从指定节点之前插入新节点 6.从指定节点之后插入新节点 7.删除指定节点 8.输出链表 代码 /** * @author 鯉伴MAY * @param <Item> 泛型 */ public class...
数据结构之C语言实现双向链表（学习笔记）
weixin_45803046的博客
07-16 352
一、双向链表定义 双向链表（double linked list）是在单链表的每个结点中，再设置一个指向其前驱结点的指针域 二、空表的判断条件 //head的是头结点 p->next = head; //或者 p->prior = head; 三、双向链表的基本操作 typedef int ElemType; typedef struct DNode { ElemType data; struct DNode* next; //直接后继指针 struct DNode* prior;
C语言 实现一个双链表
pecuyu
12-12 3438
1 头文件编写如下doublelinklist.h头文件#pragma once typedef int _TYPE; // 数据类型typedef struct DoubleLinkListNode { struct DoubleLinkListNode* pPre; // 前一个节点指针 struct DoubleLinkListNode* pNext; // 后一个节点指针
双向链表的单指针实现（算法导论习题）
yysdsyl的专栏
06-14 2611
题目描述：Explain how to implement doubly linked lists using only one pointer value np[x] per item instead of the usual two (next and prev). Assume that all pointer values can be interpreted as k-bit int
Algs4-1.3.31实现双向链表
weixin_34356310的博客
10-26 105
1.3.31实现一个嵌套类DoubleNode用来构造双向链表，其中每个结点都含有一个指向前驱元素的引用和一项指向后续元素引用(如果不存在则为null)。为以下任务实现若干静态方法：在表头插入结点、在表尾插入结点、从表头删除结点、从表尾删除结点、在指定结点之前插入新结点、在指定的结点之后插入新结点、删除指定结点。public class Node<Item> {...
双向链表类DoubleLink，提供addFirst，addEnd，delete功能
第十七签
08-17 882
package test; public class DoubleLink { private Node first; private Node end; /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub DoubleLink
算法－第四版－练习1.3.31解答
一夜听风雨2019的博客
02-20 348
题目 实现一个嵌套类DoubleNode用来构造双向链表，其中每个结点都含有一个指向前驱元素的引用和一个指向后续元素的引用（如果不存在则为null）。为以下任务实现若干静态方法：在头插入结点、在表尾插入结点、从表头删除结点、从表尾删除结点、在指定结点前插入新结点、在指定结点之后插入新结点、删除指定结点 分析 先编写一个内部的嵌套类DoubleNode,存在3个类变量Item值,next和previ...
双向链表的C实现
热门推荐
12-20 1万+
双向链表需要定义一个结构体，结构体有3个属性typedef struct __Node{     int data;    数据     struct __Node *pre;    指向前一个结点指针     struct __Node *next;    指向下一个结点指针 }Node;其中 pre和next指针式嵌套定义。一般链表定义一个头指针Node *head；指向链表第一个结点，如果链表为空的话，那么head == NULL。双向链表一般分为init，insert, delete, se
【Redis系列8】如何利用一个支持元素删除的布隆过滤器来解决缓存穿透问题
zwx900102的博客
11-29 3306
面试题1：如何解决缓存穿透，缓存击穿和缓存雪崩问题 面试题2：如何在海量(如10亿)的无序的数据中快速判断一个元素是否存在
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值