java代码实现链表

最新推荐文章于 2023-09-23 20:18:55 发布
最新推荐文章于 2023-09-23 20:18:55 发布
阅读量217 收藏
点赞数 2
文章标签： java 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61294100/article/details/131948562
版权

文章目录

前言

链表是一种常见的数据结构，用于存储和组织数据。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。

链表可以分为单向链表和双向链表两种类型。

在单向链表中，每个节点只包含一个指向下一个节点的指针。链表的第一个节点称为头节点，最后一个节点称为尾节点，尾节点的指针指向空值。

在双向链表中，每个节点包含指向前一个节点和后一个节点的指针。这使得在双向链表中可以从前向后或从后向前遍历。

链表相对于数组的优势在于插入和删除操作的效率较高。由于链表中的节点可以在内存中分散存储，所以可以在不移动其他节点的情况下插入或删除节点。这使得链表在需要频繁进行插入和删除操作的场景中更加高效。

然而，链表的缺点是访问任意节点的效率较低。由于链表中的节点不是连续存储的，所以无法像数组一样通过索引直接访问节点，而是需要从头节点开始遍历链表直到找到目标节点。

链表常见的操作包括插入、删除和遍历。插入操作可以在链表的任意位置插入一个新节点。删除操作可以删除链表中的一个节点。遍历操作可以按顺序访问链表中的所有节点。

链表还有一些特殊的变种，如循环链表和跳表。循环链表是一种特殊的链表，其中尾节点的指针指向头节点，形成一个闭环。跳表是一种高效的数据结构，用于在有序链表中快速查找和插入节点。

总的来说，链表是一种灵活且高效的数据结构，适用于需要频繁进行插入和删除操作的场景。

一、单链表

在这里插入图片描述

package exer.linked;

/**
 * 单链表
 */
public class GoodsNode {
    public int id;

    public String name;

    public double price;

    public GoodsNode next;

