数据结构和算法学习：链表

链表

链表是有序的列表，但是它在内存中是存储如下

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

单链表

单链表(带头结点) 逻辑结构示意图如下

代码实现

class SingleLinkedList{
    //设置头结点
    HeroNode heroNode = new HeroNode(0);
    //添加节点到单向链表
    //思路，当不考虑编号顺序时
    //1. 找到当前链表的最后节点
    //2. 将最后这个节点的next 指向 新的节点
    public void add(HeroNode newheroNode){
        //因为是头结点不能动，所以定义一个辅助节点
        HeroNode temp = heroNode;
        //找到最后一个节点
        while (true){
            //找到链表的最后
            if(temp.next == null){
                break;
            }
            //如果没有找到最后, 将将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next 指向 新的节点
        temp.next = newheroNode;
    }

    //删除节点
    //思路
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2. 说明我们在比较时，是temp.next.no 和  需要删除的节点的no比较
    public void del(int no) {
        //因为头结点不能动，定义一个辅助节点
        HeroNode temp = heroNode;
        //定义一个变量判断是否找到了需要删除的节点
        boolean flag = false;
        while (true){
            if(temp.next ==null){
                System.out.println("未找到需要删除的节点");
                return ;
            }
            if(temp.next.no == no){
                flag = true;
                break;
            }
            //后移
            temp = temp.next;
        }
        if(flag){
            temp.next = temp.next.next;
        }
    }

    //显示链表[遍历]
    public void list(){
        //判断链表是否为空
        if(heroNode.next == null){
            System.out.println("链表为空");
            return;
        }
        //定义一个辅助节点，头结点不能动
        HeroNode temp = heroNode.next;
        while (true){
            if(temp==null){
                return;
            }
            System.out.println("节点"+temp);
            temp = temp.next;
        }

    }

}

//节点
class HeroNode{
    public int no;
    public HeroNode next;
    public HeroNode(int no){
        this.no = no;
    }
    public int getNo() {
        return no;
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                '}';
    }
}

测试

public class SingleLinkedListDemo {
    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);
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //添加节点
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        //查看节点
        singleLinkedList.list();
        //删除节点
        singleLinkedList.del(2);
        //查看节点
        singleLinkedList.list();
    }
}

单向链表的缺点分析

1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2. 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点

双向链表

双向链表也是链表的一种，它每个数据结点中都有两个结点，分别指向其直接前驱和直接后继。所以我们从双向链表的任意一个结点开始都可以很方便的访问其前驱元素和后继元素。

代码实现

class  DoubleLinkedList{
    //定义头结点
    DoubleHeroNode head = new DoubleHeroNode(0);


    // 遍历双向链表的方法
    // 显示链表[遍历]
    public void list(){
        if(head.next ==null){
            System.out.println("链表为空");
            return ;
        }
        //定义一个辅助节点，接受头结点
        DoubleHeroNode temp = head.next;
        while (true){
            if(temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
    //添加一个节点到双向链表的最后.
    public void add(DoubleHeroNode newDoubleHeroNode){
        //头结点不能动，定义一个辅助节点
        DoubleHeroNode temp = head;
        while (true){
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        newDoubleHeroNode.pre = temp;
        temp.next = newDoubleHeroNode;
    }
    // 从双向链表中删除一个节点,
    // 说明
    // 1 对于双向链表，我们可以直接找到要删除的这个节点
    // 2 找到后，自我删除即可
    public void del(int no){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return ;
        }
        //定义一个辅助节点，接受头结点
        DoubleHeroNode temp = head;
        //记录删除的节点是否存在
        boolean flag = false;
        while (true){
            if(temp.next == head){
                return;
            }
            if(temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.next.next.pre = temp;
            temp.next = temp.next.next;
        }
    }
}
class DoubleHeroNode{
    public int no;
    //下一个节点
    public DoubleHeroNode next;
    //上一个节点
    public DoubleHeroNode pre;
    public DoubleHeroNode(int no) {
        this.no = no;
    }
    public DoubleHeroNode getNext() {
        return next;
    }
    public DoubleHeroNode getPre() {
        return pre;
    }
    @Override
    public String toString() {
        return "DoubleHeroNode{" +
                "no=" + no +
                '}';
    }
}

测试

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        DoubleHeroNode doubleHeroNode1 = new DoubleHeroNode(1);
        DoubleHeroNode doubleHeroNode2 = new DoubleHeroNode(2);
        DoubleHeroNode doubleHeroNode3 = new DoubleHeroNode(3);
        DoubleHeroNode doubleHeroNode4 = new DoubleHeroNode(4);
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        //添加
        doubleLinkedList.add(doubleHeroNode1);
        doubleLinkedList.add(doubleHeroNode2);
        doubleLinkedList.add(doubleHeroNode3);
        doubleLinkedList.add(doubleHeroNode4);
        //查
        doubleLinkedList.list();
        //删除
        doubleLinkedList.del(2);
        //查
        doubleLinkedList.list();
    }
}