链表

链表

链表介绍

链表是有序的列表

1. 链表是以节点的方式来存储，是链式存储
2. 每个节点包含data域，next域：指向下一个节点
3. 链表的每个节点不一定是连续存储
4. 链表分带头节点的链表和没有头结点的链表，根据实际的需求来确定

单链表

单链表的应用实例

public class SingleLinkedList {

    //定义SingleLinkedList , 管理我们的英雄

    //先初始化一个头结点，头结点不要动，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    //思路：（当不考虑编号顺序时）
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next 指向新的节点
    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; //flag标志添加的编号是否存在，默认为false
        while(true){
            if (temp.next == null){
                break;
            }else if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){
                flag = true;
                break;
            }

            temp = temp.next;
        }

        if (flag){
            System.out.printf("您插入的编号 %d 已存在\n",heroNode.no);
        }else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    public void update(HeroNode newHero){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }

        HeroNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }else if (temp.no == newHero.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            temp.name = newHero.name;
            temp.nickName = newHero.nickName;
        }else{
            System.out.println("没有找到该节点");
        }
    }

    public void delete(int no){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }else if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("该节点不存在");
        }
    }

    public void showList(){
        if (head.next == null){
            System.out.println("列表为空");
            return;
        }

        HeroNode temp = head.next;
        while (true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

单链表面试题

1. 求单链表中有效节点的个数

public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }

        int length = 0;
        HeroNode temp = head.next;
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

2. 查找单链表中的倒数第k个节点

public static HeroNode getLastIndexNode(SingleLinkedList sll, int index) {
        HeroNode head = sll.getHead();
        //判断链表为空，返回null
        if (head.next == null) {
            return null;
        }

        //得到链表有效节点长度
        int size = getLength(head);
        //校验index
        if (index <= 0 || index > size){
            return null;
        }
        //遍历
        HeroNode temp = head.next;
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

3. 单链表的反转

public static void reverseList(SingleLinkedList sll){
        HeroNode head = sll.getHead();

        //如果当前列表为空，或者只有一个节点，无需反转，直接返回
        if (head.next == null || head.next.next == null){
            return;
        }

        HeroNode temp = head.next;
        HeroNode next = null;
        HeroNode reverseHead = new HeroNode(0,"","");
        while(temp != null){
            next = temp.next;
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            temp = next;
        }
        head.next = reverseHead.next;
    }

4. 从尾到头打印单链表

public static void reversePrint(SingleLinkedList sll){
        HeroNode head = sll.getHead();
        if (head.next == null){
            return; //空链表，不能打印
        }

        Stack<HeroNode> stack = new Stack<>();
        HeroNode temp = head.next;
        while (temp != null){
            stack.push(temp);
            temp = temp.next;
        }

        while (stack.size() > 0){
            System.out.println(stack.pop());
        }
    }

双向链表

双向链表实现遍历、添加、修改、删除的代码：

public class DoubleLinkedList {

    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead() {
        return head;
    }

    public void showList(){
        if (head.next == null){
            System.out.println("链表为空~~");
            return;
        }

        HeroNode temp = head.next;
        while(true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    public void add(HeroNode heroNode){
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true){
            if (temp.next == null){
                break;
            }
            temp = temp.next;
        }

        temp.next = heroNode;
        heroNode.pre = temp;
    }

    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while(true){
            if (temp.next == null){
                flag = true;
                break;
            }else if (temp.next.no > heroNode.no){
                flag = true;
                break;
            }else if (temp.next.no == heroNode.no){
                break;
            }
            temp = temp.next;
        }
        if (flag){
            heroNode.next = temp.next;
            if (temp.next != null){
                temp.next.pre = heroNode;
            }
            temp.next = heroNode;
            heroNode.pre = temp;
        }else{
            System.out.printf("您插入的编号 %d 已存在\n",heroNode.no);
        }
    }

    public void update(HeroNode newHero){
        if (head.next == null){
            System.out.println("链表为空~~");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }else if (temp.no == newHero.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newHero.name;
            temp.nickName = newHero.nickName;
        }else{
            System.out.println("没有找到该节点");
        }
    }

    //从双向链表中删除一个节点
    //说明
    //1. 对于双向链表，我们可以直接找到要删除的这个节点
    //2. 找到后自我删除即可
    public void delete(int no){
        if (head.next == null){
            System.out.println("链表为空，不能删除");
            return;
        }

        HeroNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }else if (temp.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.pre.next = temp.next;
            //如果是最后一个节点，就不需要进行下面这句话，否则出现空指针
            if (temp.next != null){
                temp.next.pre = temp.pre;
            }
        }else{
            System.out.println("该节点不存在");
        }
    }
}

单向环形链表

单向环形链表介绍

应用场景

Josephu（约瑟夫）问题

思路分析：

代码

public class CircleSingleLinkedList {

    private Boy first = null;
    private int num = 0;

    public void addBoy(int num) {
        if (num < 1) {
            System.out.println("你输入的人数小于1");
            return;
        }

        Boy temp = null;

        for (int i = 1; i <= num; i++) {
            Boy boy = new Boy(i);
            if (i == 1) {
                first = boy;
                temp = first;
                temp.setNext(first);
            } else {
                temp.setNext(boy);
                boy.setNext(first);
                temp = temp.getNext();
//                temp = boy;
            }
        }
        this.num = num;
    }

    public void showBoy() {
        if (first == null) {
            System.out.println("没有任何小孩！");
            return;
        }
        Boy temp = first;
        while (true) {
            System.out.printf("小孩的编号：%d \n", temp.getNo());

            if (temp.getNext() == first) {
                break;
            }

            temp = temp.getNext();
        }
    }

    public int getNum() {
        int num = 0;
        if (first == null) {
            return num;
        }

        Boy temp = first;
        while (true) {
            num++;
            if (temp.getNext() == first) {
                break;
            }
            temp = temp.getNext();
        }
        return num;
    }

    public void countBoy(int startNo, int countNum) {

        if (first == null || startNo < 1 || startNo > num) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }

        Boy helper = first;

        while (true) {
            if (helper.getNext() == first) {
                break;
            }
            helper = helper.getNext();
        }

        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        while(true){
            if (helper == first){
                break;
            }

            for (int i=0; i<countNum-1; i++){
                first = first.getNext();
                helper = helper.getNext();
            }
            System.out.println(first.getNo());
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.println(first.getNo());
    }
}