java 环形/循环链表的实现（tail）（基本功能+mintofirst将最小元素移到最前+merge将两个环形链表合并）

已于 2022-09-23 21:52:02 修改
阅读量910 收藏 1
点赞数 6
分类专栏： 数据结构 笔记 作业 文章标签： java 链表 开发语言
于 2022-09-23 21:26:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62871362/article/details/127017999
版权
笔记 同时被 3 个专栏收录
22 篇文章 1 订阅
订阅专栏
数据结构
2 篇文章 0 订阅
订阅专栏
作业
2 篇文章 0 订阅
订阅专栏

目录

完整代码：

分解部分：

图解：

属性：

Node类：

构造方法：

isEmpty、size、indexof、get方法：

add、clear方法：

remove方法：

mintofirst将最小的元素移动到最前面:

merge将两个环形链表合并:

迭代器：

完整代码：

package list;

import java.util.Iterator;

/**
 * \* (ง •_•)ง,加油
 * \* User: ttmdawn
 * \* Date: 2022/9/16
 * \* Time: 11:12
 * \* Description:单循环链表的基本操作
 * \
 */
@SuppressWarnings("all")
public class CircularLinkedListWithHeadNodeUsingTail<T> implements Ilist<T>, Iterable<T> {
    private Node<T> tail;//尾巴
    private int size;

    /**
     * Node类
     *
     * @param <T>
     */
    private static class Node<T> {
        T data;
        Node<T> next;

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

        public String toString() {//测试后面的tail有没有弄对
            return String.valueOf(data);
        }//测试用
    }

    public CircularLinkedListWithHeadNodeUsingTail() {
        tail = new Node<>(null, null);// 尾结点
        tail.next = tail;//循环起来
        //此时的链表长度依旧为0
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public int indexOf(T x) {
        int index = 0;
        for (Node<T> p = tail.next.next; p != tail.next; p = p.next) {
            if (x.equals(p.data))
                return index;
            ++index;
        }
        return -1;
    }

    // 将索引号的合法性检查抽出作为函数
    private void rangeCheckForAdd(int index) {// add用
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException(String.valueOf(index));
    }

    private void rangeCheck(int index) {// 其它函数用
        if (index < 0 || index > size - 1)
            throw new IndexOutOfBoundsException(String.valueOf(index));
    }

    public T get(int index) {
        rangeCheck(index);
        Node<T> p = tail.next.next;// 对比LinkListWithSize
        for (int i = 0; i < index; i++) // i次
            p = p.next;
        return p.data;
    }

    /**
     * add==>在最后要更改这个tail，使其一直指向末尾！
     *
     * @param index
     * @param x
     */
    public void add(int index, T x) {
        rangeCheckForAdd(index);
        Node<T> p = tail.next;
        for (int i = 0; i < index; i++) // 找到index的前驱
            p = p.next;
        p.next = new Node<>(x, p.next);
        if (p == tail) tail = p.next;//更改tail，使其一直指向末尾
        ++size;
    }

    public void clear() {
        while (tail.next != tail) {
            Node<T> q = tail.next;// q待删除结点
            tail.next = q.next;// 将q从链表中移除
            q.data = null;// 帮助GC
            q.next = null;
        }
        size = 0;
    }

    /**
     * remove
     *
     * @param index
     * @return
     */
    public T remove(int index) {
        rangeCheck(index);
        Node<T> p = tail.next;
        for (int i = 0; i < index; i++) // 找到index的前驱
            p = p.next;// p待删除结点的前驱
        Node<T> q = p.next;// q待删除结点
        if (q == tail) tail = p;//tail！！！
        p.next = q.next;// 将待删除结点从链表中移除
        T value = q.data; // q指向待删除结点
        q.data = null;// 帮助GC
        q.next = null;
        --size;
        return value;
    }

    /**
     * mintofirst将最小元素移到最前面
     * 基本思路：
     * 使用链表操作，找到最小的结点的前驱结点，然后，调整链表，从链表中摘除最小结点，再把最小结点加入第1个位置
     */
    public void mintofirst() {
        Node<T> p = tail.next;//起始位置
        Comparable<? super T> tmp = (Comparable<? super T>) p.next.data;
        Node<T> t;
        Node<T> min = p.next;//最小节点
        Node<T> min_h = p;//最小节点的前驱节点
        for (t = p.next; t != tail.next; t = t.next) {
            if (tmp.compareTo(t.data) > 0) {
                tmp = (Comparable<? super T>) t.data;
                min = t;//找到最小的那个节点
            }
        }
        for (t = p.next; t != min; t = t.next) {//找到最小的结点的前驱结点
            min_h = min_h.next;
        }
        if (min == tail) {//解决在尾部的情况
            Node<T> temp = tail;
            tail = min_h;
            tail.next = tail.next.next;
            temp.next = tail.next.next;
            tail.next.next = temp;
        } else {//普通情况
            min_h.next = min.next;
            min.next = tail.next.next;
            tail.next.next = min;
        }
    }

    /**
     * 合并
     *
     * @return
     */
    public void merge(CircularLinkedListWithHeadNodeUsingTail<T> other) {
        //剥离出带合并的有效节点
        Node<T> p = other.tail.next.next;//第二个环形链表的第一个节点
        Node<T> q = other.tail;//第二个环形链表的第二个节点
        other.tail = other.tail.next;//将tail指向other的头节点
        other.tail.next = other.tail;//自己循环，将剩下的待合并节点剥离出
        //合并两个环形链表
        q.next = tail.next;//将other原赖的尾节点连接到头节点
        tail.next = p;
        //更改尾指针的位置
        tail = q;
        //更改size大小
        size = size + other.size;
        other.size = 0;
    }

    public String toString() {
        StringBuilder str = new StringBuilder();
        for (T elem : this)// 利用了实现了的迭代器
            str.append(elem + "  ");
        return str.toString();
    }

    public Iterator<T> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<T> {
        private Node<T> currentNode;

        public Itr() {
            currentNode = tail.next.next;//！！！
        }

        public boolean hasNext() {
            return currentNode != tail.next;//！！！
        }

        public T next() {
            T data = currentNode.data;
            currentNode = currentNode.next;
            return data;
        }
    }
}

分解部分：

图解：

属性：

private Node<T> tail;//尾巴
private int size;

使用tail（尾节点/尾指针），tail.next即为head头节点，此处的head为空，是一个伪节点，tail.next.next指向第一个元素。

tail为尾节点，永远指向最后一个元素。

Node类：

/**
     * Node类
     *
     * @param <T>
     */
    private static class Node<T> {
        T data;
        Node<T> next;

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

