Java——实现链表结构

最新推荐文章于 2023-09-12 00:00:35 发布
最新推荐文章于 2023-09-12 00:00:35 发布
阅读量427 收藏
点赞数
分类专栏： code 算法与数据结构 源码 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45565886/article/details/122508345
版权

文章目录


利用Java语言实现单向链表结构：

首先，创建一个LinkedSinglyList类，让它支持泛型，同时还实现我们定义的List接口

List接口如下：

import java.util.Comparator;

//线性表接口定义
public interface List<E> extends Iterable<E> {
    //默认在表尾添加一个元素
    public void add(E element);
    //在指定角标处添加元素
    public void add(int index, E element);
    //删除指定元素
    public void remove(E element);
    //删除指定角标处的元素 并返回原先的值
    public E remove(int index);
    //获取指定角标处的元素
    public E get(int index);
    //修改指定角标index处的值为element，并返回原先的值
    public E set(int index, E element);
    //获取线性表中的元素个数
    public int size();
    //查看元素第一次出现的角标位置(从左到右)
    public int indexOf(E element);
    //判断是否包含元素
    public boolean contains(E element);
    //判断线性表是否为空
    public boolean isEmpty();
    //清空线性表
    public void clear();
    //按照比较器的内容进行排序
    public void sort(Comparator<E> c);
    //获取子线性表 原线性表中[formIndex, toIndex)这个部分
    public List<E> subList(int fromIndex, int toIndex);

}

接下来，创建LinkedSinglyList<E>类：
分别实现如下方法：
【1】void add(int index, E element){}
【2】E remove(int index){}
【3】E get(int index){}
【4】E set(int index, E element){}
【5】int indexOf(E element){}
【6】void sort(Comparator<E> c){}
【7】List<E> subList(int fromIndex, int toIndex){}
【8】String toString(){}
【9】Iterator<E> iterator(){}
注意：此处并非是LinkedSinglyList<E>类的全部方法，此处仅提供了主要方法，其他方法在源码中体现

准备工作：定义构造器、成员变量等
    //定义结点对象
    private class Node{
        E data;//数据域
        Node next;//指针域
        public Node(){
            this(null,null);
        }
        public Node(E data){
            this(data,null);
        }
        public Node(E data, Node next){
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }
    private Node head;//头指针
    private Node tail;//尾指针
    private int size;//元素的个数
    public LinkedSinglyList(){
        head = null;
        tail = null;
        size = 0;
    }
    public LinkedSinglyList(E[] arr){
        if(arr == null || arr.length == 0){
            throw new IllegalArgumentException("arr is null");
        }
        for(int i = 0; i < arr.length; i++){
            add(arr[i]);
        }
    }
【1】实现void add(int index, E element){}：
    @Override
    public void add(int index, E element) {
        if(index < 0 || index > size){
            throw new IllegalArgumentException("add index out of range");
        }
        Node n = new Node(element);
        if(size == 0){
            head = n;
            tail = n;
        }else if(index == 0){
            n.next = head;
            head = n;
        }else if(index == size){
            tail.next = n;
            tail = n;
        }else{
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }
【2】实现E remove(int index){}：
    @Override
    public E remove(int index) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("remove index out of range");
        }
        E ret =  null;
        if(size == 1){
            ret = head.data;
            head = null;
            tail = null;
        }else if(index == 0){
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
        }else if(index == size - 1){
            Node p = head;
            while(p.next != tail){
                p = p.next;
            }
            ret = tail.data;
            p.next = null;
            tail = p;
        }else{
            Node p = head;
            for(int i = 0; i < index - 1; i++){
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }
【3】实现E get(int index){}：
    @Override
    public E get(int index) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("get index out of range");
        }
        if(index == 0){
            return head.data;
        }else if(index == size - 1){
            return tail.data;
        }else{
            Node p = head;
            for(int i = 0; i < index; i++){
                p = p.next;
            }
            return p.data;
        }
    }
【4】实现E set(int index, E element){}：
    @Override
    public E set(int index, E element) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("get index out of range");
        }
        E ret = null;
        if(index == 0){
            ret = head.data;
            head.data = element;
        }else if(index == size - 1){
            ret = tail.data;
            tail.data = element;
        }else{
            Node p = head;
            for(int i = 0; i < index; i++){
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }
【5】实现int indexOf(E element){}：
    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while(!p.data.equals(element)){
            p = p.next;
            index++;
            if(p == null){
                return -1;
            }
        }
        return index;
    }
【6】实现void sort(Comparator<E> c)：
    @Override
    public void sort(Comparator<E> c) {
        if(c == null){
            throw new IllegalArgumentException("comparator can not be null");
        }
        if(size == 0 || size == 1){
            return;
        }
        Node nodeA = head;
        Node nodeB = nodeA.next;
        while(true){
            while (true){
                if(c.compare(nodeA.data, nodeB.data) > 0){
                    swap(nodeA, nodeB);
                }
                if(nodeB == tail){
                    break;
                }
                nodeB = nodeB.next;
            }
            if(nodeA == tail){
                break;
            }
            if(nodeA.next == tail){
                break;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }
    }
【7】实现List<E> subList(int fromIndex, int toIndex){}：
    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        //0 <= fromIndex <= toIndex <= size-1  [fromIndex,toIndex]
        if(fromIndex < 0 || toIndex >= size || fromIndex > toIndex){
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }
        LinkedSinglyList<E> list = new LinkedSinglyList<>();
        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;
        }
        Node p = nodeA;
        while(true){
            list.add(p.data);
            if(p == nodeB){
                break;
            }
            p = p.next;
        }
        return list;
    }
