【Java数据结构】链表

最新推荐文章于 2024-01-22 16:06:56 发布
最新推荐文章于 2024-01-22 16:06:56 发布
阅读量64 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：https://yq.aliyun.com/articles/18530
版权

1.链接点

链接点核心思想：
链接点中包含一个数据域和一个指针域。其中数据域用来包装数据，而指针域用来指向下一个链接点。

链接点模型：

package cn.deu;

public class Link {
		//数据域
	    private long data;
	    
	    //指针域
	    private Link next;
	    
		public Link(long data) {
			this.data = data;
		}

		public long getData() {
			return data;
		}

		public void setData(long data) {
			this.data = data;
		}

		public Link getNext() {
			return next;
		}

		public void setNext(Link next) {
			this.next = next;
		}
	    
}

链接点测试： 
package en.edu.Test;

import cn.deu.Link;

public class TestLink {
	public static void main(String[] args) {
			Link link1=new Link(10);
			Link link2=new Link(45);
			Link link3=new Link(360);
			Link link4=new Link(1);
			
			link1.setNext(link2);
			link2.setNext(link3);
			link3.setNext(link4);
			
	System.out.println(link1.getData());
	System.out.println(link1.getNext().getData());
	System.out.println(link1.getNext().getNext().getData());
	System.out.println(link1.getNext().getNext().getNext().getData());
	}
}
结果：
10
45
360
1


2.链表

链表核心思想：

链表中只包含一个数据项，即对第一个链接点的引用

链表模型： 
package cn.deu;

//其实java的指针就是"引用"而已
public class LinkList {
		private Link first=new Link(-1);
		
		//思路：一个首链接点，每添加一个新链接点
		//将新链接点的指针指向首链接点的指针所指向的对象
		//之后将首链接点的指针指向新连接点对象
		public void insert(long value){
			Link link1=new Link(value);
			if(first.getNext()==null){
				first.setNext(link1);
			}else{
				link1.setNext(first.getNext());
				first.setNext(link1);
			}
		}
		
		public void displayAll(){
			Link current =first;
			while(current.getNext()!=null){
				if(current!=first){
		System.out.println("当前数据："+current.getData());
				}
	System.out.println("链接的下一个数据"+current.getNext().getData());
				current=current.getNext();
			}
		}
}

链表测试类： 
package en.edu.Test;

import cn.deu.LinkList;

public class TestLinkList {
	
	public static void main(String[] args) {
		LinkList linklist=new LinkList();
		linklist.insert(1);
		linklist.insert(5);
		linklist.insert(6);
		linklist.insert(9);
		linklist.displayAll();
	}
}
/*
 * 结果：
 链接的下一个数据9
当前数据：9
链接的下一个数据6
当前数据：6
链接的下一个数据5
当前数据：5
链接的下一个数据1
 */

3.查找指定节点

模型：

package cn.deu;

//其实java的指针就是"引用"而已
public class LinkList {
		private Link first=new Link(-1);
		
		//思路：一个首链接点，每添加一个新链接点
		//将新链接点的指针指向首链接点的指针所指向的对象
		//之后将首链接点的指针指向新连接点对象
		public void insert(long value){
			Link link1=new Link(value);
			if(first.getNext()==null){
				first.setNext(link1);
			}else{
				link1.setNext(first.getNext());
				first.setNext(link1);
			}
		}
		
		public void displayAll(){
			Link current =first;
			while(current.getNext()!=null){
				if(current!=first){
	System.out.println("当前数据："+current.getData());
				}
	System.out.println("链接的下一个数据"+current.getNext().getData());
				current=current.getNext();
			}
		}


		//查找节点
		public Link find(long key){
			Link current=first.getNext();
			while(current.getData()!=key){
				if(current.getNext()==null){
					return null;
				}
				current=current.getNext();
			}
			
			return current;
				
		}
}

测试： 
package en.edu.Test;

import cn.deu.LinkList;

public class TestLinkList {
	
	public static void main(String[] args) {
		LinkList linklist=new LinkList();
		linklist.insert(1);
		linklist.insert(5);
		linklist.insert(6);
		linklist.insert(9);

		if(linklist.find(5)!=null){
          System.out.println("找到节点，数据为:"+linklist.find(5).getData());
		}
		
	}
}

结果：找到节点，数据为:5


4.添加指定节点

