Java数据结构---链表_java 链表 csdn-CSDN博客

public class MYsingleList {

    static class ListNode   {
        public int val; //存储的数据
        public ListNode next; //存储下一个节点的地址

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head; // 代表当前链表的头节点的引用

    public void createLink() {
        ListNode listNode1 = new ListNode(12);
        ListNode listNode2 = new ListNode(12);
        ListNode listNode3 = new ListNode(23);
        ListNode listNode4 = new ListNode(90);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        head = listNode1;

}

因为我们写的是不带头的单链表,不知道头在哪里,通过定义一个head变量来引用当前链表的头节点,这样一来,head引用那个节点,就代表那个节点是头节点.而且我们在存储数据的时候不知道存储的下一个数据是什么,所以我们给一个 public ListNode(int val) 的构造方法,只用来存储数据.

1. 遍历链表

1. cur = head 如果我们在遍历链表的时候让head != null 那么当我们遍历完成时head为null,所以我们定义一个cur,让cur去完成遍历

2. 通过cur = cur.next让链表往后遍历

2. 判断关键字key是否存在链表中

3.得到链表的长度

4. 头插法

1. 在插入的时候首先要有一个节点,我们就需要实例化一个节点

2.采用头插法插入到链表的头部,新的节点就就是头结点

3. 插入完成后

5. 尾插法

在我们插入前要判断链表当中是否有数据,如果没有数据,直接让头节点= 要插入的节点,否则会发生空指针异常

6, 任意位置插入

插入前

插入后

1. 当index = 0时,相当于头插法,当Index = size( )相当于尾插法

2. 当index < 0 或者 index > size( )时插入的位置不合法,

3. 当index合法时,找插入的位置,我们让cur走到index - 1位置的节点的位置

 public void addIndex(int index, int data) throws ListIndexOutOfException {
        checkIndex(index);
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = findIndexSubOne(index);
        ListNode listNode = new ListNode(data);
        listNode.next = cur.next;
        cur.next = listNode;

    }

    // 找到 index - 1 位置的节点的位置
    private ListNode findIndexSubOne(int index) {
        ListNode cur = head;
        int count = 0;
        while (count != index - 1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

    //查看是否合法
    private void checkIndex(int index) throws ListIndexOutOfException {
        if (index < 0 || index > size()) {
            throw new ListIndexOutOfException("index位置不合法");
        }
    }

异常

7. 删除第一次出现关键字为key的节点

1. 我们的链表是单向的,如果我们直接找到要删除的节点,我们节不能知道前一个节点是什么,可以通过cur.next.val找到要删除节点的前一个节点

2. 当 cur.next == null 的时候,说明没有要删除的节点

3. 当删除的是头节点的时候直接让 head = head.next

8. 删除所有值为key的节点

1. 让 cur 从第二个节点开始遍历, prev 是cur的前驱节点,当 cur.val == key 时 prev.next = cur. next, curr = cur.next. 否则我们让cur继续遍历 prev = cur, cur = cur.next.( 同时让prev和cur往后走 )

2. 当cur遍历完整个链表的时候,我们会发现第一个节点没有遍历,新链表的头节点和原来的头节点是同一个节点,当 head.val == key时,head= head. next.这样头节点也是要被删除的节点的情况就会解决

9. 清空所有节点

链表是由一个一个节点组成的,有一个next域指向下一个节点,如果我们直接把头节点干掉.那就没有节点继续指向下一个节点,就实现了清空所有节点

快慢指针

题目一: 链表的中间节点

1. 我们定义fast 和slow 两个节点都指向头节点,,让fast和slow同时往后走,fast每次走两步,slow每次走一步,当fast在终点的时候,slow在中间位置

2. 当链表的个数是奇数个时,当fast == null的时候,slow恰好在中间位置.

3. 当链表的个数是偶数个时,当fast.next == null时,slow恰好在中间位置

4. 循环结束的条件: fast != null && fast.next != null. 当写成fast.next != null && fast != null时会发生空指针异常