java —— 链表

最新推荐文章于 2024-07-24 16:04:11 发布
最新推荐文章于 2024-07-24 16:04:11 发布
阅读量119 收藏
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sokoooo/article/details/113089417
版权

java —— 链表

一、单向链表

（一）链表代码部分

  1. 链表的实现部分
import java.util.Scanner;

public class ListDemo {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        List list = new List();
        for (int i = 0; i < n; i ++){
            Character per = new Character();
            String str = sc.next();
            String scr = sc.next();
            int num = sc.nextInt();
            per.setName(str);
            per.setAbility(scr);
            per.setAge(num);
            list.addCharacter(per); // 插入链表中
        }
        list.printList();
    }

}
  1. 链表部分
// 单向链表
/*
1. 找到当前链表的最后节点
2. 将最后节点的next 指向下一个节点
 */
class List {
    // 先初始化一个头节点，头节点一般不要移动
    private Character head = new Character(); // 一般不存放具体数据

    public void addCharacter(Character person) {
        Character temp = head;
        while (true) { // 遍历链表，找到链表的最后一个节点
            if (temp.next == null)
                break;
            else // 否则就把temp移向下一个节点
                temp = temp.next;
        }
        temp.next = person; // 退出循环则代表temp的next指向了最后一个节点，再将此指向新的节点
    }
    // 利用遍历显示链表
    public void printList() {
        Character temp = head.next;
        while (true) {
            if (temp == null)
                break;
            else {
                System.out.println(temp);
                temp = temp.next;
            }
        }
    }
}

// 定义Character，每一个Character对象就是一个节点
class Character {
    String name;
    String ability;
    int age;
    Character next; // 指向下一个结点

    // 构造方法
    public Character() {
    }

    public Character(String name, String ability, int age) {
        this.name = name;
        this.ability = ability;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAbility() {
        return ability;
    }

    public void setAbility(String ability) {
        this.ability = ability;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Character getNext() {
        return next;
    }

    public void setNext(Character next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Character{" +
                "name='" + name + '\'' +
                ", ability='" + ability + '\'' +
                ", age=" + age +
                '}';
    }
}

结果如下：
Character{name='太宰治', ability='人间失格', age=22}
Character{name='中原中也', ability='污浊了的忧伤之中', age=22}

（二）链表的插入、修改、删除

  1. 插入（运用插入可以使链表有序排列）
// 将其加入指定位置
    // temp 是位于添加位置的前一个节点
    public void insertList(Character person) { // 插入
        Character temp = head;
        boolean flag = false; // 判断链表中是否存在相同的标号
        while (true) {
            if (temp.next == null)
                break; // 说明temp已经在链表的最后了
            else if (temp.next.nume > person.nume) //位置已经找到，就在temp的后面将其插入
                break;
            else if (temp.next.nume < person.nume)
                temp = temp.next;
            else{
                flag = true; // 说明编号存在
                break;
            }
        }
        // 判断 flag 的值
        if (flag){
            System.out.println("此人物标号重复");
        }else{
            person.next = temp.next;
            temp.next = person;
        }
    }
  1. 修改
 public void resiveList(Character person) { // 修改
        if (head.next == null) // 判断链表是否为空
            System.out.println("null");
            Character temp = head.next;
            boolean flag = false; // 设置flag来进行后面的判断
            while (true){
                if (temp == null)
                    break; // 说明已经遍历完
                if (temp.nume  == person.nume){ // 这说明找到了需要修改的位置
                    flag = true; // 将flag赋予true
                    break;
                }else temp = temp.next;
            }
            if (flag) {  // 当flag为true进行修改操作
                temp.name = person.name;
                temp.age = person.age;
                temp.ability = person.ability;
            }else System.out.println("error");
    }
  1. 删除（单向链表不可以进行自我删除）
  public void deleteList(int nume) { // 删除：直接让要被删除部分的前一个节点指向被删除部分的下一个节点
        if (head.next == null) // 判断链表是否为空
            System.out.println("error");
        Character temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp.next == null)
                break;
            if (temp.next.nume == nume){ // 找到了需要删除的地方
                flag = true;
                break;
            }else temp = temp.next;
        }
        if (flag) {
            temp = temp.next.next;
        }else System.out.println("error");
    }
}

