Java实现单链表_使用链式存储结构

最新推荐文章于 2022-05-18 21:18:33 发布
最新推荐文章于 2022-05-18 21:18:33 发布
阅读量100 收藏
点赞数
文章标签： 数据结构与算法 java
原文链接：https://my.oschina.net/xinxingegeya/blog/313791
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

Java实现单链表_使用链式存储结构

单链表的示意图：http://my.oschina.net/xinxingegeya/blog/261287

贴代码，部分代码参考：http://blog.csdn.net/zhangerqing/article/details/8796518

package hash;

/**
 * Created with IntelliJ IDEA.
 * User: ASUS
 * Date: 14-9-15
 * Time: 下午6:58
 * To change this template use File | Settings | File Templates.
 */
public class CustomLinkedList01<T> {

    /**
     * 用来表示单链表的节点类
     * class node
     *
     * @param <T>
     * @author egg
     */
    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }

        Node(T data) {
            this(data, null);
        }

        Node() {
        }
    }

    //头指针指向头结点
    //头结点的数据域不存储数据
    private Node<T> head;  //单链表的头节点

    //初始化链表，初始化后的链表为空
    public CustomLinkedList01() {
        head = new Node<T>();  //头结点
    }

    /**
     * judge the list is empty
     * 除头结点外没有其他节点，该链表为空
     */
    public boolean isEmpty() {
        return head.next == null;
    }

    /**
     * 打印链表
     * print the list
     */
    public void traverse() {
        Node<T> p = head.next;
        for (Node<T> n = p; n != null; n = n.next)
            System.out.println(n.data);
    }

    /**
     * insert node from head
     * 头插法
     */
    public void addFromHead(T item) {
        Node<T> newNode = new Node<T>(item);   //实例化一个节点
        Node<T> p = head.next;
        head.next = newNode;
        newNode.next = p;//新节点的后继元素原来的head
    }

    /**
     * 尾插法
     * insert node from tail
     */
    public void addFromTail(T item) {
        Node<T> newNode = new Node<T>(item); //实例化一个新节点
        Node<T> p = head;
        while (p.next != null) { //遍历到单链表的尾
            p = p.next;
        }
        p.next = newNode;    //尾节点的后继节点为新节点
        newNode.next = null; //新节点的后继节点为空
    }

    /**
     * delete node from head
     */
    public void removeFromHead() {
        if (!isEmpty()) {
            Node<T> p = head.next;  //删除第一个节点
            head.next = p.next;
        } else {
            System.out.println("The list have been emptied!");
        }
    }

    /**
     * delete tail, lower effect
     * 删除最后一个节点
     */
    public void removeFromTail() {
        if (isEmpty()) {
            System.out.println("The list have been emptied!");
        } else {
            //如果curr.next == null说明curr为最后一个节点
            Node<T> prev = head, curr = head.next;
            while (curr.next != null) {
                prev = curr;
                curr = curr.next;
            }
            prev.next = null;
        }
    }

    /**
     * insert a new node
     * 在元素前面插入item
     *
     * @param appointedItem
     * @param item
     * @return
     */
    public boolean insertBefore(T appointedItem, T item) {
        Node<T> prev = head, curr = head.next, newNode;
        newNode = new Node<T>(item);
        //当到达尾节点或找到元素，跳出循环
        while ((curr != null) && (!appointedItem.equals(curr.data))) {
            prev = curr;
            curr = curr.next;
            // 如果到达链表的尾端，说明没有找到插入点
            if (curr == null) {
                return false;
            }
        }
        newNode.next = curr;
        prev.next = newNode;
        return true;
    }

    /**
     * insert a new node
     *
     * @param appointedItem
     * @param item
     * @return
     */
    public boolean insertAfter(T appointedItem, T item) {
        Node<T> newNode = new Node<T>(item);
        Node<T> curr = head.next;
        //当到达尾节点或找到元素，跳出循环
        while ((curr != null) && (!appointedItem.equals(curr.data))) {
            curr = curr.next;
            if (curr == null) {
                return false;
            }
        }
        Node<T> p = curr.next;
        newNode.next = p;
        curr.next = newNode;
        return true;
    }


    /**
     * 删除节点
     *
     * @param item
     */
    public void remove(T item) {
        Node<T> curr = head.next, prev = head;
        while (curr != null) {
            if (item.equals(curr.data)) {
                prev.next = curr.next;
                return;
            } else {
                prev = curr;
                curr = curr.next;
            }
        }
    }

    /**
     * 通过遍历整个链表查找元素
     *
     * @param item
     * @return
     */
    public int indexOf(T item) {
        int index = 0;
        for (Node<T> p = head.next; p != null; p = p.next) {
            if (item.equals(p.data)) {
                return index;
            }
            index++;
        }
        return -1;
    }


    /**
     * judge the list contains one data
     */
    public boolean contains(T item) {
        return indexOf(item) != -1;
    }

    public static void main(String args[]) {
        CustomLinkedList01 linkedList = new CustomLinkedList01();

        linkedList.addFromHead("s1");
        linkedList.addFromHead("s2");
        linkedList.addFromHead("s3");
        linkedList.addFromHead("s4");
        linkedList.addFromHead("s5");
        linkedList.addFromHead("s6");
        linkedList.addFromTail("s00");
        linkedList.addFromTail("s01");
        linkedList.addFromTail("s02");

        System.out.println(linkedList.contains("s03"));

        System.out.println("#############insertBefore###############");
        linkedList.remove("s1");
        linkedList.traverse();


        System.out.println("#############insertBefore###############");
        linkedList.insertBefore("s3", "mm");
        linkedList.insertBefore("s02", "mm");
        linkedList.traverse();


        System.out.println("#############insertAfter###############");
        linkedList.insertAfter("mm", "uu");
        linkedList.insertAfter("uu", "pp");
        linkedList.traverse();

        System.out.println("#############removeFromHead###############");
        linkedList.removeFromHead();
        linkedList.traverse();


        System.out.println("#############removeFromTail###############");
        linkedList.removeFromTail();
        linkedList.traverse();


        System.out.println("#############removeFromTail###############");
        linkedList.removeFromTail();
        linkedList.traverse();
    }
}

 

