java —— 链表

最新推荐文章于 2024-10-09 12:07:53 发布
最新推荐文章于 2024-10-09 12:07:53 发布
阅读量135 收藏
点赞数 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 5367
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
算法（Java）——链表
小朱小朱绝不认输的博客
03-15 1059
链表是除数组外，另一个常用的数据结构，算法中经常会对链表进行处理，主要是指针的用法。 链表 链表结构： public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } }
链表
qq_41965731的博客
10-04 509
根据尚硅谷的韩顺平老师的数据结构视频总结的笔记 观看视频的网址 一、链表的介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 1、单链表介绍 单链表（带头节点）逻辑结构如下图： 2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 ..
Java数据结构——链表（完整详解 单向链表【带哨兵】，双向链表【带哨兵】，附有案例+代码）
最新发布
Java技术加油站的博客
10-09 587
链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上并不连续。可以分为：单向链表，每个元素只知道其下一个元素是谁双向链表，每个元素知道其上一个元素和下一个元素循环链表，通常的链表尾节点 tail 指向的都是 null，而循环链表的 tail 指向的是头节点 head链表内还有一种特殊的节点称为哨兵（Sentinel）节点，也叫做哑元（ Dummy）节点，它不存储数据，通常用作头尾，用来简化边界判断，如下图所示随机访问性能根据 index 查找，时间复杂度 O(n)插入或删除性能。
【数据结构】链表
热门推荐
knous
03-13 6万+
链表
数据结构--链表
weixin_30381317的博客
09-09 96
数据结构--链表 链表的种类 单链表 循环链表 双链表 链表的操作 单链表的节点删除 单链表的节点插入 双链表节点的删除 双链表的节点插入 链表的比较 转载于:https://www.cnblogs.com/szm2019/p/7535615.html...
数据结构-链表
weixin_74312694的博客
08-30 1077
当我们实现了带头双向循环链表的插入和删除数据我们发现，与单链表相比，当前链表无论是在头或者在尾效率都很高，时间复杂度相同为O(N)。这个链表实现也更为简单，所以听起来复杂的链表实现起来并不复杂。
java 链表成环_探究HashMap线性不安全（二）——链表成环的详细过程
weixin_36150766的博客
02-28 254
内容​　　网上很多资料都详细地讲解了HashMap底层的实现，但是讲到HashMap的并发操作不是线性安全时，往往一笔带过：在多个线程并发扩容时，会在执行transfer()方法转移键值对时，造成链表成环，导致程序在执行get操作时形成死循环。​　　对于没有研究过该过程的童鞋，很难费解这句话的含义。下面笔者分四个小节带着大家共同研究一下JDK1.7和JDK1.8版本下HashMap的线性不安全是怎...
《Java数据结构和算法》学习笔记(4)——链表
03-14
在Java中，我们可以自定义类来实现链表，或者使用内置的`java.util.LinkedList`类。本文将以单链表为例，讲解其核心概念和操作。 1. 单链表的创建与插入： 创建链表需要先创建一个头节点，然后通过插入操作逐步...
JAVA——链表
qq_69133469的博客
04-23 3万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
JAVA链表基础——代码随想录 链表
weixin_44023809的博客
11-28 414
本文档创作于代码随想录算法训练营四期。
链表数据结构
Yuqbd的博客
04-26 858
链表数据结构1 历史2 结构2.1 单向链表2.2 双向链表2.3 循环链表3链表的应用 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间...
数据结构（链表）
weixin_48206333的博客
01-22 695
一：什么是链表？ 1.链表是以节点的方式来储存 2.每个节点包含data域，next域：指向下一个节点。 3.链表的各个节点不一定是连续存储。 4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。 二：单链表的应用实例 使用带head头的单向链表实现-水浒传英雄排列榜管理 1.完成对英雄人物的增删改查操作 2.第一种方法在添加英雄时，直接添加到链表的尾部 3.第二种方式在添加英雄时，根据排名将英雄插入到指定位置 ...
数据结构 -- 链表详解
hu_143的博客
04-27 3034
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
java——链表
2301_77713282的博客
01-23 421
链表的实现, 链表的增删改查及一些扩展方法, 链表有虚拟头结点和没有虚拟头结点的区别
图解链表 —— JAVA 中的双向链表
AlinaQ05的博客
05-22 5141
1. 双向链表 前面提到了单向链表，单链表的特点是只能从前向后遍历，但是如果我们已知一个节点在链表靠后的位置，这时如果使用单链表效率就会很低，因此引入了双向链表就可以快速的找到靠后的节点。双向链表与单向链表的区别就是它不仅有后继节点，还有前驱节点。这样就既存储了下一个节点的地址，也存储了前一个节点的地址。 2. 双向链表的定义 节点类： class DoubleNode { // 指向前驱节点 DoubleNode prev; // 具体存储的数据
数据结构之链表结构
CS_knight的博客
08-27 663
数组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) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值