JAVA数据结构 - 单向链表

1.单链表                    2.JAVA模拟单链               1.直接在末尾插入   2.顺序插入   3.更新删除节点

  1.定义一个临时模拟指针指向头结点,用来判断条件

  2.链表:  想要获得某一个节点,只能获得它的前一个,再.next获取它本身

  3.设置 新插入节点时,  Next:  先设置   newHead的  next      Pre :   先设置 原来节点的前一个   指向新节点

1.单链表

1)   链表是以节点的方式来存储,是链式存储             2)   每个节点包含  data  域(存储数据)， next  域:指向下一个节点.

3)   如图：发现链表的各个节点不一定是连续存储.  4)   链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

 单链表(带头结点)  逻辑结构示意图如下 ,看起来是连续的, 但是真正的结构是上图

2.JAVA模拟单链表

    1.主要注意的是,定义一个临时的模拟指针指向头结点,用它来判断是否满足条件,如果没有就向后移动一位,而不影响原来的节点

    2.直接插入时,如果 tmp后面为null,那么直接将tmp.next指向 新添加进来的 节点即可

    1.直接在末尾插入

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        singleLinkedList.show();
    }

    static class SingleLinkedList {
        //先定一个头结点,不存储信息
        private HeroNode HeadNode = new HeroNode(0, "", "");

        /**
         * 向链表的最后一位插入
         * @param headNode
         */
        public void add(HeroNode headNode) {

            HeroNode tmp = HeadNode; //定一个临时变量指向头结点

            while (true) {
                if (tmp.next == null) {  //如果头结点的下一位为空,那么将传入的节点设置为它的下一位
                    tmp.next = headNode;
                    break;
                }
                tmp = tmp.next;    //如果不为空,指向下一位
}}
    static class HeroNode {
        private int number;
        private String name;
        private String nickName;
        private HeroNode next;

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

  2.顺序插入

   1.分三种情况,  当为空直接插入     

    2.当tmp.next > 要插入的编号 那么就在 tmp与tmp之间插入

         将headNode的下一位指向tmp的下一位将tmp的下一位指向 headNode

   3.始终不满足 tmp.next > 要插入的编号,那么tmp指向最后一位为null, 说明编号是最大的,插入最后面

         public void addByOder(HeroNode headNode) {
            HeroNode tmp = HeadNode; //将头结点,赋值给临时变量,以便操作
            Boolean flag = false;  //表示要插入的节点是否存在

            while (true) {
                if (tmp.next == null) {  //已经最后一个了,直接插入
                    break;
                }
                if (tmp.next.number > headNode.number) {
                    //表示tmp的下一个大于headNode那么headNode就插入到tmp之后就行了
                    break;
                } else if (tmp.next.number == headNode.number) {
                    flag = true;
                    break;
                }
                tmp = tmp.next;

            }
            if (flag == true) {
                System.out.printf("已经存在%d号节点,不能插入~~\n", headNode.number);
            } else {  //可以插入
                // 将headNode的下一位指向tmp的下一位
                headNode.next = tmp.next;
                //将tmp的下一位指向 headNode,
                tmp.next = headNode;
            }

        }

3.更新删除节点

   1.更新比较简单,不更新编号              2.删除时,一定是找到被删除标号的上一个编号,然后将上一个编号指向下下一个编号即可

        public void update(HeroNode headNode) {
            Boolean flag = false;   //表示是否找到该节点
            HeroNode tmp = HeadNode;
            while (true) {
                if (tmp.next == null) {  //没有数据
                    break;
                }
                if (tmp.next.number == headNode.number) {  //找到
                    flag = true;
                    break;
                }
                tmp = tmp.next;
            }
            if (flag) {
                tmp.next.name = headNode.name;
                tmp.next.nickName = headNode.nickName;
            } else {
                System.out.printf("没有该%d号节点,不能更新~~\n", tmp.number);
}}
         * 删除一个指定节点
        public void delete(int number){
            Boolean flag =false;  //表示是否找到该节点
            HeroNode tmp = HeadNode;

            while (true){
                if (tmp.next==null){
                    break;
                }
                if (tmp.next.number==number){  //找到该编号的上一个节点
                    flag=true;
                    break;
                }
                tmp = tmp.next;
            }

            if (flag){
                tmp.next = tmp.next.next;
            }else {
                System.out.printf("不存在该%d号节点\n",number);
}}}