双向链表---环形单向链表

双向链表

package com.shizhong.linkedlist.doublelinkedlist;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1,"一","一一");
        HeroNode hero2 = new HeroNode(2,"二","二二");
        HeroNode hero3 = new HeroNode(3,"三","三三");
        HeroNode hero4 = new HeroNode(4,"四","四四");
        //创建双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);
        doubleLinkedList.list();
        //修改链表节点内容
        HeroNode newNode = new HeroNode(3,"五","五五");
        doubleLinkedList.update(newNode);
        //修改后的链表情况
        System.out.println("修改后的链表情况");
        doubleLinkedList.list();
        //删除
        doubleLinkedList.del(3);
        System.out.println("删除之后的链表");
        doubleLinkedList.list();
        //按照编号顺序向链表中添加节点
        HeroNode node = new HeroNode(3,"SAN","SANSAN");
        doubleLinkedList.addByOrder(node);
        System.out.println("按照编号顺序向双向链表中添加节点");
        doubleLinkedList.list();

    }
}

//创建双向链表
class DoubleLinkedList {
    //创建私有属性，头节点，属于这个节点特有的属性
    private HeroNode head = new HeroNode(0,"","");
    //获取私有属性，即头节点
    public HeroNode getHead() {
        return head;
    }
    //遍历双向链表的节点
    public void list() {
        if (head.next == null) {
            System.out.println("双向链表为空");
            return ;
        }
        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }
    //默认添加节点到双向链表的尾部
    public void add(HeroNode heroNode) {
        HeroNode cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }
        //形成一个双向链表
        cur.next = heroNode;
        heroNode.pre = cur;
    }
    //双向链表中按照编号顺序添加节点
    public void addByOrder(HeroNode heroNode) {
        HeroNode cur = head.next;
        while (true) {
            if (cur == null) {
                break;
            }
            if (cur.no > heroNode.no) {
                cur.pre.next = heroNode;
                heroNode.pre = cur.pre;
                heroNode.next = cur;
                cur.pre = heroNode;
                break;
            }
            cur = cur.next;
        }
    }

    //修改双向链表中一个节点的内容,和单向链表实现一样
    public void update(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return ;
        }
        HeroNode cur = head.next;
        boolean flag = false;
        while (true) {
            if (cur == null) {
                break;
            }
            if (cur.no == heroNode.no) {
                flag = true;
                break;
            }
            cur = cur.next;
        }
        if (flag = true) {
            cur.name = heroNode.name;
            cur.nickname = heroNode.nickname;
        }else {
            System.out.printf("链表中没有编号为%d的节点\n",heroNode.no);
        }
    }
    //从双向链表中删除一个节点
    /*
    注意：从双向链表中删除节点，只需要找到要删除的节点，不需要像单链表找到要删除节点的前一个节点
    找到要删除的节点后，进行自我删除即可
     */
    public void del(int no) {
        if (head.next == null) {
            System.out.println("链表为空");
            return ;
        }
        HeroNode cur = head.next;
        boolean flag = false;
        while (true) {
            if (cur == null) {
                break;
            }
            if (cur.no == no) {
                flag = true;
                break;
            }
            cur = cur.next;
        }
        if (flag) {
            cur.pre.next = cur.next;
            //如果是最后一个节点，不需要执行下面语句，否则会出现空指针异常
            if (cur.next != null) {
                cur.next.pre = cur.pre;
            }
        }else {
            System.out.printf("链表中没有编号为%d的节点\n",no);
        }
    }


}



//创建双向链表的节点类
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点，默认为null
    public HeroNode pre;//指向前一个节点，默认为null
    //创建构造器，初始化对象属性方法
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //重写toString方法，用于显示链表节点
    //在java系统中，当输出一个对象时，或者将某个对象和字符串进行连接时，系统会自动调用该
    // 对象的toString（）方法返回该对象的字符串表示，toString（）方法属于Object对象，所有的
    // 对象都继承了object对象实例，所有对象都可以使用该方法，因此这里首先对toString（）方法进行重写
    //当输出节点对象时，系统自动调用该方法，将对象转化为字符串的形式输出，这里重写了该方法，
    // 因此输出对象时，直接将该对象转化为字符串的形式输出
    //返回链表节点，以字符串的形式
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

