数据结构 —— java 单链表、双端链表、双向链表、无序链表、有序链表

最新推荐文章于 2024-08-04 17:29:18 发布
最新推荐文章于 2024-08-04 17:29:18 发布
阅读量3.9k 收藏 34
点赞数 9
分类专栏： 面试 数据结构 文章标签： 单链表 双端链表 双向链表 java 有序链表
原文链接：https://blog.csdn.net/xiaojin21cen/article/details/95180892
版权

文章目录

0、节点

节点 是数据结构中的基础，是 构成复杂数据结构的基本组成单位。

在这里插入图片描述

public class Node {
	public long data;
	public Node next;		

	public Node(long value) {
		this.data = value;
	}	
}

1、链表的定义

链表：

通常由一连串 节点 组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向 上一个 或 下一个 节点的位置的链接（“links”）。

在这里插入图片描述

上面是一个单链表的存储原理图，head为头节点，它不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用，而每个节点中都有一个 next 引用，指向下一个节点，就这样一节一节往下面记录，直到最后一个节点，其中的 next 指向 null 。

2、链表的种类和特点

（1）普通链表（单链表）：
单链表的节点类保留下一节点的引用。链表类只保留头节点的引用，只能从头节点插入删除 （思考为什么？）；

（2）双端链表：
双端链表的节点类保留下一节点的引用。链表类保留头节点、尾节点的引用，可以从尾节点插入，但只能从头节点删除 （思考为什么？）；

（3）双向链表：
双向链表的节点类保留上一节点、下一节点的引用。链表类保留头节点、尾节点的引用，可以从尾节点插入删除；

如图所示：
在这里插入图片描述

（4）无序链表 最大特点就是 在头部或尾部增加 新节点。

上面几种 链表都是 无序链表。

（5）有序链表：

递增，递减或者其他满足一定条件的规则，插入数据时，从头结点开始遍历每个节点，在满足规则的地方插入新节点。

3、普通链表、单链表（单向链表）

普通链表 ，也叫 单链表 或者 单向链表。

单链表 是链表中结构最简单的。一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。

  • 查找：单向链表 只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。

  • 插入：而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。

  • 删除：删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

查找图：

在这里插入图片描述

在表头增加节点：
在这里插入图片描述

删除节点：
在这里插入图片描述

package node1;

public class Node {
	public long data;
	public Node next;		

	public Node(long value) {
		this.data = value;
	}
	
	//显示方法
	public void display() {
		System.out.print(data + " ");
	}
}


package node1;

/**
 * 单链表
 */
public class SingleEndLinkList {
	
	/**头点节*/
	private Node first;
	
	public SingleEndLinkList() {
		first = null;
	}
	
	/**
	 * 插入节点
	 * <pre>
	 * 在头结点之后插入
	 * </pre>
	 */
	public void insertFirst(long value) {
		Node aNode = new Node(value);
		aNode.next = first;
		first = aNode;
	}
	
	//删除头节点
	public Node deleteFirst() {
		Node tmp = first.next;
		first = tmp;
		return tmp;
	}
	
	
	//显示方法
	public void display() {
		Node now = first;
		while(now != null) {
			now.display();
			now = now.next;
		}
		System.out.println();
	}
	
	//查找方法
	public Node find(long value) {
		Node now = first;
		while(now.data != value) {
			if(now.next == null) {
				return null;
			}
			now = now.next;
		}
		return now;
	}
	
	//根据数值删除
	public Node delete(long value) {
		Node now = first;
		Node before = first;
		while(now.data != value) {
			if(now.next == null) {
				return null;
			}
			before = now;
			now = now.next;
		}
		
		if(now == first) {
			first = first.next;
		}
		else {
			before.next = now.next;
		}
		return now;
	}
}

4、双端链表（单向引用）

双端链表的节点类保留下一节点的引用。（单向引用）

双端链表： 保留对头节点、尾节点的引用，可以从尾节点插入，但只能从头节点删除，只能从一个方向遍历，相当于单向链表多了一个对尾节点的引用。

双端链表的特点：
双端链表的含有对 第一个节点 和 最后一个节点的引用 。

|

双端链表的操作读取（引用）插入删除
头部√√√
尾部√√x

在这里插入图片描述

