链表的基本原理以及java实现

一：单向链表基本介绍

链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。

单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。 上图中最左边的节点即为头结点（Head），但是添加节点的顺序是从右向左的，添加的新节点会被作为新节点。最先添加的节点对下一节点的引用可以为空。引用是引用下一个节点而非下一个节点的对象。因为有着不断的引用，所以头节点就可以操作所有节点了。 下图描述了单向链表存储情况。存储是分散的，每一个节点只要记录下一节点，就把所有数据串了起来，形成了一个单向链表。 节点（Node）是由一个需要储存的对象及对下一个节点的引用组成的。也就是说，节点拥有两个成员：储存的对象、对下一个节点的引用。下面图是具体的说明：

二：链表的实现

package com.cgs.demo.service;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Stack;

/**
 * @author chenguangshuai
 * @title: SingleLinkedListDemo
 * @projectName demo
 * @description: 链表
 * @date 2/24/22-3:54 PM
 */
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(new HeroNode(1, "卢本伟", "五五开"));
        singleLinkedList.add(new HeroNode(5, "韩金龙", "芜湖大司马"));
//        singleLinkedList.list();
        singleLinkedList.addByOrder(new HeroNode(3, "王云浩", "小天才"));
        System.out.println("----------------------------------");
//        singleLinkedList.list();
        singleLinkedList.updateByNo(new HeroNode(3, "DSM", "芜湖厨子"));
//        singleLinkedList.list();
//        System.out.println("----------------删除---------------");
//        singleLinkedList.deleteByNo(5);
        SingleLinkedList.reverse(singleLinkedList.head);
        singleLinkedList.list();
        singleLinkedList.reversePrint(singleLinkedList.head);
