java 不带头结点的单链表实现（基本功能+reverse逆序+removeRange删除区间+lastIndex该元素最后出现的位置+add直接添加保证顺序）

最新推荐文章于 2022-10-24 09:59:44 发布
最新推荐文章于 2022-10-24 09:59:44 发布
阅读量669 收藏
点赞数 1
分类专栏： 笔记 数据结构 作业 文章标签： java servlet jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62871362/article/details/127018304
版权
笔记 同时被 3 个专栏收录
22 篇文章 1 订阅
订阅专栏
数据结构
2 篇文章 0 订阅
订阅专栏
作业
2 篇文章 0 订阅
订阅专栏

目录

完整代码：

reverse逆序：

removerange删除区间：

lastindex该元素最后出现的位置：

add直接添加，保证顺序正确

完整代码：

package list;

import java.util.Iterator;

//不带头结点的单链表
@SuppressWarnings("all")
public class CLinkedList<T> implements Ilist<T>, Iterable<T>, Cloneable {
    /**
     * Node 内部类
     *
     * @param <T>
     */
    private static class Node<T> {
        // 注意和Itr类的比较，通过这个例子，应该能明白静态嵌套类和内部类的使用场合
        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);
        }//测试用
    }

    private Node<T> head;
    private int size;

    public CLinkedList() {
        // head = null;
        // size = 0;
    }

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

    /**
     * size
     *
     * @return size
     */
    public int size() {
        return size;
    }

    /**
     * indexOf x不能为null
     *
     * @param x
     * @return
     */
    public int indexOf(T x) {
        int index = 0;
        for (Node<T> p = head; p != null; p = p.next) {
            if (x.equals(p.data))
                return index;
            ++index;
        }
        return -1;
    }

    /**
     * indexOf1 数据就可以是null，x也可以是null
     *
     * @param x
     * @return
     */
    public int indexOf1(T x) {
        if (x == null) {
            int index = 0;
            for (Node<T> p = head; p != null; p = p.next) {
                if (p.data == null)
                    return index;
                ++index;
            }
        } else {
            int index = 0;
            for (Node<T> p = head; p != null; p = p.next) {
                if (x.equals(p.data))
                    return index;
                ++index;
            }
        }
        return -1;
    }

    // 可以这样写，但是，java类库用的前面的indexOf的写法，使用引用变量控制循环，不要用下面的写法
    public int indexOf2(T x) {
        Node<T> p = head;
        for (int index = 0; index < size; ++index) {
            if (x.equals(p.data))
                return index;
            p = p.next;
        }
        return -1;
    }

    // 可以用while，但是，看起来没有for容易理解，不要使用
    public int indexOf3(T x) {
        Node<T> p = head;
        int index = 0;
        while (p != null) {
            if (x.equals(p.data))
                return index;
            p = p.next;
            ++index;
        }
        return -1;
    }

    /**
     * 将索引号的合法性检查抽出作为方法
     *
     * @param index
     */
    private void rangCheckForAdd(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));
    }

    /**
     * get
     *
     * @param index
     * @return
     */
    public T get(int index) {
        rangeCheck(index);
        Node<T> p = head;
        for (int i = 0; i < index; i++) // 找到结点index
            p = p.next;
        return p.data;
    }

    /**
     * add
     *
     * @param index
     * @param x
     */
    public void add(int index, T x) {
        rangCheckForAdd(index);
        if (index == 0) {// 空表，及插入位置0
            head = new Node<>(x, head);
        } else {
            Node<T> p = head;
            for (int i = 0; i < index - 1; i++) // 找到index的前驱
                p = p.next;
            p.next = new Node<>(x, p.next);
        }
        ++size;
    }

    /**
     * remove
     *
     * @param index
     * @return
     */
    public T remove(int index) {
        rangeCheck(index);
        Node<T> p = head;
        if (index == 0) {// 肯定不为空
            head = head.next;
        } else {// 至少有2个结点
            // 找到index的前驱
            for (int i = 0; i < index - 1; i++)
                p = p.next;
            Node<T> q = p;
            p = p.next;
            q.next = p.next;
        }
        // p引用待删除结点
        T value = p.data;
        p.data = null;// 帮助GC
        p.next = null;
        --size;
        return value;
    }

    /**
     * reverse
     */
    public void reverse() {//逆序
        if (head == null || head.next == null) return;
        Node<T> p = head.next;//先指到第2个节点
        head.next = null;//把第一个节点断开
        while (p != null) {
            Node<T> q = p.next;//后移
            //将p插入头结点之后
            p.next = head;
            head = p;
            p = q;//继续访问下一个元素
        }
    }

    /**
     * removeRange
     *
     * @param from
     * @param to
     */
    public void removeRange(int from, int to) {
        rangeCheck(from);
        rangeCheck(to);//检查index
        Node<T> from_h = head;
        Node<T> to_b = head;
        Node<T> p = head;//帮助GC的指针
        if (from == 0) {//from在开头的情况
            for (int i = 0; i < to + 1; i++) {
                p = to_b.next;
                to_b = null;
                to_b = p;
            }
            head = to_b;
        } else {//一般情况
            for (int i = 0; i < to + 1; i++) {
                if (i < from - 1) {
                    from_h = from_h.next;
                }
                p = to_b.next;
                to_b = null;
                to_b = p;
            }
            from_h.next = to_b;
        }
        size = size - (to - from + 1);//更改size
    }

    /**
     * lastIndex
     *
     * @param x
     * @return
     */
    public int lastIndex(T x) {
        Node<T> p = head;
        int index = -1;
        int i = 0;
        while (p != null) {
            if (p.data.equals(x)) {
                index = i;
            }
            i++;
            p = p.next;
        }
        return index;
    }

    /**
     * add
     *
     * @param x
     */
    public void add(T x) {
        Comparable<? super T> tmp = (Comparable<? super T>) x;
        if (size == 0) {//空表情况，及插入位置0
            head = new Node<>(x, head);
        } else {//非空表情况
            Node<T> p = head;
            Node<T> temp = head;
            int i;
            for (i = 0; i < size; i++) {
                if (tmp.compareTo((T) p.data) < 0)
                    break;
                p = p.next;
            }
            if (i==0){//第一个位置的情况
                head=new Node<>(x,head);
            }else {//普通情况
                p=head;
                for (int j = 0; j < i-1; j++) {
                    p=p.next;
                }
                p.next=new Node<>(x, p.next);
            }
        }

        ++size;//调整size
    }

    /**
     * clear
     */
    public void clear() {
        while (head != null) {// 从第1个结点开始，逐个删除
            Node<T> q = head;// q待删除结点
            head = head.next;// 下一个结点

            q.data = null;// 帮助GC
            q.next = null;
        }
        size = 0;
    }

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

    public boolean equals(Object obj) {
        if (this == obj)
            return true;

        if (obj instanceof CLinkedList<?>) {
            CLinkedList<?> rhd = (CLinkedList<?>) obj;
            if (this.size != rhd.size)
                return false;
            for (Node<?> p = head, q = rhd.head; p != null; p = p.next, q = q.next) {
                if (!p.data.equals(q.data))
                    return false;
            }
            return true;
        }
        return false;
    }

    public int hashCode() {
        int result = 1;
        for (Node<T> p = head; p != null; p = p.next)
            result = result * 31 + p.data.hashCode();
        return result;
    }

    @SuppressWarnings("unchecked")
    private CLinkedList<T> superClone() {
        try {
            return (CLinkedList<T>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }
    }

    public Object clone() {
        CLinkedList<T> v = superClone();// v的head和size与this的head和size相同
        if (v.head == null)// 空链表
            return v;
        // 为v分配新的结点，不能与this共用
        v.head = new Node<>(head.data, null);
        for (Node<T> p = head.next, q = v.head; p != null; p = p.next, q = q.next)
            q.next = new Node<>(p.data, null);
        return v;
    }

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

    private class Itr implements Iterator<T> {// 注意Itr是内部类，而 Node是静态的嵌套类
        private Node<T> currentNode;

        public Itr() {
            currentNode = head;
        }

        public boolean hasNext() {
            return currentNode != null;
        }

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

    }

    
}