双端链表： 只能从一个方向遍历，相当于 单向链表 多了一个对尾节点的引用。
在这里插入图片描述

package node2;

public class Node {
	public long data;
	public Node next;

	public Node(long data) {
		this.data = data;
	}

	// 显示方法
	public void display() {
		System.out.print(data + " ");
	}
}

package node2;

/**
 * 双端链表
 */
public class DoubleEndLinkedList {
    // 头节点
    private Node first;
    //尾节点
    private Node last;
    
    public DoubleEndLinkedList() {
		first = null;
		last = null;
	}
	
	//插入节点，在头结点之后插入
	public void insertFirst(long value) {
		Node aNode = new Node(value);
		if (isEmpty()) {
			last = aNode;
		}
		aNode.next = first;
		first = aNode;
	}
	
	//尾节点插入
	public void insertLast(long value) {
		Node aNode = new Node(value);
		if (isEmpty()) {
			first = aNode;
		}
		else {
			last.next = aNode;
		}
		last = aNode;
	}
	
	//删除头节点
	public Node deleteFirst() {
		Node tmp = first;
		if (first.next == null) {
			last = null;
		}
		first = tmp.next;
		return tmp;
	}
	
	//显示方法
	public void display() {
		Node now = first;
		while(now != null) {
			now.display();
			now = now.next;
		}
		System.out.println();
	}
	
	//查找方法
	public Node find(long value) {
		Node now = first;
		while(now.data != value) {
			if(now.next == null) {
				return null;
			}
			now = now.next;
		}
		return now;
	}
	
	//根据数值删除
	public Node delete(long value) {
		Node now = first;
		Node before = first;
		while(now.data != value) {
			if(now.next == null) {
				return null;
			}
			before = now;
			now = now.next;
		}
		
		if(now == first) {
			first = first.next;
		}
		else {
			before.next = now.next;
		}
		return now;
	}
	
	//判断是否为空
	public boolean isEmpty() {
		return first == null;
	}
}

为什么不能删除尾节点？ 删除尾节点时必须知道尾节点的上个节点，但是 双端链表 只能知道下个节点，不知道上个节点，故无法删除。

5、双向链表

双向链表 的节点类保留上一节点、下一节点的引用。
双向链表 保留头节点、尾节点的引用，可以从尾节点插入删除。

在这里插入图片描述

package node3;

public class Node {
    // 数据域
    public long data;
    //指针域（保存下一个节点的引用）
    public Node next;
    //指针域（保存前一个节点的引用）
    public Node previous;

    public Node(long value) {
        this.data = value;
    }

    /**
     * 显示方法
     */
    public void display() {
        System.out.print(data + " ");
    }
}

package node3;

/**
 * 双向链表
 */
public class DoubleByLinkedList {
    // 头结点
    private Node first;
    //尾结点
    private Node last;

    public DoubleByLinkedList() {
        first = null;
        last = null;
    }

    /**
     * 插入一个节点，在头结点后进行插入
     *
     * @param value
     */
    public void insertFirst(long value) {
        Node node = new Node(value);
        if (isEmpty()) {
            last = node;
        } else {
            first.previous = node;
        }
        node.next = first;
        first = node;
    }

    public void insertLast(long value) {
        Node node = new Node(value);
        if (isEmpty()) {
            first = node;
        } else {
            last.next = node;
            node.previous = last;
        }
        last = node;
    }

    /**
     * 删除一个结点,在头结点后进行删除
     *
     * @return
     */
    public Node deleteFirst() {
        Node tmp = first;
        if (first.next == null) {
            last = null;
        } else {
            first.next.previous = null;
        }
        first = tmp.next;
        return tmp;
    }

    /**
     * 删除一个结点,从尾部进行删除
     *
     * @return
     */
    public Node deleteLast() {
        if (first.next == null) {
            first = null;
        } else {
            last.previous.next = null;
        }
        last = last.previous;
        return last;
    }

    /**
     * 显示方法
     */
    public void display() {
        Node current = first;
        while (current != null) {
            current.display();
            current = current.next;
        }
    }

    /**
     * 查找方法
     *
     * @param value
     * @return
     */
    public Node find(long value) {
        Node current = first;
        while (current.data != value) {
            if (current.next == null) {
                return null;
            }
            current = current.next;
        }
        return current;
    }