注： 可以通过 插入法对链表进行排序，将上述实现部分的for处改为如下：

for (int i = 0; i < n; i ++){
            Character per = new Character();
            String name = sc.next();
            String ability = sc.next();
            int age = sc.nextInt();
            int num = sc.nextInt();
            per.setName(name);
            per.setAbility(ability);
            per.setAge(age);
            per.setNume(num);
            list.insertList(per);
        }
        list.printList();

二、双向链表

（一）链表代码部分

  1. 链表部分：
// 创建一个双向链表的类
class Person {
    String name;
    int nume;
    Person next; // 指向下一个结点
    Person pre; // 指向上一个节点

    // 构造方法
    public Person() {
    }

    public Person(String name, int nume) {
        this.name = name;
        this.nume = nume;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNume() {
        return nume;
    }

    public void setNume(int nume) {
        this.nume = nume;
    }

    public Person getNext() {
        return next;
    }

    public void setNext(Person next) {
        this.next = next;
    }

    public Person getPre() {
        return pre;
    }

    public void setPre(Person pre) {
        this.pre = pre;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", nume=" + nume +
                '}';
    }
}

// 双向链表
class DoubleList {
    private Person head = new Person(); //

    public void printDoubleList() { 
        Person temp = head.next;
        while (true) {
            if (temp == null)
                break;
            else {
                System.out.println(temp);
                temp = temp.next;
            }
        }
    }
    

    // 增加只需要加入一个上一个节点即可
    public void addPerson(Person person) {
        Person temp = head;
        while (true) { // 遍历链表，找到链表的最后一个节点
            if (temp.next == null)
                break;
            else // 否则就把temp移向下一个节点
                temp = temp.next;
        }
        // 形成双向链表
        person.pre = temp;
        temp.next = person; // 退出循环则代表temp的next指向了最后一个节点，再将此指向新的节点
    }

（二）插入、修改、删除

  1. 插入
双向链表和单向链表一致
  1. 修改
// 双向链表的修改和单项链表一致
    public void resiveDoubleList(Person person) {
        if (head.next == null) // 判断链表是否为空
            System.out.println("null");
        Person temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null)
                break; // 说明已经遍历完
            if (temp.nume == person.nume) {
                flag = true;
                break;
            } else temp = temp.next;
        }
        if (flag) {
            temp.name = person.name;
        } else System.out.println("error");
    }

三、链表（提供者：Jplusztc）

class Node{
    int data;
    Node next;

    public Node() {}

    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }
}

//带头结点的链表
public class LinkedList {
    private Node head;
    private int size;

    public LinkedList() {
        this(false);
    }
    public LinkedList(boolean ascend, int...arr){
        head = new Node();
        size = 0;
        addBySort(ascend, arr);
    }
    public int size(){
        return this.size;
    }
    public boolean isEmpty(){return this.size == 0;}

    //需要学会的方法，将添加进链表的数据均按顺序排列
    //ascend为true代表是升序，否则为降序
    //注意这里是private， 我只对创建链表时传入的数据进行排序
    private void addBySort(boolean ascend, int...arr){
        for (int i = 0; i < arr.length; i++) {
            int num = arr[i];
            Node temp = head;
            while (temp != null){
                if (temp.next == null){
                    temp.next = new Node(num, null);
                    break;
                }
                if (ascend){
                    if (temp.next.data > num) {
                        temp.next = new Node(num, temp.next);
                        break;
                    }
                }else {
                    if (temp.next.data < num) {
                        temp.next = new Node(num, temp.next);
                        break;
                    }
                }
                temp = temp.next;
            }
            size++;
        }
    }

    //添加到末尾
    public void add(int data){
        add(data, size);
    }
    //添加到链表指定下标处
    public void add(int data, int index){
        if (index < 0 || index > size){
            throw new IndexOutOfBoundsException("下标越界");
        }
        Node temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.next = new Node(data, temp.next);
        size++;
    }