reverse逆序：

/**
     * reverse
     */
    public void reverse() {//逆序
        if (head == null || head.next == null) return;
        Node<T> p = head.next;//先指到第2个节点
        head.next = null;//把第一个节点断开
        while (p != null) {
            Node<T> q = p.next;//后移
            //将p插入头结点之后
            p.next = head;
            head = p;
            p = q;//继续访问下一个元素
        }
    }

removerange删除区间：

/**
     * removeRange
     *
     * @param from
     * @param to
     */
    public void removeRange(int from, int to) {
        rangeCheck(from);
        rangeCheck(to);//检查index
        Node<T> from_h = head;
        Node<T> to_b = head;
        Node<T> p = head;//帮助GC的指针
        if (from == 0) {//from在开头的情况
            for (int i = 0; i < to + 1; i++) {
                p = to_b.next;
                to_b = null;
                to_b = p;
            }
            head = to_b;
        } else {//一般情况
            for (int i = 0; i < to + 1; i++) {
                if (i < from - 1) {
                    from_h = from_h.next;
                }
                p = to_b.next;
                to_b = null;
                to_b = p;
            }
            from_h.next = to_b;
        }
        size = size - (to - from + 1);//更改size
    }

1. 检查from，to

2. 注意帮助GC，清空内存

3. 找到from的前驱节点指向to的后继节点即可