思路：
插入节点到指定位置（insert方法重载），
新加入的节点的下一个是原来节点的下一个，
当前节点的下一个设为新加入的。

public void insert(long value,int pos){
	boolean flag=true;
		Link current=first.getNext();
		while(current.getData()!=pos){
			if(current.getNext()==null){
				flag=false;
				System.out.println("插入失败");
				break;
			}
			current=current.getNext();
		}


		if(flag==true){
			Link InsertNum=new Link(value);
			//新加入的节点的下一个是原来节点的下一个
			InsertNum.setNext(current.getNext());
			//当前节点的下一个设为新加入的
			current.setNext(InsertNum);
		    	System.out.println("插入成功！");
		}
}

测试： 
package en.edu.Test;

import cn.deu.LinkList;

public class TestLinkList {
	
	public static void main(String[] args) {
		LinkList linklist=new LinkList();
		linklist.insert(1);
		linklist.insert(5);
		linklist.insert(6);
		linklist.insert(9);
		linklist.displayAll();
		/*
		 * 结果：
		 链接的下一个数据9
		当前数据：9
		链接的下一个数据6
		当前数据：6
		链接的下一个数据5
		当前数据：5
		链接的下一个数据1
		 */


		//将数据插入到5后面
		linklist.insert(10, 5);
		linklist.displayAll();
		System.out.println("-------------------------");
		//将数据插入到110后面(没有110，会失败)
		linklist.insert(10, 110);
		linklist.displayAll();
		/*
		* 结果：
		插入成功！
		链接的下一个数据9
		当前数据：9
		链接的下一个数据6
		当前数据：6
		链接的下一个数据5
		当前数据：5
		链接的下一个数据10
		当前数据：10
		链接的下一个数据1
		-------------------------
		插入失败
		链接的下一个数据9
		当前数据：9
		链接的下一个数据6
		当前数据：6
		链接的下一个数据5
		当前数据：5
		链接的下一个数据10
		当前数据：10
		链接的下一个数据1
 		*/


	}
}

5.删除指定节点 

//删除节点
//思路：将要删除节点的前一个节点的next指向要删除节点的next
public void delete(long key){
	boolean flag=true;
	Link current=first.getNext();
	while(current.getNext()!=null&¤t.getNext().getData()!=key){
			current=current.getNext();
			if(current.getNext()==null){
				flag=false;
				System.out.println("删除失败！");
				break;
			}
	}


	if(flag==true){
		current.setNext(current.getNext().getNext());
		//中间那个节点被丢掉后，Java的垃圾回收器就会自动回收
			System.out.println("删除成功！");
		}
	}

测试： 
package en.edu.Test;

import cn.deu.LinkList;

public class TestLinkList {
	
	public static void main(String[] args) {
		LinkList linklist=new LinkList();
		linklist.insert(1);
		linklist.insert(10);
		linklist.insert(5);
		linklist.insert(6);
		linklist.insert(9);
		linklist.displayAll();


		System.out.println("-------------------------");
		linklist.delete(10);
		linklist.displayAll();
		System.out.println("-------------------------");
		linklist.delete(110);
		linklist.displayAll();
	}
}
结果：
链接的下一个数据9
当前数据：9
链接的下一个数据6
当前数据：6
链接的下一个数据5
当前数据：5
链接的下一个数据10
当前数据：10
链接的下一个数据1
-------------------------
删除成功！
链接的下一个数据9
当前数据：9
链接的下一个数据6
当前数据：6
链接的下一个数据5
当前数据：5
链接的下一个数据1
-------------------------
删除失败！
链接的下一个数据9
当前数据：9
链接的下一个数据6
当前数据：6
链接的下一个数据5
当前数据：5
链接的下一个数据1


6.比较链表与顺序表

package en.edu.Test;

import java.text.SimpleDateFormat;
import java.util.Date;


import cn.deu.LinkList;
import cn.deu.MyArray;


public class TestLinkAndList {
	public static void main(String[] args) {
	
		//构建链表
		Date date1=new Date();
		LinkList linkList=new LinkList();
		for (int i = 0; i < 100000; i++) {
			linkList.insert(i);
		}
		Date date2=new Date();
		System.out.println(date2.getTime()-date1.getTime());
		
		
		//构建顺序表（从小到大）
		date1=new Date();
		MyArray ma=new MyArray(100000);
		for (int i = 0; i < 100000; i++) {
			ma.insert(i);
		}
		date2=new Date();
		System.out.println(date2.getTime()-date1.getTime());


		date1=new Date();
		linkList.delete(11111);
		date2=new Date();
		System.out.println(date2.getTime()-date1.getTime());
		
		date1=new Date();
		ma.delete(11111);
		date2=new Date();
		System.out.println(date2.getTime()-date1.getTime());
	}
}