【8】实现String toString(){}：
    @Override
    public String toString() {
       StringBuilder sb = new StringBuilder();
       sb.append('[');
       if(isEmpty()){
           sb.append(']');
       }else{
           Node p = head;
           while(true){
               sb.append(p.data);
               if(p == tail){
                   sb.append(']');
                   break;
               }
               sb.append(',');
               sb.append(' ');
               p = p.next;
           }
       }
       return sb.toString();
    }
【9】实现Iterator<E> iterator(){}：

此处我为了方便，定义了一个内部类：LinkedSinglyListIterator ，让它实现Iterator接口

    @Override
    public Iterator<E> iterator() {
        return new LinkedSinglyListIterator();
    }
    class LinkedSinglyListIterator implements Iterator<E>{
        private Node cur = head;
        @Override
        public boolean hasNext() {
            return cur != null;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            return ret;
        }
    }
全部代码：
import p1.接口.List;
import java.util.Comparator;
import java.util.Iterator;
//单向链表
public class LinkedSinglyList<E> implements List<E> {

    //定义结点对象
    private class Node{
        E data;//数据域
        Node next;//指针域
        public Node(){
            this(null,null);
        }
        public Node(E data){
            this(data,null);
        }
        public Node(E data, Node next){
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }
    private Node head;//头指针
    private Node tail;//尾指针
    private int size;//元素的个数
    public LinkedSinglyList(){
        head = null;
        tail = null;
        size = 0;
    }
    public LinkedSinglyList(E[] arr){
        if(arr == null || arr.length == 0){
            throw new IllegalArgumentException("arr is null");
        }
        for(int i = 0; i < arr.length; i++){
            add(arr[i]);
        }
    }
    @Override
    public void add(E element) {
        add(size,element);
    }

