《算法通关村第一关——链表青铜挑战笔记》

 1.理解Java是如何构造出链表的

        

/**
 * 一个简单的链表实例，用于演示JVM怎么构造链表的
 */
public class BasicLink {

    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 6};
        Node head = initLinkedList(a);
        System.out.println(head);
    }

    private static Node initLinkedList(int[] array) {
        Node head = null, cur = null;//置空
        for (int i = 0; i < array.length; i++) {
            Node newNode = new Node(array[i]);
            newNode.next = null;
            if (i == 0) {
                head = newNode;
                cur = newNode;
            } else {
                cur.next = newNode;
                cur = newNode;
            }
        }
        return head;
    }

    static class Node {
        public int val;
        public Node next;

        Node(int x) {
            val = x;
            next = null;
        }
    }



}

       debug

System.out.println(head);

：

 

        小结：注意Node的创建，里面定义了val（值）和next（指针），注意头结点和之后节点的

head和cur的变化。

⒉链表增加元素，首部、中间和尾部分别会有什么问题，该如何处理?
 

// 需要判空，否则后面可能会有空指针异常
        if (head == null) {
            return nodeInsert;
        }
        //越界判断
        int size = getLength(head);
        if (position > size + 1 || position < 1) {//position最多是总长+1，又不能比0小
            System.out.println("位置参数越界");
            return head;
        }

总体上要注意范围。在首部上只要保证新节点指向原节点，再把原来的hea替换给新节点

nodeInsert.next = head;
head = nodeInsert;

        尾部：

     只要保证尾节点指向新指针。

        中间：

 首先循环列表到15这个节点，然后把new的指针指向7这个节点，再把15指针指向new，这里两行代码不能换顺序。因为每个节点只能有一个next指针，若先15指向new，15就有2个next了，所以不行。

Node pNode = head;
        int count = 1;
        while (count < position - 1) {
            pNode = pNode.next;
            count++;
        }
        nodeInsert.next = pNode.next;
        pNode.next = nodeInsert;

3.链表删除元素，首部、中间和尾部分别会有什么问题，该如何处理?
 

首部：

只要将头节点向前移动一次，也就是head(新节点)=head（原头节点).next

 

尾部：

 循环，先找到要删的节点的前一位，把这个节点的指针指向null，即可删除。

中间：

循环，找到要删的节点前一位，并把指针指向要删节点的后一位，即可删除中间节点。

4.双向链表是如何构造的，如何实现元素的插入和删除。

构造：

相比单向节点，多了prev指针，创建头和尾节点first last 。 first=null; last = first; 头节点为空，last变成每次循环后的first节点。

创建：

class DoubleNode {
        public int data;    //数据域
        public DoubleNode next;    //指向下一个结点
        public DoubleNode prev;

        public DoubleNode(int data) {
            this.data = data;
        }

        //打印结点的数据域
        public void displayNode() {
            System.out.print("{" + data + "} ");
        }
    }

private DoubleNode first;
    private DoubleNode last;
    public DoublyLinkList() {
        first = null;
        last = first;
    }

插入：分为头，尾，中。简单阐述：

        头：判断是否之前为空，不为空，将还没插入新节点之前链表的第一个节点的prev指向newNode，再将新节点的next指向原一个节点，最后将新节点赋给first（链接）成为第一个节点。

    public void insertFirst(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (isEmpty()) {
            last = newDoubleNode;
        } else {//如果不是第一个结点的情况
            first.prev = newDoubleNode;    //将还没插入新结点之前链表的第一个结点的previous指向newNode
        }
        newDoubleNode.next = first;        //将新结点的next指向first
        first = newDoubleNode;            //将新结点赋给first（链接）成为第一个结点
    }

         尾部：

同上。差不多

public void insertLast(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (isEmpty()) {
            first = newDoubleNode;        //若链表为空，则将first指向新的结点（newNode）
        } else {
            newDoubleNode.prev = last;//将last的previous指向last（last永远指向的是最后一个结点）【此时还没有插入新的结点newNode，所以last指向的是当前链表的最后一个结点】
            last.next = newDoubleNode;    //将last.next(当前链表最后一个结点的next域)指向新的结点newNode
        }
        last = newDoubleNode;                //由于插入了一个新的结点，又因为是尾部插入，所以将last指向newNode
    }

        中间：

 