4. 删除注意更改size

lastindex该元素最后出现的位置：

/**
     * lastIndex
     *
     * @param x
     * @return
     */
    public int lastIndex(T x) {
        Node<T> p = head;
        int index = -1;
        int i = 0;
        while (p != null) {
            if (p.data.equals(x)) {
                index = i;
            }
            i++;
            p = p.next;
        }
        return index;
    }

额.........找到返回即可

add直接添加，保证顺序正确

/**
     * add
     *
     * @param x
     */
    public void add(T x) {
        Comparable<? super T> tmp = (Comparable<? super T>) x;
        if (size == 0) {//空表情况，及插入位置0
            head = new Node<>(x, head);
        } else {//非空表情况
            Node<T> p = head;
            Node<T> temp = head;
            int i;
            for (i = 0; i < size; i++) {
                if (tmp.compareTo((T) p.data) < 0)
                    break;
                p = p.next;
            }
            if (i==0){//第一个位置的情况
                head=new Node<>(x,head);
            }else {//普通情况
                p=head;
                for (int j = 0; j < i-1; j++) {
                    p=p.next;
                }
                p.next=new Node<>(x, p.next);
            }
        }

        ++size;//调整size
    }

1. 空表直接加入

2. compare找到位置

3. 找到前驱节点，使前驱节点指向该新建节点，该新建节点指向原前驱节点的next

4. 注意插入的位置