    //删除指定下标处的数据, 下标范围[0, size)
    public void delete(int index){
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("下标越界");
        Node temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
        size--;
    }

    //删除遇到的data, deleteAll为True时，删除所有的data，否则只删除第一个
    public void deleteData(int data, boolean deleteAll){
        Node temp = head;
        while (temp.next != null){
            if (temp.next.data == data){
                temp.next = temp.next.next;
                size--;
                if (!deleteAll) break;
            }
            temp = temp.next;
        }
    }

    @Override  // 方法重写
    public String toString() {
        Node temp = head.next;
        StringBuilder s = new StringBuilder();
        while (temp != null){
            s.append(temp.data);
            temp = temp.next;
            if (temp != null) s.append(", ");
        }
        return "LinkedList{"+s.toString()+"}";
    }
}
  1. 删除（双向链表可以进行自我删除）
class Node{
    int data;
    Node next;

    public Node() {}

    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }
}

//带头结点的链表
public class LinkedList {
    private Node head;
    private int size;

    public LinkedList() {
        this(false);
    }
    public LinkedList(boolean ascend, int...arr){
        head = new Node();
        size = 0;
        addBySort(ascend, arr);
    }
    public int size(){
        return this.size;
    }
    public boolean isEmpty(){return this.size == 0;}

    //需要学会的方法，将添加进链表的数据均按顺序排列
    //ascend为true代表是升序，否则为降序
    //注意这里是private， 我只对创建链表时传入的数据进行排序
    private void addBySort(boolean ascend, int...arr){
        for (int i = 0; i < arr.length; i++) {
            int num = arr[i];
            Node temp = head;
            while (temp != null){
                if (temp.next == null){
                    temp.next = new Node(num, null);
                    break;
                }
                if (ascend){
                    if (temp.next.data > num) {
                        temp.next = new Node(num, temp.next);
                        break;
                    }
                }else {
                    if (temp.next.data < num) {
                        temp.next = new Node(num, temp.next);
                        break;
                    }
                }
                temp = temp.next;
            }
            size++;
        }
    }

    //添加到末尾
    public void add(int data){
        add(data, size);
    }
    //添加到链表指定下标处
    public void add(int data, int index){
        if (index < 0 || index > size){
            throw new IndexOutOfBoundsException("下标越界");
        }
        Node temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.next = new Node(data, temp.next);
        size++;
    }

    //删除指定下标处的数据, 下标范围[0, size)
    public void delete(int index){
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("下标越界");
        Node temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
        size--;
    }

    //删除遇到的data, deleteAll为True时，删除所有的data，否则只删除第一个
    public void deleteData(int data, boolean deleteAll){
        Node temp = head;
        while (temp.next != null){
            if (temp.next.data == data){
                temp.next = temp.next.next;
                size--;
                if (!deleteAll) break;
            }
            temp = temp.next;
        }
    }

    @Override  // 方法重写
    public String toString() {
        Node temp = head.next;
        StringBuilder s = new StringBuilder();
        while (temp != null){
            s.append(temp.data);
            temp = temp.next;
            if (temp != null) s.append(", ");
        }
        return "LinkedList{"+s.toString()+"}";
    }
}

END