环形单向链表

package com.shizhong.linkedlist.josephu;

public class Josephu {
    public static void main(String[] args) {
        //创建环形单向链表
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addNode(125);//加入5个节点
        circleSingleLinkedList.showNode();
        //测试节点出圈的顺序
        circleSingleLinkedList.countNode(20,10,125);

    }
}
//创建环形单向链表类
class CircleSingleLinkedList {
    //创建一个first节点，当前没有编号
    private Node first = null;
    //添加节点，构成环形链表
    public void addNode(int nums) {//nums表示添加节点个数
        //对nums做一个校验
        if (nums < 1) {
            System.out.println("nums数值有误");
            return ;
        }
        Node cur = null;
        //使用for循环创建环形链表
        for (int i = 1; i <= nums; i++) {
            Node node = new Node(i);//创建编号为i的节点
            if (i == 1) {//判断如果是第一个节点
                first = node;//让first永远指向第一个节点,让first永远表示环形单向链表的第一个节点
                first.setNext(first);//这里是私有属性，需要设置私有属性的值，这里让第一个节点形成环
                cur = first;//创建一个辅助指针，指向第一个节点
            }else{
                cur.setNext(node);
                node.setNext(first);
                cur = node;
            }
        }
    }
    //遍历当前环形单向链表
    public void showNode() {
        //判断链表是否为空
        if (first == null) {
            System.out.println("链表为空");
            return ;
        }
        //因为first不能动，永远指向环形单向链表的第一个节点，所以引入一个辅助指针
        Node cur = first;
        while (true) {
            System.out.printf("节点的编号为%d\n",cur.getNo());
            if (cur.getNext() == first) {//如果当前节点的下一个节点是first节点，则说明循环链表遍历完成了
                break;
            }
            cur = cur.getNext();//cur向后移动
        }

    }
    //根据输入，计算出节点出圈的顺序

    /**
     *
     * @param startNo 表示从第几个节点开始计数
     * @param countNum 表示数多少下
     * @param nums 表示最初环形单向链表中有多少个节点
     */
    public void countNode(int startNo, int countNum, int nums){
        //对参数进行校验
        if (first == null || startNo < 1 || countNum > nums) {
            System.out.println("参数输入有误");
            return ;
        }
        //定义辅助指针，帮助完成节点出圈
        Node helper = first;
        while (helper.getNext() != first) {
            helper = helper.getNext();
        }//此时，helper指向first节点的后一个位置
        //让first移动到开始计数的那个节点。
        for (int j = 0; j < startNo -1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        //当开始计数时，让first和helper同时移动countNum-1次，因为本身还要计数，然后出圈
        //这里是一个循环操作，当圈中只有一个人时，结束循环
        while (helper != first) {//当环中只有一个节点，退出循环
            for (int i = 0; i < countNum -1; i++) {//让first和helper同时向后移动countNum-1次
                first = first.getNext();
                helper = helper.getNext();
            }
            //此时first指向待出环的节点，helper指向后一个节点，因此将first在向后移动一个
            System.out.printf("节点%d出圈\n",first.getNo());
            //让first指向的节点出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的节点编号为%d\n",first.getNo());


    }


}


//创建节点类
class Node {
    private int no;
    private Node next;//指向下一个节点，默认为null
    public Node(int no) {
        this.no = no;
    }
    //获取私有属性

    public int getNo() {//获取私有属性
        return no;
    }
    public Node getNext() {
        return next;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public void setNext(Node next) {
        this.next = next;//设置私有属性的值，让节点的指向下一个节点
    }
}