在Java中，linkedList是这样一种存储结构

202932_u4OT_1469576.png

示例代码如下，

package hash;

public class LinkedList<T> {

    /**
     * class node
     *
     * @param <T>
     * @author egg
     */
    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }

        Node(T data) {
            this(data, null);
        }
    }

    // data
    private Node<T> head, tail;

    public LinkedList() {
        head = tail = null;
    }

    /**
     * judge the list is empty
     */
    public boolean isEmpty() {
        return head == null;
    }

    /**
     * add head node
     */
    public void addHead(T item) {
        head = new Node<T>(item);
        if (tail == null)
            tail = head;
    }

    /**
     * add the tail pointer
     */
    public void addTail(T item) {
        if (!isEmpty()) {
            tail.next = new Node<T>(item);
            tail = tail.next;
        } else {
            head = tail = new Node<T>(item);
        }
    }

    /**
     * print the list
     */
    public void traverse() {
        if (isEmpty()) {
            System.out.println("null");
        } else {
            for (Node<T> p = head; p != null; p = p.next)
                System.out.println(p.data);
        }
    }

    /**
     * insert node from head
     */
    public void addFromHead(T item) {
        Node<T> newNode = new Node<T>(item);
        newNode.next = head;
        head = newNode;
    }

    /**
     * insert node from tail
     */
    public void addFromTail(T item) {
        Node<T> newNode = new Node<T>(item);
        Node<T> p = head;
        while (p.next != null)
            p = p.next;
        p.next = newNode;
        newNode.next = null;
    }

    /**
     * delete node from head
     */
    public void removeFromHead() {
        if (!isEmpty())
            head = head.next;
        else
            System.out.println("The list have been emptied!");
    }

    /**
     * delete frem tail, lower effect
     */
    public void removeFromTail() {
        Node<T> prev = null, curr = head;
        while (curr.next != null) {
            prev = curr;
            curr = curr.next;
            if (curr.next == null)
                prev.next = null;
        }
    }

    /**
     * insert a new node
     *
     * @param appointedItem
     * @param item
     * @return
     */
    public boolean insert(T appointedItem, T item) {
        Node<T> prev = head, curr = head.next, newNode;
        newNode = new Node<T>(item);
        if (!isEmpty()) {
            while ((curr != null) && (!appointedItem.equals(curr.data))) {
                prev = curr;
                curr = curr.next;
            }
            newNode.next = curr;
            prev.next = newNode;
            return true;
        }
        return false;
    }

    public void remove(T item) {
        Node<T> curr = head, prev = null;
        boolean found = false;
        while (curr != null && !found) {
            if (item.equals(curr.data)) {
                if (prev == null)
                    removeFromHead();
                else
                    prev.next = curr.next;
                found = true;
            } else {
                prev = curr;
                curr = curr.next;
            }
        }
    }


    public int indexOf(T item) {
        int index = 0;
        Node<T> p;
        for (p = head; p != null; p = p.next) {
            if (item.equals(p.data))
                return index;
            index++;

        }
        return -1;
    }

    /**
     * judge the list contains one data
     */
    public boolean contains(T item) {
        return indexOf(item) != -1;
    }
}

