链表简介

1.链表(LinkedList)介绍

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

• 链表是以节点的方式来存储,是链式存储
• 每个节点包含 data 域， next 域:指向下一个节点.
• 如图:发现链表的各个节点不一定是连续存储.
• 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
  单链表(带头结点) 逻辑结构示意图如下
  

2.单链表应用

2.1一个例子

使用带 head 头的单向链表实现：Person(String no,String name) 的增删改查等操作

2.1.1添加

1.先创建一个head头节点，作用就是表示单链表的头
2.每添加一个节点newNode，先遍历到指定的位置上一个位置pre和当前元素curr。然后pre.next = newNode;newNode.next = curr;

2.1.3删除

1.找到要删除节点上一个节点pre，下一个节点follow
2.pre.next = follow，剔除当前元素

2.1.4改

遍历到元素修改值即可

2.1.5遍历

略

2.1.6反转

1. 从前向后遍历，分别记录下pre、curr、follow元素
2. curr.next = pre; 然后将follow当成 curr元素，如此循环
3. 如果是头元素curr，则设置头元素的curr.next=null
4. 如果是到末尾curr，则设置末元素head = curr
   代码如下

/**
     * 1.反转  ， 常规手段
     */
    public void reverse() {
        if (isEmpty() || size == 1) {
            return;
        }

        Node pre = head;
        Node curr = head.next;
        Node follow;
        pre.next = null;

        while (curr.next != null) {
            follow = curr.next;
            curr.next = pre;

            pre = curr;
            curr = follow;
        }

        head = curr;
        head.next = pre;
    }

    /**
     * 2.递归手段
     */
    public void reverse1() {
        if (isEmpty() || size == 1) {
            return;
        }

        reverse1(head, head.next);
    }

    private void reverse1(Node pre, Node curr) {
        // 退出递归条件
        if (curr.next == null) {
            curr.next = pre;
            head = curr;
            return;
        }

        reverse1(curr, curr.next);

        curr.next = pre;
        pre.next = null;
    }

    /**
     * 3.头插法，新建一个链表，在头部插入
     */
    public void reverse2() {
        if (isEmpty() || size == 1) {
            return;
        }

        Node newHead = new Node(null); // 新链表头部
        Node curr = head;   // 老链表当前值
        Node tmp = curr.next;  // 存放老链的下一个值
        curr.next = null;

        while (curr != null) {
            curr.next = newHead.next;
            newHead.next = curr;

            curr = tmp;
            if (tmp != null) {
                tmp = tmp.next;
            }
        }

        head = newHead.next; // 换一下头
        newHead.next = null; // 去掉原来的头引用

    }

    /**
     * 4.栈手段，相较递归更好理解
     */
    public void reverse3() {
        if (isEmpty() || size == 1) {
            return;
        }

        Stack<Node> stack = new Stack<>();
        Node curr = head;
        while (curr != null) {  // 全部压入栈
            stack.push(curr);
            curr = curr.next;
        }

        head = stack.pop(); // 从栈顶取数，然后改变指向即可
        Node tmp = head;   // 临时变量，用于存储新链表链尾数据

        while (true) {
            Node node = stack.pop();
            tmp.next = node;
            tmp = node;   // 此时出现了互指的情况，栈里面的元素.next指向tmp，而tmp.next又指向栈里面的元素，debug的时候提示outofmemory，但是最终能执行，可以通过多设置一个变量的方式来解决，此处不做优化

            if (stack.isEmpty()) {
                // 如果当前是最后一个，改变其next为null
                node.next = null;
                break;
            }
        }
    }

代码参考

3.双向链表

3.1双向链表的操作分析和实现

管理单向链表的缺点分析:

1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2. 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除 时节点，总是找到 temp,temp 是待删除节点的前一个节点
3. 分析了双向链表如何完成遍历，添加，修改和删除的思路
   
   对上图的说明:

1. 遍历 方和 单链表一样，只是可以向前，也可以向后查找
2. 添加 (默认添加到双向链表的最后)

• 先找到双向链表的最后这个节点
• temp.next = newHeroNode
• newHeroNode.pre = temp;

3. 修改 思路和 原来的单向链表一样.
4. 删除

• 因为是双向链表，因此，我们可以实现自我删除某个节点
• 直接找到要删除的这个节点，比如 temp
• temp.pre.next = temp.next
• temp.next.pre = temp.pre;

代码参考

4.单向环形链表

4.1一个需求

Josephu 问题为:设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k(1<=k<=n)的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此 产生一个出队编号的序列

4.2 单向环形链表

4.3.Josephu 问题解法

代码参考 代码测试