//        System.out.println(singleLinkedList.getLength(singleLinkedList.head));
//        System.out.println(SingleLinkedList.getIndexHeroNode(singleLinkedList.head, 1));

    }

    static class SingleLinkedList {
        //先初始化一个节点，头节点不动，不存在具体数据
        HeroNode head = new HeroNode(0, "", "");

        //添加节点到单向链表
        //1. 找到当前链表的最后节点
        //2. 将最后这个节点的next指定新节点
        public void add(HeroNode heroNode) {
            //因为head节点不能动，所以需要一个辅助变量temp
            HeroNode temp = head;
            while (true) {
                //根据是否有下个节点判断 是否到了链表动最后
                if (temp.next == null) {
                    break;
                }
                //如果没有找到最后 temp后移
                temp = temp.next;
            }
            //当退出循环时，temp就指向了链表的最后位置
            //当最后这个节点的next 指向新的节点
            temp.next = heroNode;
        }

        //显示链表

        /**
         * 显示链表
         */
        public void list() {
            //判断链表是否为空
            if (head.next == null) {
                System.out.println("链表为空");
            }
            //因为头节点，不能动，因此我们需要一个中间变量来遍历
            HeroNode temp = head.next;
            while (true) {
                //判断是否到链表最后
                if (temp == null) {
                    break;
                }
                //输出节点的信息
                System.out.println(temp);
                //将中间变量后移
                temp = temp.next;
            }
        }

        /**
         * 根据顺序添加
         *
         * @param heroNode 节点元素
         */
        public void addByOrder(HeroNode heroNode) {
            //因为头节点不能动，因此需要一个辅助指针（变量）来帮助找到到添加到位置
            //因为单链表，因为temp（中间变量）是位于添加位置到上一个节点
            HeroNode temp = head;
            //标记需要添加到编号是否存在，默认为false
            boolean flag = false;
            while (true) {
                //temp为链表到尾节点
                if (temp.next == null) {
                    break;
                }
                //temp的下个节点的编号大于要插入的节点 位置找到
                if (temp.next.no > heroNode.no) {
                    break;
                }
                //编号已经存在
                if (temp.next.no == heroNode.no) {
                    flag = true;
                    break;
                }
                //后移
                temp = temp.next;
            }
            //根据flag的值判断
            if (flag) {
                System.out.printf("准备插入的英雄编号%d已经存在了\n", heroNode.no);
            } else {
                //找到对应的位置
                heroNode.next = temp.next;
                temp.next = heroNode;
            }
        }

        /**
         * 根据编号修改节点
         *
         * @param heroNode 新节点
         */
        public void updateByNo(HeroNode heroNode) {
            //判断队列是否为空
            if (head.next == null) {
                System.out.println("链表为空");
                return;
            }
            HeroNode temp = head;
            //对链表进行遍历找到要修改对节点
            boolean flag = false;
            while (true) {
                //已经遍历到链表尾
                if (temp.next == null) {
                    break;
                }
                if (temp.no == heroNode.no) {
                    //找到对应对节点
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //找到对应编号到节点
            if (flag) {
                temp.nickName = heroNode.nickName;
                temp.name = heroNode.name;
            } else {
                System.out.println("没有找到对应节点");
            }
        }

        /**
         * 根据编号删除节点
         *
         * @param no 节点编号
         */
        public void deleteByNo(int no) {
            //判断是否链表为空
            if (head.next == null) {
                System.out.println("链表为空");
                return;
            }
            HeroNode temp = head;
            //设置标识
            boolean flag = false;
            while (true) {
                //已经遍历到链表尾
                if (temp.next == null) {
                    break;
                }
                //找到修改节点的上一个节点
                if (temp.next.no == no) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }

            //找到对应的节点
            if (flag) {
                //找到要删除节点的上一个节点 将删除节点的下一个节点 绑定为中间变量的下一个节点
                temp.next = temp.next.next;

            } else {
                System.out.println("没有对应的节点无法删除");
            }
        }
        /***
         * 单链表面试题
         * 1。求单链表中的有效节点的个数
         * 2。查找单链表中倒数第K个节点
         * 3。单链表的反转
         * 4。从尾到头打印单链表【百度，要求方式1 ： 反向遍历。方式2 ：stack栈】
         * 5。合并两个有序的单链表，合并玩之后的链表依然有序【课后练习】
         * 6。约瑟夫环问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
         */

        /**
         * 链表的长度计算
         *
         * @param head 头节点
         * @return
         */
        public static int getLength(HeroNode head) {
            if (head.next == null) {
                return 0;
            }
            int index = 0;
            HeroNode temp = head.next;
            while (true) {
                if (temp == null) {
                    break;
                }
                index++;
                temp = temp.next;
            }
            return index;
        }

        /**
         * 获取链表中第K个节点
         * @param index 第K节点
         * @return
         */

        /***
         * 思路
         * 1.编写函数，接受head节点，同时接受一个index
         * 2.index表示是倒数第index个节点
         * 3.先把链表从头到尾遍历,得到链表的总长度
         * 4.得到size后 我们从头开始遍历（size-index）个，就可以得到
         */
        public static HeroNode getIndexHeroNode(HeroNode temp, int index) {
            //判断如果链表为空，返回null
            if (temp.next == null) {
                return null;
            }
            //获取链表的长度
            int length = getLength(temp);
            //第二次遍历
//            int mark = 0;
            //从第一个有效节点开始
            temp = temp.next;
//            while (true) {
//                if (mark == length - index) {
//                    break;
//                }else {
//                    mark++;
//                    temp = temp.next;
//                }
//            }
            //校验index
            if (index <= 0 || index > length) {
                return null;
            }
            for (int i = 0; i < length - index; i++) {
                temp = temp.next;
            }
            return temp;
        }

        /**
         * 反转链表
         * @param head 头节点
         * @return
         */

        /***
         * 思路
         * 1.先定义一个节点 reverseHead = new HeroNode();
         * 2.从头到尾遍历原来的链表，每遍历一个节点，并放在新的链表reverseHeroNode的最前端
         * 3.原来的链表的head.next = reverseHead.next
         */
        public static void reverse(HeroNode head) {
            //检验链表
            if (head.next == null || head.next.next == null) {
                return;
            }
            //定义一个新的辅助指针(变量)，帮助我们遍历原来的链表
            HeroNode cur = head.next;
            //指向当前节点【cur】的下一个节点
            HeroNode next = null;
            HeroNode reverseHead = new HeroNode(0, "", "");
            //遍历原来的链表，每遍历一个节点，就将它取出来，并放在新的链表reverseHead的最前端
            while (cur != null) {
                //先暂时保存在当前节点的下一个节点，因为后面需求使用
                next = cur.next;
                //将cur的下一个节点指向新的链表的节点
                cur.next = reverseHead.next;
                reverseHead.next = cur;

                cur = next;//后移
            }
            //将head.next 指向reverseHead.next  实现单链表的反转
            head.next = reverseHead.next;
        }

        /**
         * 思路
         * 利用栈这个数据结构，将各个节点压入到栈中，利用栈的先进后出的特点，就实现了逆序打印的效果
         * @param head 链表的头节点
         */
        public void reversePrint(HeroNode head) {
            if (head.next == null) {
                return; // 空链表，不能打印
            }
            //创建一个栈，给所有节点压入栈
            Stack<HeroNode> stack = new Stack<>();
            HeroNode temp = head.next;
            //将链表中的所有节点压入栈
            while (temp != null) {
                stack.push(temp);
                temp = temp.next;//temp后移，这样就可以压入下一个节点
            }
            //将栈中的节点进行打印，pop出栈
            while(stack.size()>0){
                System.out.println(stack.pop());
            }
        }




    }

    @Data
    @NoArgsConstructor
    static
    class HeroNode {
        //编号
        public int no;
        //名称
        public String name;
        //昵称
        public String nickName;
        //下个节点编码
        public HeroNode next;

        public HeroNode(int no, String name, String nickName) {
            this.no = no;
            this.name = name;
            this.nickName = nickName;
        }

        public HeroNode(int no, String name) {
            this.no = no;
            this.name = name;
        }

        @Override
        public String toString() {
            return "HeroNode{" +
                    "no=" + no +
                    ", name='" + name + '\'' +
                    ", nickName='" + nickName + '\'' +
                    '}';
        }
    }


}