=====END=====

转载于:https://my.oschina.net/xinxingegeya/blog/313791

weixin_33816611
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构和算法(二)Java实现单向链表
yuan_xw的专栏
02-17 408
1. 数据结构和算法(二)Java实现单向链表 1.1 什么是单向链表   单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点； 链表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针...
Java数据结构与算法之LinkedList单链表
Andy_lau
10-02 3605
目录： 1.链表概述 2.链表分类即结构 3.单链表 3.1 自定义单链表需要实现的功能(方法) 3.2 单链表实现代码 1.链表概述： 链表具有逻辑连续，物理存储不连续且大小不固定的特点，它是基于指针实现的。其中单链表和单向循环链表中的每一个节点包含了一 个数据域和一个指针域，数据域保存节点的数据，指针域保存节点的下一个节点位置，当需要查找当前节点的下一个节点时，即可通过
Java集合Collection之实现原理解读(LinkedList)
weixiaohuai的博客
10-03 1337
一、简介 LinkedList与ArrayList一样都实现了List接口，不过LinkedList底层实现是双向链表，对于插入、修改、删除速度比较快，对于查询就比较慢，因为要循环遍历查找。本章将模仿LinkedList源码实现一个简单的自定义LinkedList，以帮助饿哦们理解LinkedList底层是怎么实现的。 二、实现原理 LinkedList底层是通过双向链表实现的，通过一系列的...
java单链表存储结构_Java实现单链表_使用链式存储结构
weixin_39834475的博客
02-13 126
Java实现单链表_使用链式存储结构packagehash;/***CreatedwithIntelliJIDEA.*User:ASUS*Date:14-9-15*Time:下午6:58*TochangethistemplateuseFile|Settings|FileTemplates.*/publicclassCustomLinkedList01...
数据结构与算法-第三章 链表
Chaneon的博客
12-30 820
第三章 链表 3.1 链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下 小结上图: 链表是以节点的方式来存储,是链式存储 每个节点包含data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点) 逻辑结构示意图如下 3.2 单链表的应用实例 使用带h...
java实现单链表
12-22
1）链表是以节点的方式来存储,是链式存储。 2）每个节点包含 data 域， next 域：指向下一个节点。 3）如上图：发现链表的各个节点不一定是连续存储。 4）链表分带头节点的链表和没有头节点的链表，根据实际的需求来...
Java栈之链式栈存储结构的实现代码
08-30
以下是Java栈之链式栈存储结构的实现代码的相关知识点： 一、链栈的定义 链栈是一种使用链表来存储元素的栈结构。在链栈中，每个元素都是一个独立的对象，节点中保存着数据和指向下一个节点的引用。链栈的实现可以...
基于链式存储结构的线性表实现.rar_Table_cameramjx_data structure
09-20
在"Table_cameramjx_data structure"这个主题中，我们可能会看到如何使用C++或Java等编程语言实现这些链式存储结构，并讨论它们在实际问题中的应用，如数据缓存、队列、栈等。通过这个资源，学习者可以深入理解链式...
Java实现带头结点的单链表
08-25
Java实现带头结点的单链表是一种链式数据结构，链表的特点是以节点方式存储，是链式结构。每个节点包含data域，next域：指向下一个节点。链表的各个节点不一定是连续存储。链表分为带头节点和不带头节点两种类型的...
单链表是一种链式存取的数据结构.pdf
最新发布
04-01
单链表作为一种典型的链式存储结构，其核心在于使用一组地址任意分布的存储单元来存储线性表中的数据元素。与数组不同，单链表中的数据不是连续存储的，而是通过指针链接起来形成一个整体。在单链表中，每个结点由两...
用链表实现线性表java
07-02
用链表实现线性表java用链表实现线性表
数据结构之链表（Java实现）
Easenyang的博客
05-18 8247
数据结构中线性表的重要知识之一
数据结构-链式存储结构（单链表）Java实现
master_1997的博客
09-19 1254
在之前学习了线性表的顺序存储结构之后，我们知道顺序存储结构的优点就是查询和修改速度快，但是它也是有缺点的，那就是插入和删除需要移动大量的元素，显然非常的耗费时间，所以我们就需要学习新的知识来解决这个问题，那就是链式存储结构。顺序存储结构的缺点，恰恰就是链式存储结构的优点。 线性表链式存储结构定义 为了表示每个数据元素ai与其直接后继数据元素ai+1 之间的逻辑关系,对数据元素ai来说,除了存储其本...
单链表的存储方式及实现（java语言描述）
信念随梦的博客
06-25 4930
顺序存储虽然是一种很有用途的存储结构，但也有很多局限性：      (1)若要为线性表扩充存储空间，则需重新创建一个地址连续的更大的存储空间，并把原有的数据元素都复制到新的存储空间中；      (2)因为顺序存储要求逻辑上相邻的数据元素，在物理存储位置上也是相邻，这就使得增删的数据元素会引起平均约一半的数据元素的移动。 针对这些情况，我们通常采用链式存储结构。      链式存储
java的链式存储结构
Fuzz
05-30 5147
首先，我们应该先了解计算机内部的物理存储结构。计算机的主要外存就是软盘和硬盘，现在光说硬盘，硬盘是由一个个盘面组成的，每个盘面上由两个磁头读取数据（正反面）。每个盘面上分为若干个扇区。这里主要用到堆和栈。堆是存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，还可以...
java单链表存储结构_Java数据结构之图解单链表
weixin_42427302的博客
02-13 1123
链表(Linked List)介绍：1，链表是以节点的方式来存储是链式存储2，每个节包含 data域：存储信息next域：指向下一个节点。3，链表的各个节点不一定是连续存储的。4，链表分带头结点的链表和没有头节点的链表，根据实际情况来确定链表在内存中的存储形式：由此得出：链表的各个节点不一定是连续存储的。 单链表的逻辑结构示意图：每一个节点Node中都包含一个data域和一个指针域。 链表的...
线性表的链式存储结构之单链表类的实现_Java
AngelHacker|Java|C++|.Net
08-20 4574
在之前的两篇博文——线性表接口的实现_Java和线性表的链式存储结构之单链表结点类的实现_Java中，我们实现了线性表的接口和单链表的结点类，今天让我们来实现线性表的链式存储结构——单链表类。 注释写得很详细了，直接看吧： package dataStructure.
Java 链表完整版(单向)
Java软贱攻城狮
02-06 2369
范例：class Link { class Node { private Node next;// 下一个节点 private Object data;// 数据 // 构造方法 public Node(Object data) { this.data = data; } // 1.节点的增加 // 第一次调用:this=Link.root // 第二次...
数据结构——Java单链表的实现
朱砂绛的博客
03-17 1216
数据结构在计算机科学中是一门综合性的专业基础课，因此对于它的理解是很重要。数据的储存结构分为顺序存储结构和链式存储结构。前一种存储结构则需要在内存中使用一块连续的内存去进行存储，通常借助程序设计语言的数组来描述。后一种存储结构无需保证元素在内存存储位置上的连续性，只需要在逻辑上相邻的元素之间用指针来指定，通常借助程序设计语言的指针类型来描述。 而Java中并没有显示的指针，无法得到每个元素的地址...
Java实现数据结构：单链表与存储结构详解
物理结构，即数据的存储结构，是指数据在内存中的布局方式，它取决于逻辑结构的选择。在Java中，数据类型分为基本类型（如整数、浮点数、字符和布尔）和构造类型（如数组、类和接口）。数据结构本身定义为有限集合，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值