【数据结构】Java实现链表

于 2024-08-16 16:11:39 发布
阅读量791 收藏 17
点赞数 19
分类专栏： 数据结构 文章标签： 数据结构 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaochuan_bsj/article/details/141258625
版权

目录

链表的概念

链表的实现

链表的功能

框架搭建

功能实现

打印链表

获取数据数量

查询数据

插入数据

头插法

尾插法

指定位置插入

删除数据

删除一个数据

 删除多个相同数据

删除链表

完整代码

链表的概念

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。

这次要实现的是单向，不带头，非循环的链表，形式如下图所示，就像是一个火车头拉着一节节火车。

 

 单向和不循环相对来说好理解一些，关于这个不带头可能有点难理解，下面这张图是带头，两图对比着看好理解一些

链表的实现

链表的功能

 链表的功能包括插入数据、删除数据、查找数据以及销毁链表等功能，其中的部分功能还有细分。

框架搭建

首先我们可以创建一个MySingleList类，在其中定义链表的基本内容，这要运用到了静态代码块方面的知识。

MySingleList类

public class MySingleList implements IList{

    static class ListNode{
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
}

之所以定义 head，是要把它作为链表的第一个结点，链表中每一个如下的部分都可称为一个结点。

创建一个IList接口类，再通过MySingleList类来重写接口的方法。

IList接口

public interface IList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    public void clear();
    public void display();
    public void createList();
}

此时的MySingleList类为

public class MySingleList implements IList{

    static class ListNode{
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;


    @Override
    public void addFirst(int data) {
        
    }

    @Override
    public void addLast(int data) {

    }

    @Override
    public void addIndex(int index, int data) {

    }

    @Override
    public boolean contains(int key) {
        return false;
    }

    @Override
    public void remove(int key) {

    }

    @Override
    public void removeAllKey(int key) {

    }

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

    @Override
    public void clear() {

    }

    @Override
    public void display() {

    }

    @Override
    public void createList() {

    }

}

功能实现

打印链表

display方法

在打印链表之前，需要有链表才能打印，所以我们要先创建一个链表，写一个createList方法来实现

createList方法

    public void createList(){
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);
        ListNode node5 = new ListNode(56);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        this.head = node1;
    }

因为要去打印链表，也就是说要把链表遍历一遍，然后打印其中的数据，而想要链表的数据一个接一个往下走，可以通过 head = head.next 来实现。循环条件是 cur != null，因为最后一个结点的next为null。

不过为了防止循环走完后，head的指向发生变化，我们可以写一个cur来解决的这个问题

    public void display() {
        ListNode cur = head;
        //可以防止循环走完后，head的指向发生变化
        while(cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
    }

获取数据数量

size方法

这里其实只要把链表遍历一遍，定义一个整型，每经过一个数据+1即可。

    public int size() {
        ListNode cur = head;
        int len = 0;
        while(cur != null){
            len++;
            cur = cur.next;
        }
        return len;
    }

查询数据

contain方法

通过遍历链表，查询其中的val值是否和key值相等即可。

    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;

    }

插入数据

头插法

addFirst方法

一开始设置了 head 作为第一个结点，所以在头部插入数据就可以先用插入数据连接结点，然后再把它设为第一个结点。

头插法不用把空链表作为特殊情况，因为无论链表是否为空，它都是在链表头部进行插入。

    public void addFirst(int data) {
        ListNode node = new ListNode(data);

        //先连接结点
        node.next = head;
        //再把node设为第一个结点
        head = node;
    }
尾插法

addList方法

我们要做的是把最后一个结点中的 null 改为 插入数据的地址，不过在这之前还得要找到最后一个结点，所以步骤可以分为下面这两步

  1. 找到最后一个结点
  2. 修改其中的next

对于尾插法，我们需要考虑链表是否为空，不为空按照上面思路走。若为空，就意味着这时的尾插其实也是头插，可以通过上面写的代码进行完善。

    public void addLast(int data) {
        //1.特殊情况，链表为空
        ListNode node = new ListNode(data);
        if(head == null){
            head = node;
            return;
        }
        //2.链表不为空
        ListNode cur = head;
        while(cur.next != null){
            cur= cur.next;
        }
        cur.next = node;
    }
指定位置插入

addIndex方法

这时候我们要想到插入的位置（index）是否合理

index位置不合理的情况有两种：

  1. index < 0
  2. index > size();

链表的排序和数组是一样的，都是从0开始计数，所以index=size()也是合理的，形式和尾插是一样的。这里同时可以想到当 index=0 和 index=size()时，使用头插法和尾插法进行。

