链表详解（Java实现）

其他 2020-05-18 14:54:00 阅读次数: 0

二、链表

2.1 单链表

2.1.1 概述

功能：遍历打印、添加到最后、按ID大小添加、根据ID进行修改、根据ID删除节点

2.1.2 代码及详细注释

package linkedlist;

import linkedlist.pojo.User;

/**
 * @author: doudou
 * @date: Created in 2020/3/31
 * @description:
 * @version: 1.0
 */
public class UndirectionalLinkedList {
    // 头指针一开始就要初始化
    private Node head = new Node();

    /**
     * push方法，将元素放到链表的末尾
     * @param user
     */
    public void push(User user){
        Node node = new Node(user);
        Node tmp = head;
        while(true){
            if(tmp.next == null){
                break;
            }
            // 注意指针后移，防止死循环
            tmp = tmp.next;
        }
        tmp.next = node;
    }

    /**
     * 展示链表
     */
    public void show(){
        Node tmp = head.next;
        if (tmp == null) {
            System.out.println("链表为空！");
        }
        while(true){
            if(tmp == null){
                return;
            }
            System.out.println(tmp);
            tmp = tmp.next;
        }
    }

    /**
     * 按照id，升序插入到特定位置
     * 如果有重复的元素，则插入失败
     * @param user
     * @return
     */
    public boolean insert(User user) {
        Node node = new Node(user);
        Node tmp = head;
        boolean flag = false; // 默认插入失败
        while(true){
            if(tmp.next == null){
                flag = true;
                break;
            }
            if(node.user.getId() < tmp.next.user.getId()) {
                flag = true;
                break;
            }
            if(node.user.getId() == tmp.next.user.getId()) {
                break;
            }
            tmp = tmp.next;
        }
        if(flag) {
            node.next = tmp.next;
            tmp.next = node;
        }
        return flag;
    }