结果：
26
4367
删除成功！
13
45

对比结果：
链表进行插入删除比较快捷，但是查找比较慢
顺序表查找起来和修改起来比较好，但是插入删除比较慢。

比如公司的职员表经常发生变化，最好使用链表，因为插入删除比较快捷。
若表是固定的，就使用顺序表即可。

转载请注明出处：http://blog.csdn.net/acmman/article/details/50444792

weixin_34049948
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 数据结构之链表
JavaZWT的博客
08-06 1030
前言 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 由于链表不必按照顺序存储，故在插入数据时可以达到O(1)的复杂度，但是查找的时候就需要遍历，时间复杂度为O(n)。 ...
Java数据结构之链表
m0_74195366的博客
11-06 392
JAVA链表单链表
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4212
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
JAVA——链表
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
【Java】链表LinkedList
qq_61635026的博客
07-06 9401
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
Java数据结构篇之链表
MasterJundarj的博客
09-23 2892
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
Java链表入门(超详细)
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
Java链表详解--通俗易懂(超详细,含源码)
噜噜噜噜鲁
12-05 3万+
概念 链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂
链表知识详解及java代码示例
m0_68871967的博客
05-23 949
这篇教学文章主要介绍了链表的基本原理和定义，以及如何使用 Java 实现链表。链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。相比于数组，链表具有动态扩展和删除节点的优势，但是访问节点的效率较低。在文章中，我们还介绍了链表的几种常见操作，包括插入节点、删除节点、查找节点等。并且均给出java示例代码。
Java算法进阶(一):链表
Justin_Andyson的博客
04-11 930
Java算法链表的深究
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
Java中的链表
weixin_52758364的博客
12-09 3359
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
JAVA基础-链表
lwxklts的博客
02-02 707
链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。链表在插入的时候速度较快，可以达到O(1)的复杂度，但是查找操作较慢，需要O(n)的时间，线性表和顺序表查找操作的时间复杂度分别是O(logn)和O(1)。链表的物理存储结构是非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接的次序实现的.利用尾节点last尾插法插入结点。先查找结点比对结点值再删除。在指定结点前添加结点。
Java中链表的实现(超详细)
m0_74000148的博客
05-24 3223
在这个示例中，我们创建了一个。在Java中，链表可以通过。 在这个示例中，我们创建了一个 LinkedList 类，它包含一个 Node 类和一些方法来操作链表。我们可以使用 push() 方法在链表的头部插入节点，使用 insertAfter() 方法在链表中间插入节点，使用 append() 方法在链表尾部插入节点，使用 deleteNode() 方法删除链表中的给定节点，并使用 printList() 方法打印链表。
04 Java基本数据结构之链表
R_conqueror的博客
07-11 297
链表这一部分内容较多，同时实现起来最开始的时候也是笔者最开始不太理解的，掌握基础链表后，再进一步实现双端链表、有序链表、双向链表以及用链表实现栈、队列。
Java基础--单链表的实现
鱼非子
03-25 9万+
Java内部也有自己的链表--LinkedList，但是我们今天不是讨论LinkedList，而是自己来实现一个单链表，包括简单的增删查改，以及使用链表来实现栈和队列这两种数据结构，涉及的方面如下： 单链表的结构 单链表的基本操作 使用虚拟头结点的单链表 单链表实现栈 单链表实现队列 单链表的结构 一种链式存取的数据结构，单链表中的数据是以结点的形式存在，每一个结点...
Java版的数据结构——链表
ANNE_fly的博客
09-12 748
LinkedList的官方文档LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。【说明】实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess（该接口是实现随机访问）接口，因此LinkedList不支持随机访问。
数据结构——链表的实现（Java版）
最新发布
2301_77116754的博客
01-22 898
Java实现链表，链表的实现
java数据结构链表
09-21
链表是一种常用的数据结构，它由节点组成，每个节点包含一个值和一个指向下一个节点的指针。Java中可以使用Node类来实现链表的节点，如下所示： ```java public class Node { public int value; public Node next...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值