        public String toString() {//测试后面的tail有没有弄对
            return String.valueOf(data);
        }//测试用
    }

构造方法：

public CircularLinkedListWithHeadNodeUsingTail() {
        tail = new Node<>(null, null);// 尾结点
        tail.next = tail;//循环起来
        //此时的链表长度依旧为0
    }

初始化时，tail为空，tail.next指向tail，形成循环

isEmpty、size、indexof、get方法：

public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public int indexOf(T x) {
        int index = 0;
        for (Node<T> p = tail.next.next; p != tail.next; p = p.next) {
            if (x.equals(p.data))
                return index;
            ++index;
        }
        return -1;
    }

public T get(int index) {
        rangeCheck(index);
        Node<T> p = tail.next.next;// 对比LinkListWithSize
        for (int i = 0; i < index; i++) // i次
            p = p.next;
        return p.data;
    }

add、clear方法：

/**
     * add==>在最后要更改这个tail，使其一直指向末尾！
     *
     * @param index
     * @param x
     */
    public void add(int index, T x) {
        rangeCheckForAdd(index);
        Node<T> p = tail.next;
        for (int i = 0; i < index; i++) // 找到index的前驱
            p = p.next;
        p.next = new Node<>(x, p.next);
        if (p == tail) tail = p.next;//更改tail，使其一直指向末尾
        ++size;
    }

    public void clear() {
        while (tail.next != tail) {
            Node<T> q = tail.next;// q待删除结点
            tail.next = q.next;// 将q从链表中移除
            q.data = null;// 帮助GC
            q.next = null;
        }
        size = 0;
    }

add与后面的remove在执行时都要注意tail永远指向最后一个节点

链表增加或减少都要注意size的变化

remove方法：

/**
     * remove
     *
     * @param index
     * @return
     */
    public T remove(int index) {
        rangeCheck(index);
        Node<T> p = tail.next;
        for (int i = 0; i < index; i++) // 找到index的前驱
            p = p.next;// p待删除结点的前驱
        Node<T> q = p.next;// q待删除结点
        if (q == tail) tail = p;//tail！！！
        p.next = q.next;// 将待删除结点从链表中移除
        T value = q.data; // q指向待删除结点
        q.data = null;// 帮助GC
        q.next = null;
        --size;
        return value;
    }

清除不要忘记帮助GC，即清除内存

mintofirst将最小的元素移动到最前面:

/**
     * mintofirst将最小元素移到最前面
     * 基本思路：
     * 使用链表操作，找到最小的结点的前驱结点，然后，调整链表，从链表中摘除最小结点，再把最小结点加入第1个位置
     */
    public void mintofirst() {
        Node<T> p = tail.next;//起始位置
        Comparable<? super T> tmp = (Comparable<? super T>) p.next.data;
        Node<T> t;
        Node<T> min = p.next;//最小节点
        Node<T> min_h = p;//最小节点的前驱节点
        for (t = p.next; t != tail.next; t = t.next) {
            if (tmp.compareTo(t.data) > 0) {
                tmp = (Comparable<? super T>) t.data;
                min = t;//找到最小的那个节点
            }
        }
        for (t = p.next; t != min; t = t.next) {//找到最小的结点的前驱结点
            min_h = min_h.next;
        }
        if (min == tail) {//解决在尾部的情况
            Node<T> temp = tail;
            tail = min_h;
            tail.next = tail.next.next;
            temp.next = tail.next.next;
            tail.next.next = temp;
        } else {//普通情况
            min_h.next = min.next;
            min.next = tail.next.next;
            tail.next.next = min;
        }
    }

基本思路：
使用链表操作，找到最小的结点的前驱结点，然后，调整链表，从链表中摘除最小结点，再把最小结点加入第1个位置

merge将两个环形链表合并:

