第四章：链表

4.3单链表的面试题

package com.atguigu03.linkedList;

import java.util.Stack;

/**
 * @author peng
 * @date 2021/11/2 - 21:53
 * <p>
 * 简单的单链表实现
 */
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
        HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");

        //将节点加入链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
//        singleLinkedList.add(heroNode1);
//        singleLinkedList.add(heroNode2);
//        singleLinkedList.add(heroNode3);
//        singleLinkedList.add(heroNode4);

        //使用考虑顺序的插入方法
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode4);
        singleLinkedList.addByOrder(heroNode2);
        singleLinkedList.addByOrder(heroNode3);
        singleLinkedList.addByOrder(heroNode3);

        //链表信息的修改
        HeroNode newHeroNode = new HeroNode(3, "有用", "没脑袋");
        singleLinkedList.update(newHeroNode);

        //链表的删除
        singleLinkedList.delete(4);

        //输入链表
        singleLinkedList.showList();

        //新浪面试题
        System.out.println("链表的有效节点个数为：" + getLength(singleLinkedList.getHead()));

        //新浪面试题二：返回倒数第K个节点
//        System.out.println("链表倒数第三个节点为：" + findLastIndexNode(singleLinkedList.getHead(), 3));

        //腾讯面试题：单链表的反转
        System.out.println("原来的链表顺序为：");
        singleLinkedList.showList();
        reverswList(singleLinkedList.getHead());
        System.out.println("反转后链表的顺序为：");
        singleLinkedList.showList();

        //百度面试题：逆序打印单链表
        System.out.println("原来链表的顺序为：");
        singleLinkedList.showList();
        System.out.println("逆序打印单链表：");
        reversePrint(singleLinkedList.getHead());
    }

    /**
     * 面试题一：新浪
     * 求单链表中有效节点的个数
     * 传入链表的头节点
     */
    public static int getLength(HeroNode head) {
        int count = 0;//链表有效节点的个数，初始值为0
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                return count;
            }
            count++;
            temp = temp.next;
        }
    }

    /**
     * 面试题二：新浪
     * 返回倒数第K个节点
     * 思路：先获取链表的长度，再返回第（链表长度 - k）个节点
     */
    public static HeroNode findLastIndexNode(HeroNode head,int index) {
        //判断链表是否为空
        if (head.next == null) {
            //当前链表为空，返回null
            return null;
        }
        //如果链表不为空，获取当前链表的长度
        int size = getLength(head);
        //返回倒数第K个节点
        if (index <= 0 || index > size) {
            //先判断index是否合法
            return null;
        }
        int length = 0;//需要返回节点的顺序
        HeroNode temp = head.next;
        while (length != (size - index)) {
            length ++;
            temp = temp.next;
        }
        return temp;
    }

    /**
     * 面试题三：腾讯，实现单链表的反转
     */
    public static void reverswList(HeroNode head) {
        //首先判断当前链表是否为空，或者当前链表只有一个节点，则直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
        HeroNode cur = head.next;
        HeroNode next = null;
        HeroNode reverseHead = new HeroNode(0,"","");
        while (cur != null) {
            next = cur.next;//先将当前节点的下一个节点保存起来
            cur.next = reverseHead.next;//当前节点的下一个节点指向反转链表的第一个节点
            reverseHead.next = cur;//反转链表的第一个节点变为当前节点，就实现了顺序的调换
            cur = next;//当前节点变为下一个节点
        }
        head.next = reverseHead.next;//再用原来的头结点替换反转链表的头节点
    }

    /**
     * 面试题四：百度，从尾到头打印单链表
     * 思路：利用栈的先进后出特性
     */
    public static void reversePrint(HeroNode head) {
        //先判断当前链表是否为空或链表只有一个节点，如果满足则不需要对链表进行操作
        if (head.next == null || head.next.next == null) {
            return;
        }
        //利用栈的特点
        Stack<HeroNode> stack = new Stack<>();
        HeroNode cur = head.next;
        while (cur != null) {
            //将节点压入栈中
            stack.push(cur);
            cur = cur.next;
        }
        //出栈，因为节点之间本来就已经连在一起的了，栈并不会改变节点之间的关系
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }
}