逃逃日塔灰
关注
专栏目录
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5267
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
算法（Java）——链表
小朱小朱绝不认输的博客
03-15 994
链表是除数组外，另一个常用的数据结构，算法中经常会对链表进行处理，主要是指针的用法。 链表 链表结构： public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } }
链表
qq_41965731的博客
10-04 484
根据尚硅谷的韩顺平老师的数据结构视频总结的笔记 观看视频的网址 一、链表的介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 1、单链表介绍 单链表（带头节点）逻辑结构如下图： 2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 ..
Java数据结构——链表（LinkedList）
最新发布
2201_75685905的博客
07-24 716
在Java中，链表是一种基本的数据结构，用于按照线性方式存储数据集合。与数组不同，链表中的元素在内存中不是连续存储的，而是通过指针（或引用）连接在一起。动态大小：链表的大小可以根据需要动态增长或缩小，不需要像数组那样预先定义固定的大小。元素访问：链表不提供像数组一样的随机访问能力。访问链表中的元素通常需要从头开始遍历。插入和删除操作：在链表中插入或删除元素通常比数组更快，特别是对于不是在链表末尾的操作，因为不需要移动其他元素来腾出空间或填补空位。内存使用。
【数据结构】链表
热门推荐
knous
03-13 6万+
链表
数据结构--链表
weixin_30381317的博客
09-09 77
数据结构--链表 链表的种类 单链表 循环链表 双链表 链表的操作 单链表的节点删除 单链表的节点插入 双链表节点的删除 双链表的节点插入 链表的比较 转载于:https://www.cnblogs.com/szm2019/p/7535615.html...
java 链表成环_探究HashMap线性不安全（二）——链表成环的详细过程
weixin_36150766的博客
02-28 213
内容​　　网上很多资料都详细地讲解了HashMap底层的实现，但是讲到HashMap的并发操作不是线性安全时，往往一笔带过：在多个线程并发扩容时，会在执行transfer()方法转移键值对时，造成链表成环，导致程序在执行get操作时形成死循环。​　　对于没有研究过该过程的童鞋，很难费解这句话的含义。下面笔者分四个小节带着大家共同研究一下JDK1.7和JDK1.8版本下HashMap的线性不安全是怎...
《Java数据结构和算法》学习笔记(4)——链表
03-14
在Java中，我们可以自定义类来实现链表，或者使用内置的`java.util.LinkedList`类。本文将以单链表为例，讲解其核心概念和操作。 1. 单链表的创建与插入： 创建链表需要先创建一个头节点，然后通过插入操作逐步...
JAVA链表基础——代码随想录 链表
weixin_44023809的博客
11-28 358
本文档创作于代码随想录算法训练营四期。
图解链表 —— JAVA 中的双向链表
AlinaQ05的博客
05-22 5044
1. 双向链表 前面提到了单向链表，单链表的特点是只能从前向后遍历，但是如果我们已知一个节点在链表靠后的位置，这时如果使用单链表效率就会很低，因此引入了双向链表就可以快速的找到靠后的节点。双向链表与单向链表的区别就是它不仅有后继节点，还有前驱节点。这样就既存储了下一个节点的地址，也存储了前一个节点的地址。 2. 双向链表的定义 节点类： class DoubleNode { // 指向前驱节点 DoubleNode prev; // 具体存储的数据
链表数据结构
Yuqbd的博客
04-26 830
链表数据结构1 历史2 结构2.1 单向链表2.2 双向链表2.3 循环链表3链表的应用 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间...
数据结构（链表）
weixin_48206333的博客
01-22 628
一：什么是链表？ 1.链表是以节点的方式来储存 2.每个节点包含data域，next域：指向下一个节点。 3.链表的各个节点不一定是连续存储。 4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。 二：单链表的应用实例 使用带head头的单向链表实现-水浒传英雄排列榜管理 1.完成对英雄人物的增删改查操作 2.第一种方法在添加英雄时，直接添加到链表的尾部 3.第二种方式在添加英雄时，根据排名将英雄插入到指定位置 ...
数据结构 -- 链表详解
hu_143的博客
04-27 2568
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构之链表结构
CS_knight的博客
08-27 644
数组1.链表结构1.1单链表结构和双链表结构1.2非连续性内存和节点1.3单链接节点类1.3单链表结构上的操作1.3.1遍历(traversal)1.3.2 搜索1.3.3替换 1.链表结构 1.1单链表结构和双链表结构 链表结构(linked structure) 单链表结构(singly linked structure) 头链接(head link) 空链接(empty link) ...
数据结构 | 链表
庭前云落的博客
06-25 414
学习目标 了解单链表和...
数据结构：链表(linked-list)
蜗牛君的奋斗史
05-09 5万+
链表分为单向链表(Singly linked lis)、双向链表(Doubly linked list)、循环链表(Circular Linked list)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值