 /**
     * 合并
     *
     * @return
     */
    public void merge(CircularLinkedListWithHeadNodeUsingTail<T> other) {
        //剥离出带合并的有效节点
        Node<T> p = other.tail.next.next;//第二个环形链表的第一个节点
        Node<T> q = other.tail;//第二个环形链表的第二个节点
        other.tail = other.tail.next;//将tail指向other的头节点
        other.tail.next = other.tail;//自己循环，将剩下的待合并节点剥离出
        //合并两个环形链表
        q.next = tail.next;//将other原赖的尾节点连接到头节点
        tail.next = p;
        //更改尾指针的位置
        tail = q;
        //更改size大小
        size = size + other.size;
        other.size = 0;
    }

思路看代码注释；

上课讲解视频：阿里云盘分享 (aliyundrive.com)

迭代器：

public String toString() {
        StringBuilder str = new StringBuilder();
        for (T elem : this)// 利用了实现了的迭代器
            str.append(elem + "  ");
        return str.toString();
    }

    public Iterator<T> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<T> {
        private Node<T> currentNode;

        public Itr() {
            currentNode = tail.next.next;//！！！
        }

        public boolean hasNext() {
            return currentNode != tail.next;//！！！
        }

        public T next() {
            T data = currentNode.data;
            currentNode = currentNode.next;
            return data;
        }
    }

明天谭
关注
  • 6
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
＜T extends Comparable＜? super T＞＞简单理解
狼在中北的博客
05-10 108
假设T extends S 简单理解如下 <T extends Comparable<? super T>>要求:要么传入类型T实现了Comparable<T>，或者S实现Comparable<S> <T extends Comparable<T>>则要求:T实现Comparable<T>
【数据结构】单向循环链表的实现
柳阿九的博客
02-08 554
不带头单向循环链表结构如下: 其中，详细介绍不带头单向循环链表的排序功能的实现。 以以下链表为例： 第一步： 将该单向循环链表分成只有一个结点的单向循环链表p和由剩下结点组成的一个单向不循环链表q。 第二步： 将p指向q链表要比较的第一个结点，q用来保存下一个结点，prev用来保存要插入位置的前一个节点的位置，cur用来保存要插入位置的结点。 比较 1<2，并没有进入第二个while中，此时prev仍为NULL，故应该将结点头插进入该单向循环链表中，由于头插会改变头结点，而单向循环链表的尾结点会
双向循环链表，java例子
qq_40382400的博客
06-03 145
方法，用于在链表的头部和尾部插入节点。在插入节点时，我们更新相应的指针以建立节点之间的双向循环连接。运行示例代码会输出：1 2 3 4 5，表示双向循环链表中节点的顺序。在循环链表中，我们可以从任。类，用于表示双向循环链表中的节点。意一个节点出发，通过循环遍历访问到链表的所有节点。类，作为双向循环链表的主要实现。两个节点指针，用于表示链表的头部和尾部。字段，以及指向前一个节点和后一个节点的。类中，我们创建了一个双向循环链表对象。方法来打印出链表中的所有节点数据。在上述示例中，我们首先定义了一个。
java 实现 tail -f 实时查看日志
qq_20025777的博客
12-19 821
java 实现 tail -f 实时查看日志
nohup运行Java tail 查看日志
二掌柜的博客
04-10 3523
后台运行命令：nohupnohup命令：nohup是不挂断的意思( no hang up)。如果你正在运行一个进程，而且你觉得在退出帐户时该进程还不会结束，那么可以使用nohup命令。该命令忽略所有挂（SIGHUP）信号，可以在你退出帐户/关闭终端之后继续运行相应的进程。
链表_链表_用链表将两个数组升序合并到另一个数组_
10-02
本主题探讨的是如何利用链表将两个已排序的数组升序合并到一个新的数组中。这个操作在数据处理、排序算法以及各种复杂的数据结构实现中都有广泛的应用。 链表与数组相比，它的主要优势在于插入和删除操作的时间...
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
07-03
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
探讨:将两个链表非降序合并为一个链表并依然有序的实现方法
09-05
总的来说，将两个非降序链表合并为一个有序链表的过程涉及到了链表的基本操作，包括创建、遍历、比较和插入。这个操作对链表的逻辑理解要求较高，需要精确控制节点的指针关系以保证最终链表的正确性。在实际编程中，...
java编程题之合并两个排序的链表
08-26
"java编程题之合并两个排序的链表" ...本文详细介绍了java编程题之合并两个排序的链表，包括链表基本概念、链表的基本操作、合并两个排序的链表的算法和实现等内容。希望本文能够对大家的学习和工作有所帮助。
基于Java实现的单链表基本操作之链表合并.zip
最新发布
04-26
合并两个有序链表的目标是创建一个新的有序链表，其中的元素按从小到大的顺序排列。以下是一个简单的Java实现： ```java public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if (l1 == null) return l2; ...
java实现tail功能
03-07
简单实现查看服务器上指定位置日志功能，可以实现看最后N行功能。参数：行数，文件路径
java tail文件读取_java实现的文件tail的方法
weixin_31190007的博客
02-16 657
最近写了的一个项目,开始的目的是同步静态资源的，后来想想可以增加一个远程tail的功能，就是把不同服务器上面的日志文件，通过tail的方式汇总到某一台服务器，这样一些分布式的系统的日志可以被汇总起来查看，方便追踪问题。具体的代码请移步http://git.oschina.net/grom/rainyPS：想要加入该项目开发的同志，请积极联系我。后期开发计划：1.Mbean实时监控和属性更改2....
别小看tail 命令，它难倒了技术总监
小张的博客
11-05 821
tail命令能够看到日志的滚动，非常方便。于是，既然我们能够用这个命令，看到所有的日志，那能不能使用tail命令，做日志收集呢？ 你知道tail -f和tail -F的区别么？测试一下第一步，创建要监控的文件第二步，启动我们的Java代码第三步，生成一个不间断的流第四步，模拟文件滚动Why?End ) 想象归想象，如果你想要一个快速的实时日志收集工具，那tail确实是个非常棒的工具。它比什么flume、logstatsh，比什么filebeat之类的，快捷的多。事实上，在工具缺乏的旧年代，我就曾经这么干过，
java tail_Java用WebSocket + tail命令实现Web实时日志
weixin_34498545的博客
02-12 343
原文：http://blog.csdn.net/xiao__gui/article/details/50041673在Linux操作系统中，经常需要查看日志文件的实时输出内容，通常会使用tail -f或者tailf命令。查看实时日志可能会需要首先SSH连上Linux主机，步骤很麻烦不说，如果是生产环境的服务器，可能还会控制各种权限。基于Web的实时日志可以解决这个问题。由于传统的HTTP协议是请求...
java代码实现链表并解决约瑟夫问题
于枭森的博客
09-14 511
本文通过java代码实现单向链表，双向链表以及单向环形链表，以及介绍了相关的操作思路，解决了约瑟夫问题。
【Java版oj】环形链表
m0_63372226的博客
10-23 640
还有人可能会想到遍历到同一个结点就算是找到闭环了，但是这种方法要保存遍历过的所有结点，在已经遍历过的结点中查找是否存在相等，时间复杂度是O(n)，空间复杂度也是O(n)。假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表起始位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。，不会出现每次刚好是套圈的情况，因此：在慢指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。指针再次到达，则链表中存在环。
java实现tail_JAVA 实现tail -f 日志文件监控功能详解
weixin_39532421的博客
02-12 796
1 /*2 * Licensed to the Apache Software Foundation (ASF) under one or more3 * contributor license agreements. See the NOTICE file distributed with4 * this work for additional information regarding co...
java数据结构之--环形链表
wcguang博客
11-10 655
单项环形链表，约瑟夫问题
java 环形链表的示例
孤舟残月梦还长存的专栏
10-15 604
环形链表是解决像约瑟夫环问题的类似问题的求解。
将自定义对象Worker存到两个链表，用merge合并，再用迭代器遍历输出合并各结点
06-09
首先，我们初始化两个链表`list1`和`list2`，并将`list2`合并到`list1`中，这个过程可以使用`std::list::merge`函数实现。最后，我们使用迭代器`std::list::iterator`遍历输出合并后的链表元素。 希望这个示例代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值