    public GoodsNode(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "GoodsNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}


package exer.linked;


/**
 * 单链表常见操作
 */
public class DLLinkedList {
    //初始化头结点
    private GoodsNode head=new GoodsNode(0,"",0.0);

    /**
     * 无序增加
     */
    public void add(GoodsNode goodsNode){
        //先将头结点赋值给临时节点
        GoodsNode temp=head;
        while (true){
            //如果临时节点的next域为null，说明可以添加节点了，可以跳出循环
            if (temp.next==null){
                break;
            }
            //遍历到下一个节点
            temp=temp.next;
        }
        //将要添加的节点赋给next域
        temp.next=goodsNode;
    }
    /**
     * 有序增加
     */
    public void addOrder(GoodsNode goodsNode){
        //将头结点赋值给临时节点
        GoodsNode temp=head;
        boolean flag=true;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.id>goodsNode.id){
                break;
            }
            if (temp.next.id==goodsNode.id){
                flag=false;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            goodsNode.next=temp.next;
            temp.next=goodsNode;
        }else{
            System.out.println("不能重复添加节点");
        }
    }

    /**
     * 删除元素
     */
    public void delete(int id){

        //将头结点的next域赋值给temp临时节点
        GoodsNode temp=head;
        boolean flag=false;
        while (true){
            //表明没有找到要删除的节点
            if (temp.next==null){
                break;
            }
            //表明找到了要删除的节点
            if (temp.next.id==id){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
          temp.next=temp.next.next;
        }else{
            System.out.println("没有找到要删除的节点");
        }

    }
    /**
     * 修改元素
     */
    public void update(GoodsNode goodsNode){
        if (head.next==null){
            System.out.println("这是一个空链表");
            return;
        }
        GoodsNode temp=head.next;
        while (true){
            if (temp==null){
                break;
            }
            if (temp.id==goodsNode.id){
                temp.name=goodsNode.name;
                temp.price=goodsNode.price;
                break;
            }
            temp=temp.next;
        }

    }

    /**
     * 获取所有元素
     */
    public void getAll(){
        GoodsNode temp=head;
        while (true){
            if (temp.next==null){
                break;
            }
            System.out.println(temp.next);
            temp=temp.next;
        }

    }
}


/**
测试
*/
package exer.linked;

public class DLLinkedListTest {
    public static void main(String[] args) {
        DLLinkedList dlLinkedList=new DLLinkedList();
        GoodsNode goodsNode1 = new GoodsNode(1, "耐克帽子", 100);
        GoodsNode goodsNode2 = new GoodsNode(2, "耐克上衣", 200);
        GoodsNode goodsNode3 = new GoodsNode(3, "耐克鞋子", 300);
        GoodsNode goodsNode4 = new GoodsNode(4, "耐克裤子", 400);


        GoodsNode goodsNode5 = new GoodsNode(4, "耐克帽子", 100);
        GoodsNode goodsNode6 = new GoodsNode(8, "耐克上衣", 200);
        GoodsNode goodsNode7 = new GoodsNode(1, "耐克鞋子", 300);
        GoodsNode goodsNode8 = new GoodsNode(3, "耐克裤子", 400);
//        dlLinkedList.add(goodsNode1);
//        dlLinkedList.add(goodsNode2);
//        dlLinkedList.add(goodsNode3);
//        dlLinkedList.add(goodsNode4);

        dlLinkedList.addOrder(goodsNode5);
        dlLinkedList.addOrder(goodsNode6);
        dlLinkedList.addOrder(goodsNode7);
        dlLinkedList.addOrder(goodsNode8);
        //dlLinkedList.delete(18);
        dlLinkedList.update(new GoodsNode(4,"耐克太阳帽",8888));
        dlLinkedList.getAll();
    }
}

二、双链表

在这里插入图片描述

package exer.linked;

/**
 * 双链表
 */
public class BookNode {
    public int id;

    public String name;

    public double price;

    public BookNode pre;

    public BookNode next;

    public BookNode(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "BookNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}


package exer.linked;

import javax.xml.stream.FactoryConfigurationError;
import java.sql.SQLOutput;

/**
 * 双链表常见操作
 */
public class DualLinkedList {
    //初始化一个头结点不存放数据
    private BookNode head=new BookNode(0,"",0.0);

    /**
     * 无序添加
     */
    public void add(BookNode bookNode){
        BookNode temp=head;
        while (true){
            if (temp.next==null){
                break;
            }
            temp=temp.next;
        }
        temp.next=bookNode;
        //bookNode.pre=temp;
        temp.next.pre=temp;
    }

    /**
     * 有序添加
     */
    public void addOrder(BookNode bookNode){
        BookNode temp=head;
        int flag=0;
        while (true){
            if (temp.next==null){
                flag=1;
                break;
            }
            if (temp.next.id==bookNode.id){
                flag=0;
                break;
            }
            if (temp.next.id> bookNode.id){
                flag=2;
                break;
            }
            temp=temp.next;
        }
        if (flag==2){
            bookNode.next=temp.next;
            temp.next=bookNode;

                temp.next.pre = bookNode;

            bookNode.pre=temp;
        }else if (flag==0){
            System.out.println("不能重复添加节点");
        }else{
            temp.next=bookNode;
            bookNode.pre=temp;
        }
    }

    /**
     * 修改
     */
    public void update(BookNode bookNode){
        if (head.next==null){
            System.out.println("这是一个空链表");
            return;
        }
        BookNode temp=head.next;
        boolean flag=false;
        while (true){
            if (temp==null){
                break;
            }
            if (temp.id== bookNode.id){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.name=bookNode.name;
            temp.price=bookNode.price;
        }else{
            System.out.println("没有找到节点");
        }
    }

    /**
     * 删除
     */
    public void delete(int id){
        BookNode temp=head;
        boolean flag=false;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.id==id){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            if (temp.next.next!=null){
            temp.next.next.pre=temp;
            }
            temp.next=temp.next.next;
        }else{
            System.out.println("没有找到节点");
        }
    }


    /**
     * 遍历
     */
    public void list(){
        BookNode temp=head;
        while (true){
            if (temp.next==null){
                break;
            }
            System.out.println(temp.next);
            temp=temp.next;
        }
    }


}


package exer.linked;

/**
 * 测试
 */
public class DualLinkedListTest {
    public static void main(String[] args) {
        DualLinkedList dualLinkedList=new DualLinkedList();
        BookNode bookNode1=new BookNode(8,"西游记",100);
        BookNode bookNode2=new BookNode(3,"三国演义",200);
        BookNode bookNode3=new BookNode(4,"水浒传",300);
        BookNode bookNode4=new BookNode(5,"红楼梦",400);
//        dualLinkedList.add(bookNode1);
//        dualLinkedList.add(bookNode2);
//        dualLinkedList.add(bookNode3);
//        dualLinkedList.add(bookNode4);
        dualLinkedList.addOrder(bookNode1);
        dualLinkedList.addOrder(bookNode2);
        dualLinkedList.addOrder(bookNode3);
        dualLinkedList.addOrder(bookNode4);
        //dualLinkedList.update(new BookNode(8,"计算机",8888.0));
        //dualLinkedList.delete(2);
        dualLinkedList.list();
    }
}

三、单向环形链表

在这里插入图片描述
由约瑟夫问题引入：
设编号为1,2…，n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

/**
 * 单向环形链表
 */
public class Boy {
    public  int id;
    public Boy next;

    public Boy(int id) {
        this.id = id;
    }

}


/**
 * 单项环形链表相关操作
 */
public class CircleSingleLinkedList {
    //创建头结点
    public Boy first=new Boy(-1);

    /**
     * 创建环形链表
     */
    public void create(int n){
        if (n<1){
            throw new RuntimeException("传入参数不正确");
        }
        //创建一个临时节点
        Boy temp=null;
        for (int i = 1; i <= n; i++) {
            Boy boy=new Boy(i);
            if (i==1){
                first=boy;
                first.next=first;
                temp=first;
            }else{
                temp.next=boy;
                boy.next=first;
                temp=boy;
            }

        }
    }
    /**
     * 遍历环形链表
     */
    public void show(){
        if (first==null||first.id==-1){
            System.out.println("当前环形链表为空");
            return;
        }
        Boy temp=first;
        while (true){
            System.out.println(temp.id);

            if (temp.next==first){
                break;
            }
            temp=temp.next;

        }
    }
    /**
     * 约瑟夫问题
     * 根据用户输入计算小孩出圈的顺序
     * startNo 为k（开始的位置）
     * countNum为数的数（m）
     * nums为总人数
     */
    public void getOrder(int startNo,int countNum,int nums){
        if (first==null||startNo<1||startNo>nums){
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        //创建一个辅助指针，指向最后的节点
        Boy tail=first;
        while (true){
            if (tail.next==first){
                break;
            }
            tail=tail.next;
        }
        //让头部指针和尾部指针根据startNo进行移动
        for (int i = 0; i < startNo-1; i++) {
            first=first.next;
            tail=tail.next;
        }

        while (true){
            if (tail==first){
                break;
            }
            //根据countNum进行移动，然后将节点出圈
            for (int i = 0; i < countNum-1; i++) {
                first=first.next;
                tail=tail.next;
            }
            System.out.printf("小号%d出圈\n",first.id);
            //这是需要将first指针指向出圈节点的下一个
            first=first.next;
            tail.next=first;
        }
        System.out.printf("最后一个为%d\n",first.id);
    }
}


/**
 * 单向环形链表测试
 */
public class CircleSingleLinkedListTest {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList=new CircleSingleLinkedList();
        circleSingleLinkedList.create(5);
        //circleSingleLinkedList.show();
        circleSingleLinkedList.getOrder(1,3,5);
    }
}
qq_61294100
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java单向链表代码实现
12-25
java单向链表代码实现
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4168
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
JAVA——链表
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
Java数据结构篇之链表
最新发布
MasterJundarj的博客
09-23 2483
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
【Java】链表LinkedList
qq_61635026的博客
07-06 8625
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
java实现链表
u011723409的博客
06-25 1万+
链表实现
Java实现单向链表反转
08-27
下面是Java实现单向链表反转的代码示例： ```java public class LinkedListTest { public static void main(String[] args) { Node A = new Node("A"); Node B = new Node("B"); Node C = new Node("C"); Node...
Java语言实现反转链表代码示例
08-29
Java语言实现反转链表代码示例 Java是一种广泛应用于软件开发的编程语言，而链表是编程中的一种重要数据结构。反转链表是链表操作中的一种基本操作，它可以应用于各种实际场景中。下面我们将详细介绍Java语言实现...
链表的原理及java实现代码示例
08-28
"链表的原理及Java实现代码示例" 链表是一种基本的数据结构，它的实现原理不同于数组。链表的优点是插入和删除操作效率高，而缺点是循环遍历时效率不高。Java中使用的LinkedList的实现原理就是链表。 单向链表的...
java双向循环链表的实现代码
09-05
介绍了java双向循环链表的实现代码，有需要的朋友可以参考一下
Java中链表的实现(超详细)
m0_74000148的博客
05-24 3165
在这个示例中，我们创建了一个。在Java中，链表可以通过。 在这个示例中，我们创建了一个 LinkedList 类，它包含一个 Node 类和一些方法来操作链表。我们可以使用 push() 方法在链表的头部插入节点，使用 insertAfter() 方法在链表中间插入节点，使用 append() 方法在链表尾部插入节点，使用 deleteNode() 方法删除链表中的给定节点，并使用 printList() 方法打印链表。
Java链表入门(超详细)
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
Java中的链表
weixin_52758364的博客
12-09 3320
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
JAVA基础-链表
lwxklts的博客
02-02 699
链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。链表在插入的时候速度较快，可以达到O(1)的复杂度，但是查找操作较慢，需要O(n)的时间，线性表和顺序表查找操作的时间复杂度分别是O(logn)和O(1)。链表的物理存储结构是非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接的次序实现的.利用尾节点last尾插法插入结点。先查找结点比对结点值再删除。在指定结点前添加结点。
Java实现链表
cainiaowangdake的博客
06-06 1254
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
数据结构之链表（Java实现）
Easenyang的博客
05-18 8122
数据结构中线性表的重要知识之一
Java算法进阶(一):链表
Justin_Andyson的博客
04-11 917
Java算法链表的深究
Java链表详解--通俗易懂(超详细,含源码)
热门推荐
噜噜噜噜鲁
12-05 3万+
概念 链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂
Java数据结构—链表（Linked List）
Rxq_Future的博客
04-16 445
数据结构—链表
用java代码实现链表
07-10
以下用Java代码实现链表的示例： ```java // 定义链表节点类 class Node { int data; Node next; public Node(int data) { this.data = data; this.next = null; } } // 定义链表类 class LinkedList { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值