明天谭
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java模拟实现无头节点的单链表
qq_45875349的博客
09-17 267
【代码】Java模拟实现无头节点的单链表。
数据结构之实现单链表(Java实现)
weixin_47851265的博客
12-22 3168
数据结构之单链表的实现
不带头节点的单链表删除 java_不带头结点的单链表递归删除元素为X的结点
weixin_42545664的博客
02-28 339
#include using namespace std;struct Node{Node *next;int elem;};void creatList(Node* &head){head = new Node;int elem;cin>>elem;head->elem = elem;Node *p = head;while(cin>>elem&&a...
不带头节点的单链表删除 java_在不带头结点的单链表中删除特定元素
weixin_36031812的博客
02-28 886
在不带头结点的单链表中删除特定元素，一种很麻烦的情况是首结点即要删的结点，所以往往标识一个链表的 head 就会改变，而在删除函数中要改变客户端的 head，就必须传入 head 的地址，否则客户端的 head 永远不会改变，也就是说，若形参为 Node * 类型，修改的只是 head 的副本，这是C语言中的基础问题。这篇博客是我读了皓哥的这篇文章《Linus：利用二级指针删除单向链表》有感而写的...
单链表删除指定数值的节点(虚拟头节点/无虚拟头节点两种实现 ) 完整代码
weixin_47988506的博客
09-06 1215
单链表、删除节点
单链表的创建+添加+删除和逆置.zip
09-28
在这个“单链表的创建+添加+删除和逆置”的主题中，我们将深入探讨如何在C语言中实现这些操作。 首先，让我们讨论单链表的创建。在C语言中，我们通常定义一个结构体来表示链表的节点，该结构体包含数据部分和指向下...
java实现单链表之逆序
09-03
单链表逆序是指将链表中的元素顺序颠倒，使得原本的第一个元素变为最后一个，原本的最后一个元素变为第一个。这个过程可以通过迭代或递归的方式来实现。本文将详细介绍如何使用Java实现单链表的逆序。 首先，我们...
基于Java实现的单链表基本操作之链表反转.zip
最新发布
04-26
在这个基于Java实现的单链表基本操作中，我们将重点关注链表反转这一特定操作。 链表反转是编程面试中常见的问题，它要求我们改变链表中节点的顺序，使得原链表的最后一个节点成为新链表的第一个节点，原链表的第一...
字符串逆序-使用C语言+递归实现字符串逆序.zip
03-21
4. 将原始字符串的第一个字符与逆序的剩余部分拼接起来，这可以通过在逆序部分的末尾添加第一个字符实现。 以下是一个简单的C语言代码示例： ```c #include #include void reverse(char* str, int len) { if ...
java单链表逆序用法代码示例
08-28
【Java 单链表逆序】 在计算机科学中，链表是一种常见的数据结构，而单链表是其中最基础的形式。单链表由一系列节点组成，每个节点包含数据和指向下一个节点的引用（通常称为`next`）。逆序一个单链表意味着将链表中...
用Java编写不带头结点的链表
10-17
用Java编写不带头结点的链表，是清华大学出版社，作者朱战立编写
java语言实现单链表---不含头结点
初心不忘、始终方得
04-19 2160
该篇文章总结使用java语言实现不含头结点的单链表的实现。
逆置无头结点的单链表
lxy99的博客
04-13 5016
对于不带头结点的单链表L，设计一个递归算法逆置所有结点。编写完整的实验程序，并采用相应数据进行测试。 采用递归方法 思路：设f(L)返回单链表逆置后的首结点指针，为“大问题”，则f(L->next)返回逆置后的首结点指针p,为“小问题”，当小问题解决后，大问题的求解只需要将首结点（L指向它）链接到L->next节点的末尾就可以了。 #include<iostream> using namespace std; #define NULL 0 typedef struct node {
数据结构逆置单链表（递归）
m0_63142359的博客
10-24 3515
数据结构逆置单链表（递归）
数据结构之---单链表(不带头节点)（Java描述）
m0_52261881的博客
12-22 865
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、什么是单链表？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参
不带头节点的单链表及其基本操作（Java实现）
一念花开的博客
10-11 3284
package lwh.linearlist.linklist;public class Node { protected int e; protected Node next; public Node(){}; public Node(int e){ this.e = e; } public Node(int e, Node next){
java不带头节点的创建_JAVA单链表的实现-不带头结点但带有尾指针
weixin_33206646的博客
02-28 268
1，本程序实现了线性表的链式存储结构。实现的链表带有两个指针，一个始终指向链表中的第一个结点，另一个指针始终指向链表中的最后一个结点。之所以设置尾指针，是因为，在插入元素到链表中的末尾时，可以通过尾指针直接找到链表的最后一个元素，从而不需要遍历链表就可以完成插入操作。2，具体实现链表的类名为LList2.java，它首先实现了线性表的接口ListInterface，该接口的定义见：http://w...
（第5讲）单链表（带头结点和不带头结点）
weiyastory的博客
06-25 3564
最近在看数据结构，刚开始看链表的时候，很迷糊，什么头结点，头指针，首结点的傻傻分不清楚，现在明白啦： 1、只要是链表都有头指针，暂时用head表示；链表中的第一个结点称为首结点，最后一个结点称为尾结点 2、头结点的存在是为了方便操作，针对单链表来说，如果带头结点的话，头指针指向头结点，头结点指向首结点；如果不带头结点的话，头指针指向首结点，如果进行插入和删除操作，必须要注意是否是在链表头进行，
不带头结点单链表
DW___的博客
10-11 1070
Link.h typedef int ELEM_TYPE; typedef struct Node { ELEM_TYPE data; struct Node* next; }Node,*PNode; void Init(PNode* phead); PNode BuyNode(ELEM_TYPE val); bool InsertTail(PNode* phead,ELEM_TYPE...
要求实现一个函数，逆序输出不带头结点的单链表的的所有元素值。
04-10
好的，这是一个比较简单的问题，可以通过遍历链表并倒序输出来实现。代码如下： ```c++ void reversePrint(ListNode* head) { if (!head) return; reversePrint(head->next); cout << head->val ; } ``` 这个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值