    public Node delete(long value) {
        Node current = first;
        while (current.data != value) {
            if (current.next == null) {
                return null;
            }
            current = current.next;
        }
        if (current == first) {
            first = first.next;
        } else {
            current.previous.next = current.next;
        }
        return current;
    }

    /**
     * 判断是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return first == null;
    }
}

6、有序列表

前面的链表实现插入数据都是无序的，在有些应用中需要链表中的数据有序，这称为有序链表。

在有序链表中，数据是按照关键值有序排列的。一般在大多数需要使用有序数组的场合也可以使用有序链表。有序链表优于有序数组的地方是插入的速度（因为元素不需要移动），另外链表可以扩展到全部有效的使用内存，而数组只能局限于一个固定的大小中。

有序列表算法题：

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

https://leetcode-cn.com/problems/merge-two-sorted-lists/

猎人在吃肉
关注
专栏目录
11.JavaSE_链表(单链表、双向链表）
roman's Blog
01-24 307
1、基本介绍： 为解决空间浪费等问题，应采用火车车厢的设计模式，动态进行车厢的挂载。 //单链表 class Node{ private Object data; private Node next; public Node(Object data) { this.data = data; } public Object getData...
数据结构（java）——单链表、双端链表和双向链表
likunkun__的博客
04-17 1945
单链表    链表大家都很熟悉，链表是由若干个节点串起来的一个结构。类似于火车一样，拥有一个头结点（火车头）之后挂着一个个的节点，每个节点后面跟上另一个节点。每个节点分为两个域，一个数据域，用来存放这个节点的数据，一个是节点域，用来存放下一个节点。    所以对于单链表，用java实现我们首先创建节点类。Node类：//联结点，相当于是车厢 public class Node { //数据域 ...
Java实现单向链表和双向链表
Tracycater的专栏
03-10 2522
1、单向链表 单向链表的特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点。public class Node { Object value; Node next; public Node(String value){
数据结构——单向链表
最新发布
脑壳有点痒，好像要长脑子了！
08-04 1027
链表（Linked List）是一种常见的数据结构，它属于线性表的一种链式存储结构，其逻辑上相邻的元素在物理存储位置并不相邻。它由一系列节点（Node）组成，每个节点包含数据部分和指向列表中下一个节点（或者上一个节点）的指针（链接）。链表中的节点通过指针相互连接，从而形成一个序列。链表可以分为几种不同的类型，但最常见的是单向链表和双向链表。
单向链表与双向链表：Java实现
weixin_43854959的博客
07-11 270
链表是一种常见的数据结构，它由一系列的节点组成。每个节点包含一个数据元素和一个指向下一个节点的指针。根据指针的数量和方向，链表可以分为单向链表和双向链表。本文将详细介绍这两种链表的定义、特点和Java实现。
用java语言模拟单向链表和双向链表
rolic_的博客
05-13 606
/* 集合是一个容器，用来存储其他类型，只能存储引用类型 迭代就是遍历 Collection是可迭代的，所有的集合都是可迭代的 Collection中有iterator方法，说明所有的集合中都有iterator方法 这个方法返回一个iterator()，是一个迭代器，集合通过获取这个方法去遍历集合 在开发过程中都是面向接口的，没有去面向类 换句话说，就是面向抽象，没有面向具体*/...
java基础之面试篇四-单向链表和双向链表区别
对酒当歌，人生几何
01-27 913
区别主要在头结点，for遍历，有无前驱结点地址。 单向链表的头结点不是哑元（哑元的意思是能不能从头节点遍历，能则不是哑元），遍历的时候要第二次才能进入for循环，第一次需要去找表头，无前驱结点地址，只有后驱结点地址。 双向链表头结点是哑元，遍历第一次就可以进入for循环，前后都有结点地址。 顺带提一下，循环链表结构和单向链表一样，区别只在最后一个结点的链接地址上，单向链表是n...
Java模拟单链表和双端链表数据结构的实例讲解
09-02
总结起来，Java中的单链表和双端链表都是重要的数据结构，它们在内存中非连续存储数据，通过节点间的引用关系维持逻辑顺序。单链表只支持从前往后的遍历，而双端链表则允许双向遍历，提供更灵活的操作。在实际应用中...
数据结构——单链表多链表基本操作菜单实现(c语言)
weth的存档室
07-19 5589
本文将单链表与双向链表的基本操作在同一个程序中实现。其中单链表头文件中的函数与双向链表头文件中的函数可以分离出来单独使用。菜单程序的实现的程序较为复杂，变量多且作用范围不同，如果修改代码需要对代码非常熟悉，没有很好的做到函数的可分离。见谅！ 一、菜单功能及从属关系 注意： 1.程序设置了两个单链表节点指针和两个双向链表节点指针，但是表现给使用者的链表数同时间内最多两条，最少0条。(我写了一个函数来提示使用者创建链表的情况) 2.进行每一项操作前，程序都需要确认进行操作的是哪一条链表，本质是确认该链表的.
Java数据结构之双端链表原理与实现方法
08-29
Java数据结构之双端链表原理与实现方法 Java数据结构中，双端链表是一种常用的数据结构，它可以实现链表的插入、删除、遍历等操作。双端链表的特点是，它有两个指针，一个指向链表的头节点，另一个指向链表的尾节点...
Java单链表、双向链表
SYT_Boss的博客
09-09 297
单链表实现 package com.ys.datastructure; /** * 单链表 */ public class SingleLinkedList { private int size;//链表节点的个数 private Node head;//头节点 public SingleLinkedList(){ size = 0; ...
【Java 数据结构】单向链表和双向链表的实现 (LinkedList)
热门推荐
书生-w的博客
04-16 1万+
​首先我们和ArrayList一样，将MySingleList单独定义为一个Java文件，然后每一个结点我们将它定义成一个静态内部类，这样就方便我们访问结点的成员，，还是和ArrayList一样，我们再定义一个Test类用来测试我们的单链表，写一个函数可以测试一下
Java-单向链表和双向链表的实现和概念
夏寻的博客
06-30 490
单向链表只有后一节点指针，在节点删除，移动的时候，需要暂存前一节点，删除的时候将前一节点和后一节点连接，因为比双向链表少维护一个前节点，只在删除的时候暂存，所以比双向链表节省资源，但是增加了操作的复杂性。双向链表有前后两个节点指针，可以回溯指针，方便节点删除，移动，在做删除操作时只需要将索引节点前后两个节点连接即可，但是相比单向链表会耗费额外资源。 二、链表优点 长度可变，扩展性好 内存利用高（可以不连续） 时间性能：查找O(n)、插入和删除O(1) 空间性能：不需要分配存储空间，只要有就
Java数据结构(三)：单链表和双链表
chtw的博客
03-01 817
单链表 在实现单链表之前，先看看数组和单链表之间的区别： 数组： 1）数组需要维护下标 2）数组定义时需要指定数组长度 3）当在数组的某些位置增加和删除元素时，还要编写代码处理元素的移动 4）时间性能：查找O(1)、插入和删除O(n) 5）空间性能：需要预分配存储空间，分大了浪费，小了容易溢出 单链表： 1）长度可变，扩展性好 2）内存利用高（可以不连续） 3）时间性能：查找O(n)、...
【Java】Day2-单链表和双链表
m0_71414371的博客
01-08 207
数据结构之单链表和双链表
数据结构--java实现单链表与双链表
mingshengda的博客
09-09 316
【代码】数据结构--java实现单链表与双链表。
python-链表（无序链表、有序链表）
Leohfan的博客
01-09 550
class Node:     def __init__(self,initdata):         self.data = initdata         self.next = None     def getData(self):         return self.data     def getNext(self):         return self.next  ...
java 双向链表和单项链表
sinat_37529004的博客
07-30 203
Java 链表的使用 浅谈自己学习链表之后的理解： 链表是一种重要的数据结构，有单链表和双链表之分 单链表（单向链表）：由两部分组成 数据域（Data）和结点域(Node),单链表就像是一条打了很多结的绳子，每一个绳结相当于一个结点，每个节结点间都有绳子连接，这样原理的实现是通过Node结点区的头指针head实现的，每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一...
Java实现单链表与特有双端链表详解及示例
Java模拟单链表和双端链表是两种基础的数据结构，它们在编程中被广泛应用，尤其是对于需要动态内存管理、灵活插入和删除元素的场景。本文主要讲解的是如何在Java中实现这两种链表的数据结构。 首先，让我们了解一下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值