最后剩的情况是插入到中间，我们可以通过index--的方式来确定到 插入元素位置的前一个位置，然后通过绑定 插入位置现在

    public void addIndex(int index, int data) {
        //多次调用size()方法是挺消耗资源的
        int len = size();
        if(index < 0 || index > len){
            //自己尝试写一个异常
            System.out.println("index位置不合法");
            return;
        }

        if(index == 0){
            addFirst(data);
            return;
        }

        if(index == len){
            addLast(data);
            return;
        }

        //中间插入
        ListNode cur = head;

        while(index - 1 != 0){
            cur = cur.next;
            index--;
        }
        ListNode node = new ListNode(data);
        node.next = cur.next;
        cur.next = node;
        return;
    }

删除数据

删除一个数据

这里我们先考虑链表中存在要删除的数据，首先我们要找到要删除的数据，这里我们可以单独写一个findNodeOfKey方法

    private ListNode findNodeOfKey(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

 这里我们找到的依旧是要删除的数据的 前一个结点

 

    public void remove(int key) {
        if(head == null){
            return;
        }
        //特殊情况：删除头节点的文件
        if(head.val == key){
            head = head.next;
            return;
        }

        ListNode cur = findNodeOfKey(key);
        if(cur == null){
            return;
        }
        ListNode del = cur.next;
        cur.next = del.next;
    }

    private ListNode findNodeOfKey(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
 删除多个相同数据

removeAllKey方法

这里分别定义了 prev = head， cur = head.next。

大致的删除步骤时通过prev和cur来进行结点的跳过

    public void removeAllKey(int key) {
        ListNode prev = head;
        ListNode cur = head.next;
        if(head == null){
            return;
        }
        while(cur != null){
            if(cur.val == key){
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key){
            head = head.next;
        }
    }

为了防止第一个结点的数据也需要被删除，在方法最后写了一个if语句，并且它只能放在最后，放在前面就不能达到删除数据的目的，这点大家可以自己试一试。

删除链表

clear方法

思路也是可以想到的，把链表中每一个结点都设为null，完成数据的回收。

    public void clear() {
        ListNode cur = head;
        while(cur != null){
            ListNode curN = cur.next;
            cur.next = null;
            cur = curN;
        }
        head = null;
    }

更粗暴的方式时直接令 head == null，这两种方法看如何取舍来使用。

完整代码

MySingleList类

public class MySingleList implements IList{

    static class ListNode{
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;


    @Override
    public void addFirst(int data) {
        ListNode node = new ListNode(data);

        //先连接结点
        node.next = head;
        //再把node设为第一个结点
        head = node;
    }

    @Override
    public void addLast(int data) {
        //1.特殊情况，链表为空
        ListNode node = new ListNode(data);
        if(head == null){
            head = node;
            return;
        }
        //2.链表不为空
        ListNode cur = head;
        while(cur.next != null){
            cur= cur.next;
        }
        cur.next = node;
    }

    @Override
    public void addIndex(int index, int data) {
        //多次调用size()方法是挺消耗资源的
        int len = size();
        if(index < 0 || index > len){
            //自己尝试写一个异常
            System.out.println("index位置不合法");
            return;
        }

        if(index == 0){
            addFirst(data);
            return;
        }

        if(index == len){
            addLast(data);
            return;
        }

        //中间插入
        ListNode cur = head;

        while(index - 1 != 0){
            cur = cur.next;
            index--;
        }
        ListNode node = new ListNode(data);
        node.next = cur.next;
        cur.next = node;
        return;
    }

    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;

    }

    @Override
    public void remove(int key) {
        if(head == null){
            return;
        }
        //特殊情况：删除头节点的文件
        if(head.val == key){
            head = head.next;
            return;
        }

        ListNode cur = findNodeOfKey(key);
        if(cur == null){
            return;
        }
        ListNode del = cur.next;
        cur.next = del.next;
    }

    private ListNode findNodeOfKey(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    @Override
    public void removeAllKey(int key) {
        if (head == null) {
            return;
        }
        ListNode prev = head;
        ListNode cur = head.next;
        while (cur != null) {
            if (cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else{
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key){
            head = head.next;
        }
    }
    @Override
    public int size() {
        ListNode cur = head;
        int len = 0;
        while(cur != null){
            len++;
            cur = cur.next;
        }
        return len;
    }

    @Override
    public void clear() {
        ListNode cur = head;
        while(cur != null){
            ListNode curN = cur.next;
            cur.next = null;
            cur = curN;
        }
        head = null;
    }

    public void createList(){
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);
        ListNode node5 = new ListNode(56);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        this.head = node1;
    }


    @Override
    public void display() {
        ListNode cur = head;
        //可以防止循环走完后，head的指向发生变化
        while(cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }


}

IList接口类

public interface IList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    public void clear();
    public void display();
    public void createList();
}

Test类

我自己写的时候的测试类也一并发给大家，方便大家进行测试。

public class Test {
    public static void main(String[] args) {
        IList list = new MySingleList();
        list.createList();
        //list.display();
        //System.out.print(list.size());
        //System.out.println();
        //System.out.println(list.contains(4));
        //list.addIndex(2,99);
        //list.remove(12);
        list.clear();
        list.display();
    }
}

小川_wenxun
关注
  • 19
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值