//定义单链表管理英雄数据
class SingleLinkedList {
    private HeroNode head = new HeroNode(0, "", "");//定义一个头节点

    /**
     * 不考虑顺序，将一个节点添加到链表的最后
     */
    public void add(HeroNode heroNode) {
        HeroNode temp = head;//定义一个临时变量
        while (true) {
            //遍历链表，找到链表的最后一个节点
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        //在最后一个节点后面添加新的节点
        temp.next = heroNode;
    }

    /**
     * 第二种添加英雄的方法，考虑到顺序的插入
     * 插入的节点要按照顺序插入
     */
    public void addByOrder(HeroNode heroNode) {
        /*
        找到插入节点的前一个节点，把该节点的指针指向插入节点，再把插入节点的指针指向原来的后一个节点
         */
        HeroNode temp = head;//定义临时节点
        boolean flag = false;//表示链表中是否已经存在序号相同的节点，默认是false
        while (true) {
            if (temp.next == null) {
                //如果遍历到最后一个节点，那么表示插入的节点插入到链表的末尾
                break;
            }
            else if (temp.next.no > heroNode.no) {
                //如果当前节点的下一个节点的序号大于插入的节点，那么说明该节点应该插入到当前节点的下一个位置
                break;
            }else if (temp.next.no == heroNode.no) {//注意头节点是没有数据的，所以比较的是头节点的下一个元素
                //表示如果链表中已经存在相同序号的节点，那么标识改为true
                flag = true;
                break;
            }
            //如果上述的条件都不满足
            temp = temp.next;
        }

        if (flag) { //根据flag的值判断能不能进行插入操作
            System.out.println("当前链表之中已经存在相同序号的元素" + heroNode.no + "，不能进行插入操作");
        }else {
            //进行链表的插入操作
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    /**
     * 实现节点信息的修改，注意节点的编号不支持修改，只支持节点信息的修改
     */
    public void update(HeroNode newHeroNode) {
        /*
        根据节点的编号修改节点的信息
         */

        //首先判断链表是否为空！
        if (head.next == null) {
            System.out.println("当前链表为空！");
            return;
        }
        HeroNode temp = head;
        while(true) {
            //先找到要修改信息的那一个节点
            if (temp.next == null) {
                System.out.println("没有找到对应序号的英雄");
                break;
            }
            if (temp.next.no == newHeroNode.no) {
                temp.next.name = newHeroNode.name;
                temp.next.nickName = newHeroNode.nickName;
                break;
            }
            temp = temp.next;
        }
    }

    /**
     * 实现链表节点的删除
     */
    public void delete(int no) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("当前链表为空！");
            return;
        }
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                System.out.println("没有找到要删除的节点，请确认后输入");
                return;
            }
            if (temp.next.no == no) {
                if (temp.next.next == null) {
                    //如果要删除的节点是尾结点
                    temp.next = null;
                    break;
                }
                System.out.println("找到要删除的节点，正在删除~~~");
                HeroNode deleteNode = temp.next;//定义一个临时变量存放要删除的节点
                temp.next = deleteNode.next;//删除节点
                deleteNode.next = null;//要删除的节点下一个节点置为空
                break;
            }
            temp = temp.next;
        }
    }

    /**
     * 返回头节点
     */
    public HeroNode getHead() {
        return head;
    }

    /**
     * 显示链表
     */
    public void showList() {
        if (head.next == null) {
            //如果只有一个头节点，那么该链表就是空的
            System.out.println("当前链表为空！");
            return;
        }
        //遍历链表
        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

/**
 * 定义水浒传英雄节点
 */
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;
    }

    @Override
    public String toString() {//重写toString方法
        return "heroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}