    @Override
    public void add(int index, E element) {
        if(index < 0 || index > size){
            throw new IllegalArgumentException("add index out of range");
        }
        Node n = new Node(element);
        if(size == 0){
            head = n;
            tail = n;
        }else if(index == 0){
            n.next = head;
            head = n;
        }else if(index == size){
            tail.next = n;
            tail = n;
        }else{
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexOf(element);
        if(index != -1){
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("remove index out of range");
        }
        E ret =  null;
        if(size == 1){
            ret = head.data;
            head = null;
            tail = null;
        }else if(index == 0){
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
        }else if(index == size - 1){
            Node p = head;
            while(p.next != tail){
                p = p.next;
            }
            ret = tail.data;
            p.next = null;
            tail = p;
        }else{
            Node p = head;
            for(int i = 0; i < index - 1; i++){
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("get index out of range");
        }
        if(index == 0){
            return head.data;
        }else if(index == size - 1){
            return tail.data;
        }else{
            Node p = head;
            for(int i = 0; i < index; i++){
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("get index out of range");
        }
        E ret = null;
        if(index == 0){
            ret = head.data;
            head.data = element;
        }else if(index == size - 1){
            ret = tail.data;
            tail.data = element;
        }else{
            Node p = head;
            for(int i = 0; i < index; i++){
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while(!p.data.equals(element)){
            p = p.next;
            index++;
            if(p == null){
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }

    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if(c == null){
            throw new IllegalArgumentException("comparator can not be null");
        }
        if(size == 0 || size == 1){
            return;
        }
        Node nodeA = head;
        Node nodeB = nodeA.next;
        while(true){
            while (true){
                if(c.compare(nodeA.data, nodeB.data) > 0){
                    swap(nodeA, nodeB);
                }
                if(nodeB == tail){
                    break;
                }
                nodeB = nodeB.next;
            }
            if(nodeA == tail){
                break;
            }
            if(nodeA.next == tail){
                break;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }
    }

    private void swap(Node nodeA, Node nodeB) {
        E temp = nodeA.data;
        nodeA.data = nodeB.data;
        nodeB.data = temp;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        //0 <= fromIndex <= toIndex <= size-1  [fromIndex,toIndex]
        if(fromIndex < 0 || toIndex >= size || fromIndex > toIndex){
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }
        LinkedSinglyList<E> list = new LinkedSinglyList<>();
        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;
        }
        Node p = nodeA;
        while(true){
            list.add(p.data);
            if(p == nodeB){
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
       StringBuilder sb = new StringBuilder();
       sb.append('[');
       if(isEmpty()){
           sb.append(']');
       }else{
           Node p = head;
           while(true){
               sb.append(p.data);
               if(p == tail){
                   sb.append(']');
                   break;
               }
               sb.append(',');
               sb.append(' ');
               p = p.next;
           }
       }
       return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedSinglyListIterator();
    }
    class LinkedSinglyListIterator implements Iterator<E>{
        private Node cur = head;
        @Override
        public boolean hasNext() {
            return cur != null;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            return ret;
        }
    }
}
NPE~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 920
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
Java实现链表
cainiaowangdake的博客
06-06 1250
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
数据结构——单链表（Java实现）
m0_52861211的博客
03-26 1840
单链表增删改查，排序，反转，倒序打印，两条单链表合并
Java版的数据结构——链表
最新发布
ANNE_fly的博客
09-12 627
LinkedList的官方文档LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。【说明】实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess（该接口是实现随机访问）接口，因此LinkedList不支持随机访问。
Java中链表的实现(超详细)
m0_74000148的博客
05-24 3154
在这个示例中，我们创建了一个。在Java中，链表可以通过。 在这个示例中，我们创建了一个 LinkedList 类，它包含一个 Node 类和一些方法来操作链表。我们可以使用 push() 方法在链表的头部插入节点，使用 insertAfter() 方法在链表中间插入节点，使用 append() 方法在链表尾部插入节点，使用 deleteNode() 方法删除链表中的给定节点，并使用 printList() 方法打印链表。
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
Java-数据结构课设-链表实现通讯录管理系统
10-07
一、用链表或者顺序表实现以下系统，完成线性表的建立（至少包括10个结点），以及线性表中信息（结点）的插入、查找、删除、修改、输出等操作，具体的模块要求见上方的“总的模块要求”。建议用“文件”存储数据。 1...
java代码-使用java面向对象的方法实现链表的源代码
04-09
java代码-使用java面向对象的方法实现链表的源代码 ——学习参考资料：仅用于个人学习使用！
【Java演示】什么是链表？数据结构（三）
01-20
中间删除Java实现链表的完整代码二、双向链表 链表：随机存储，顺序访问（读取） 前言 专栏《两周干掉数据结构》 本博文的大部分插图来自于《漫画算法——小灰》，也复制了该书部分文字 我加了一些自己的总结、代码...
数组和链表——精选推荐 数组和链表.pdf
04-18
下面我们将详细介绍数组和链表的基本组成部分、特点和Java实现。 一、数组 数组是最常用的线性数据结构，数组中的元素类型是一样的，并且有序的。数组的特点是： * 数据是连续的 * 随机访问速度快 在Java中，...
JAVA链表实现类（数据结构学习）
12-14
JAVA链表实现类（数据结构学习）.chm
自行使用Java数组实现链表数据结构
04-21
NULL 博文链接：https://redhacker.iteye.com/blog/1923208
java实现链表结构_数据结构之链表及其Java实现
weixin_39716703的博客
02-16 279
数据的存储一般分线性存储结构和链式存储结构两种。前者是一种顺序的存储方式，在内存中用一块连续的内存空间存储数据，即逻辑上相连的物理位置相邻，比较常见的就是数组；后者是一种链式存储方式，不保证顺序性，逻辑上相邻的元素之间用指针所指定，它不是用一块连续的内存存储，逻辑上相连的物理位置不一定相邻。本篇主要介绍链式存储结构基于链表的实现，使用的语言为Java。链表是一种递归的数据结构，它要么为空(null...
Java数据结构--链表
weixin_56846554的博客
03-13 902
单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点由元素和指针构成。 元素表示数据元素的映象，就是存储数据的存储单元；指针指示出后继元素存储位置，就是连接每个结点的地址数据。 以结点的序列表示的线性表称作线性链表，也就是单链表，单链表是链式存取的结构。
Java数据结构之单链表（配图详解，简单易懂）
如风暖阳的博客
01-17 3940
Java数据结构之单链表（配图详解，简单易懂）
Java实现链表结构
热门推荐
wangkr的专栏
08-19 4万+
Java实现链表结构这里主要记录了一下学习用Java实现链表的方法。假设你有一点Java基础，了解接口、内部类的内容，同时也学过数据结构中链表的内容，对设计模式中的工厂方法和迭代方法知道一些，（因为这里将不介绍这些基础知识，我的水平也讲不清）又想了解在Java中实现链表，那么接着看吧。（最近读严老师应该没记错名字吧，如果错了抱歉>的帖子说应该在博文中说明帖子的读者范围，不要浪费大家的时间，这最近写...
【Java数据结构】链表
Zincy星辰
03-18 1811
1. 概况 链表在逻辑上是连续的，在物理上不一定连续。 分类： 单向、双向 带头、不带头 循环、非循环 2. 思路 data：数值域，里面存储的数据 next：引用变量 -> 下一个节点的地址 尾巴节点：当这个节点的next域为null的时候 头节点：整个链表当中的第一个节点 单向不带头非循环链表： 单向带头非循环链表： 单向不带头循环链表： 3. 定义链表节点 class Node { public int val; public...
Java基础教程——List（列表）
06-02
常见的List实现类有ArrayList和LinkedList，其中ArrayList是基于数组实现的，而LinkedList是基于链表实现的。 下面是一些常用的List操作： 1. 创建List对象： ``` List<String> list = new ArrayList(); // 创建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值