顺序：先右边，再左边。

newNode左边是cur，右边是cur.next ，遇到时，画这个图，按顺序写出这4行就成了。

具体实现，看代码

public void insertAfter(int key, int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        DoubleNode current = first;
        while ((current != null) && (current.data != key)) {
            current = current.next;
        }
        //若当前结点current为空
        if (current == null) {                    //current为null有两种情况 一种是链表为空，一种是找不到key值
            if (isEmpty()) {                    //1、链表为空
                first = newDoubleNode;                //则插入第一个结点（其实可以调用其它的Insert方法）
                last = newDoubleNode;                    //first和last均指向该结点（第一个结点）
            } else {
                last.next = newDoubleNode;        //2、找不到key值
                newDoubleNode.prev = last;    //则在链表尾部插入一个新的结点
                last = newDoubleNode;
            }
        } else {
            if (current == last) {                    //第三种情况，找到了key值，分两种情况
                newDoubleNode.next = null;            //1、key值与最后结点的data相等
                last = newDoubleNode;                    //由于newNode将是最后一个结点，则将last指向newNode
            } else {                                    //2、两结点中间插入
                current.next.prev = newDoubleNode;    //将current当前结点的下一个结点赋给newNode.next
                newDoubleNode.next = current.next;     //将新节点指针指向current当前结点的下一个结点                                                                                                                               四
            }                                        //将current下一个结点即current.next的previous域指向current
            current.next = newDoubleNode;                    //将当前结点的next域指向newNode
            newDoubleNode.prev = current;                //将新结点的previous域指向current（current在newNode前面一个位置）

        }

    }

删除：首部 尾部 中间

        首部：

2个以上的节点，首节点的下一个的prev指向空，就把原节点断开了，将first.next赋给first

//从头部删除结点
    public DoubleNode deleteFirst() {
        DoubleNode temp = first;
        if (first.next == null) {            //若链表只有一个结点，删除后链表为空，将last指向null
            last = null;
        } else {
            first.next.prev = null;        //若链表有两个（包括两个）以上的结点 ，因为是头部插入，则first.next将变成第一个结点，其previous将变成null
        }
        first = first.next;                //将first.next赋给first
        return temp;                    //返回删除的结点
    }

         尾部：

  

public DoubleNode deleteLast() {
        DoubleNode temp = last;
        if (first.next == null) {        //如果链表只有一个结点，则删除以后为空表,last指向null
            first = null;
        } else {
            last.prev.next = null;    //将上一个结点的next域指向null
        }
        last = last.prev;            //上一个结点称为最后一个结点，last指向它
        return temp;                    //返回删除的结点
    }

              中间：

先动prev 再动next

public DoubleNode deleteKey(int key) {
        DoubleNode current = first;
        while (current != null && current.data != key) {        //遍历链表寻找该值所在的结点
            current = current.next;
        }
        if (current == null) {                        //若当前结点指向null则返回null，
            return null;                        //两种情况当前结点指向null，一是该链表为空链表，而是找不到该值
        } else {
            if (current == first) {                //如果current是第一个结点
                first = current.next;            //则将first指向它，将该结点的previous指向null,其余不变
                current.next.prev = null;
            } else if (current == last) {            //如果current是最后一个结点
                last = current.prev;        //将last指向当前结点的上一个结点（我们将当前结点除名了以后它便不再是最后一个了）
                current.prev.next = null;    //相应的要删除结点的上一个结点的next域应指向null
            } else {
                current.next.prev = current.prev;    //当前结点的下一个结点的previous域应指向当前结点的上一个结点
                current.prev.next = current.next;        //当前结点的上一个结点的next域应指向当前的下一个结点

            }
        }
        return current;        //返回
    }

总结：

        这是新的开始，之前或多或少接触过并学习过数据结构和算法，但都过于浅显了，这次，我会抓住机会和时间，全力付诸于此，这是第一课，了解了链表的增删遍历，创建。值得好好消化。让我记住了，勤画图，注意范围限制，注意代码的优雅，等等。之后的学习也要加油！！！！