    /**
     * 根据user的id更新元素
     * @param user
     * @return
     */
    public boolean update(User user) {
        Node node = new Node(user);
        Node tmp = head.next;
        boolean flag = false; // 默认更新失败
        if(tmp == null){
            System.out.println("链表为空！");
            return flag;
        }
        while (true) {
            if (tmp == null) {
                break;
            }
            if (node.user.getId() == tmp.user.getId()) {
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if(flag){
            tmp.user.setName(node.user.getName());
        }
        return flag;
    }

    /**
     * 根据id删除元素
     * @param id 
     * @return
     */
    public boolean delete(int id) {
        Node tmp = head;
        boolean flag = false; // 默认删除失败
        if(tmp.next == null) {
            System.out.println("链表为空！");
            return flag;
        }
        while(true) {
            if(tmp.next == null) {
                break;
            }
            if(tmp.next.user.getId() == id) {
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if(flag) {
            tmp.next = tmp.next.next;
        }
        return flag;
    }

    /**
     * 内部类，作为节点，对外屏蔽
     */
    private class Node {

        private User user;
        private Node next;
        public Node(){}

        public Node(User user) {
            this.user = user;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "user=" + user +
                    '}';
        }
    }
}

2.1.3 代码2.0版（完整版）

注意：完整版对show方法进行了改造，增加了入栈、出栈、单链表的翻转、反向打印、有序合并这5个方法

package linkedlist;

import linkedlist.pojo.User;

/**
 * @author: doudou
 * @date: Created in 2020/3/31
 * @description:
 * @version: 1.0
 */
public class UndirectionalLinkedList {
    // 头指针一开始就要初始化
    private Node head = new Node();

    /**
     * push方法，将元素放到链表的末尾
     * @param user
     */
    public void push(User user){
        Node node = new Node(user);
        Node tmp = head;
        while(true){
            if(tmp.next == null){
                break;
            }
            // 注意指针后移，防止死循环
            tmp = tmp.next;
        }
        tmp.next = node;
    }

    /**
     * 展示链表
     */
    private void _show(Node head){
        Node tmp = head.next;
        if (tmp == null) {
            System.out.println("链表为空！");
        }
        while(true){
            if(tmp == null){
                return;
            }
            System.out.println(tmp);
            tmp = tmp.next;
        }
    }

    /**
     * 展示链表
     */
    public void show(){
        this._show(this.head);
    }

    /**
     * 按照id，升序插入到特定位置
     * 如果有重复的元素，则插入失败
     * @param user
     * @return
     */
    public boolean insert(User user) {
        Node node = new Node(user);
        Node tmp = head;
        boolean flag = false; // 默认插入失败
        while(true){
            if(tmp.next == null){
                flag = true;
                break;
            }
            if(node.user.getId() < tmp.next.user.getId()) {
                flag = true;
                break;
            }
            if(node.user.getId() == tmp.next.user.getId()) {
                break;
            }
            tmp = tmp.next;
        }
        if(flag) {
            node.next = tmp.next;
            tmp.next = node;
        }
        return flag;
    }

    /**
     * 根据user的id更新元素
     * @param user
     * @return
     */
    public boolean update(User user) {
        Node node = new Node(user);
        Node tmp = head.next;
        boolean flag = false; // 默认更新失败
        if(tmp == null){
            System.out.println("链表为空！");
            return flag;
        }
        while (true) {
            if (tmp == null) {
                break;
            }
            if (node.user.getId() == tmp.user.getId()) {
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if(flag){
            tmp.user.setName(node.user.getName());
        }
        return flag;
    }

    /**
     * 根据id删除元素
     * @param id
     * @return
     */
    public boolean delete(int id) {
        Node tmp = head;
        boolean flag = false; // 默认删除失败
        if(tmp.next == null) {
            System.out.println("链表为空！");
            return flag;
        }
        while(true) {
            if(tmp.next == null) {
                break;
            }
            if(tmp.next.user.getId() == id) {
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if(flag) {
            tmp.next = tmp.next.next;
        }
        return flag;
    }

    /**
     * 翻转整个链表但是不改变原链表
     */
    private Node _reverse() {
        if(head.next == null || head.next.next == null) { // 1个或0个不翻转
            return head;
        }
        Node cur = head.next;
        Node reverseHead = new Node();
        while (cur != null) {
            Node next = cur.next;
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            cur = next;
        }
        return reverseHead;
    }

    /**
     * 翻转
     */
    public void reverse() {
        Node node = this._reverse();
        head.next = node.next;
    }

    /**
     * 翻转打印
     */
    public void reversePrint() {
        if(head.next == null) {
            System.out.println("[]");
            return;
        }
        Node node = this._reverse();
        _show(node);

    }

    /**
     * 添加一个元素到链表的第一个位置，入栈
     * @param user 待入栈的元素
     */
    public void stackPush(User user) {
        Node node = new Node(user);
        node.next = head.next;
        head.next = node;
    }

    /**
     * 将链表的第一个元素出栈
     * @return
     */
    public User stackPop() {
        if (head.next == null) {
            return null;
        }
        Node res = head.next;
        head.next = res.next;

        // 复制user
        User user = new User();
        user.setName(res.user.getName());
        user.setId(res.user.getId());

        return user;
    }


    /**
     * 有序合并两个链表（两个链表都为从小到大排列的，合并后也为从小到大排列） O(n)
     * @param otherList 要与this合并的链表
     * @return 新的链表
     */
    public UndirectionalLinkedList mergeSorted(UndirectionalLinkedList otherList) {
        UndirectionalLinkedList newList = new UndirectionalLinkedList();
        if(otherList.head.next == null) {
            newList.head.next = this.head.next;
            return newList;
        }

        Node cur = this._reverse().next;
        Node otherCur = otherList._reverse().next;
        while (cur != null && otherCur != null) {
            User user = new User();
            if(cur.user.getId() > otherCur.user.getId()) {
                user.setId(cur.user.getId());
                user.setName(cur.user.getName());
                cur = cur.next;
            }else{
                user.setId(otherCur.user.getId());
                user.setName(otherCur.user.getName());
                otherCur = otherCur.next;
            }
            newList.stackPush(user);
        }

        while (cur != null) {
            User user = new User();
            user.setId(cur.user.getId());
            user.setName(cur.user.getName());
            cur = cur.next;
            newList.stackPush(user);
        }


        while (otherCur != null) {
            User user = new User();
            user.setId(otherCur.user.getId());
            user.setName(otherCur.user.getName());
            otherCur = otherCur.next;
            newList.stackPush(user);
        }

        return newList;
    }

    /**
     * 内部类，作为节点，对外屏蔽
     */
    private class Node {

        private User user;
        private Node next;
        public Node(){}

        public Node(User user) {
            this.user = user;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "user=" + user +
                    '}';
        }
    }
}

2.2 双向链表

2.2.1 概述

双向链表，相比于单向链表，既能够找前驱也能够找后驱，本次实现是双向链表的增删改查

2.2.2 代码

  1. UserNode
package linkedlist.node;

import lombok.Data;

/**
 * @author: doudou
 * @date: Created in 2020/4/12
 * @description:
 * @version: 1.0
 */

@Data
public class UserNode {
    private Integer id;
    private String name;
    private UserNode next;
    private UserNode pre;

    public UserNode(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public UserNode() {
    }

    @Override
    public String toString() {
        return "UserNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
  1. 双向链表主体
package linkedlist.dual;

import linkedlist.node.UserNode;

/**
 * @author: doudou
 * @date: Created in 2020/4/12
 * @description: 带头结点的双向链表
 * @version: 1.0
 */
public class DualLinkedList {
    // 头结点
    private UserNode head = new UserNode();
    // 尾结点
    private UserNode tail = head;

    private int size = 0;

    /**
     * 获取双向链表有效结点的数量
     * @return 有效结点的数量
     */
    public int getSize() {
        return size;
    }

    /**
     * 判空
     * @return 如果为空，则返回为true
     */
    public boolean isEmpty() {
        return head == tail;
    }

    /**
     * 展示链表
     */
    public void show() {
        if (isEmpty()) {
            System.out.println("[]");
            return;
        }
        UserNode cur = head.getNext();
        while (cur != null) {
            System.out.println(cur);
            cur = cur.getNext();
        }
    }

    /**
     * 反向展示链表
     */
    public void reverseShow() {
        if (isEmpty()) {
            System.out.println("[]");
            return;
        }
        UserNode cur = tail;
        while (cur != head) {
            System.out.println(cur);
            cur = cur.getPre();
        }
    }

    /**
     * 增加新结点
     * @param newNode
     */
    public void add(UserNode newNode) {
        tail.setNext(newNode);
        newNode.setPre(tail);
        tail = newNode;
        size++;
    }


    /**
     * 根据ID删除结点，如果要删除的是最后一个结点，一定要小心
     * @param id 要删除结点的id
     */
    public void remove(int id) {
        if(isEmpty()) {
            System.out.println("链表为空，删除失败");
            return;
        }
        UserNode cur = head.getNext();
        boolean flag = false; // flag为false表示没有找到该id对应的结点
        while (cur != null) {
            if(cur.getId() == id) {
                flag =true;
                break;
            }
            cur = cur.getNext();
        }
        if(flag) {
            if(cur == tail) { // 如果要删除最后一个结点，需要特判
                tail = tail.getPre();
                tail.setNext(null);
                size--;
                return;
            }
            cur.getPre().setNext(cur.getNext()); // 当前结点前驱的后驱指向当前结点的后驱
            cur.getNext().setPre(cur.getPre()); // 当前结点后驱的前驱指向当前结点的前驱
            size--;
        }else {
            System.out.println("未找到ID="+id+"的结点");
        }
    }

    /**
     * 更新结点
     * @param newNode 利用id更新结点
     */
    public void update(UserNode newNode) {
        if(isEmpty()) {
            System.out.println("链表为空，无法进行更新操作");
            return;
        }
        UserNode cur = head.getNext();
        boolean flag = false; // flag为false表示没有找到该id对应的结点
        while (cur != null) {
            if(cur.getId() == newNode.getId()) {
                flag =true;
                break;
            }
            cur = cur.getNext();
        }
        if(flag) {
            cur.setName(newNode.getName());
        }else {
            System.out.println("未找到待更新结点");
        }
    }
}

2.3 循环单向链表与约瑟夫问题

2.3.1 概述

  1. 循环单向链表一般不设置头结点，删除结点需要把所有条件考虑清楚
  2. 约瑟夫问题：

n 个人围成一圈，从第一个人开始报数，数到 m 的人出列，再由下一个人重新从 1 开始报数，数到 m 的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。

题目链接：https://www.luogu.com.cn/problem/P1996

2.3.2 AC代码

import java.util.Scanner;

/**
 * @author: doudou
 * @date: Created in 2020/4/12
 * @description:
 * @version: 1.0
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        CircleLinkedList circleLinkedList = new CircleLinkedList();
        circleLinkedList.exitFromJosepCircle(n,m);
    }
}

class CircleLinkedList {
    private JosephNode head = null;
    private JosephNode tail = null;
    private int size = 0;

    /**
     * 获取循环单向链表的长度
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 判空
     * @return
     */
    public boolean isEmpty() {
        return head == null;
    }

    /**
     * 打印循环链表
     */
    public void show() {
        if(isEmpty()) {
            System.out.println("[]");
            return;
        }
        JosephNode cur = head;
        while (true) {
            System.out.println(cur);
            if (cur == tail) {
                break;
            }
            cur = cur.getNext();
        }
    }


    /**
     * 增加新结点
     * @param node 新增加的结点
     */
    public void add(JosephNode node) {
        if(head == null) {
            head = node;
            tail = head;
            tail.setNext(head);
            size++;
            return;
        }
        tail.setNext(node);
        tail = node;
        tail.setNext(head);
        size++;
    }

    /**
     * 清空链表
     */
    public void clear() {
        size = 0;
        head = null;
        tail = null;
    }

    /**
     * 根据ID删除结点
     * @param id
     */
    public void delete(int id) {
        if(isEmpty()) {
            System.out.println("该链表为空，不能删除");
            return;
        }

        if(size == 1) { // 如果只有一个结点
            clear();
            return;
        }

        if (head.getId() == id && size > 1) { // 如果要删除第一个结点，特判
            head = head.getNext();
            tail.setNext(head);
            size--;
            return;
        }

        JosephNode cur = head;
        JosephNode cur4next = head.getNext();
        boolean flag = false; // 默认代表没找到结点
        while (true) {
            if(cur4next.getId() == id) {
                flag = true;
                break;
            }
            if(cur4next == tail) {
                break;
            }
            cur = cur.getNext();
            cur4next = cur4next.getNext();
        }
        if(flag) { // 找到了
            if(cur4next == tail) {
                tail = cur;
            }
            cur.setNext(cur4next.getNext());
            size--;
        }else {
            System.out.println("不存在待删除的结点");
        }
    }

    /**
     * 生成约瑟夫环
     * @param n 1-n
     */
    public void constructJosepCircle(int n) {
        for(int i=1;i<=n;i++) {
            JosephNode josephNode = new JosephNode(i);
            add(josephNode);
        }
    }

    /**
     * 打印出圈顺序
     * @param n 1-n
     * @param m 数到m出圈
     */
    public void exitFromJosepCircle(int n,int m) {
        clear();
        constructJosepCircle(n);
        JosephNode cur = head;
        while (size > 0) {
            for(int i=0;i<m-1;i++) {
                cur = cur.getNext();
            }
            System.out.printf("%d ",cur.getId());
            delete(cur.getId());
            if(size > 0) {
                cur = cur.getNext();
            }
        }
    }
}

class JosephNode {
    private int id;
    private JosephNode next;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public JosephNode getNext() {
        return next;
    }

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

    @Override
    public String toString() {
        return "JosephNode{" +
                "id=" + id +
                '}';
    }

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

    public JosephNode() {}
}

猜你喜欢

转载自www.cnblogs.com/doubest/p/12910479.html
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022