数据结构——链表

链表（Linked List）

一种线性数据结构，其中的每个元素都是一个节点对象。各个节点通过“引用”（指针）相连接，引用中记录了下一个节点的内存地址，通过其可以定位并访问到下一个节点。

链表对比数组有更好的灵活性，数组要求内存空间是连续的，但当数组非常庞大时，可能无法提供那么大的连续空间，同时数据量庞大的数组除了对其进行查找操作外，其余操作都非常耗费资源，这时链表的灵活性就体现出来了。

 如图所示，链表的结构如图。故而在相同数据量下，链表比数组要占据更多的内存空间，而链表的增删操作在时间复杂度O（1），数组为O（n）。这是典型的空间换时间的设计。

对于链表的基本操作如下（单链表介绍）

 

class ListNode {
    int val;
    ListNode next;
    ListNode(int x){
        val = x;
    }
}
public class LinkList {
    public static void main(String[] args){

        Scanner in = new Scanner(System.in);
        //初始化链表
        ListNode n0 = new ListNode(1);//头节点，整个链表的代称，该链表可记作n0
        ListNode n1 = new ListNode(3);
        ListNode n2 = new ListNode(2);
        ListNode n3 = new ListNode(4);
        ListNode n4 = new ListNode(5);
        n0.next = n1;
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;

        ListNode HeadNode = n0;
        //遍历链表
        showList(HeadNode);

        //插入节点
        HeadNode = insert(HeadNode,1,new ListNode(6));

        showList(HeadNode);

//        HeadNode = deleteList(HeadNode,3);
//        showList(HeadNode);
//
//        int target = in.nextInt();
//        System.out.println("值为"+target+"的索引为"+findNode(HeadNode,target));

        alterList(HeadNode,3,7);
        showList(HeadNode);

    }

    //指定位置插入节点
    public static ListNode insert(ListNode headnode,int n,ListNode p){
        ListNode temp = headnode;
        if ( n == 1) {
            p.next = headnode;
            headnode = p;
            return headnode;
        }
        for (int i = 1; i < n-1; i++) {
            if (temp.next == null){
                temp.next = p;
            }
            temp = temp.next;
        }
        p.next = temp.next;
        temp.next = p;
        return headnode;
    }

    public static void showList(ListNode headnode){
        for (ListNode node=headnode; node != null ; node = node.next) {
            if (node.next == null){
                System.out.print(node.val+"\n");
            }else
                System.out.print(node.val+"->");
        }
    }

    public static ListNode deleteList(ListNode headnode,int n){
        ListNode temp = headnode;
        if (n == 1) {
            headnode = headnode.next;
            return headnode;
        }
        for (int i = 1; i < n-1; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
        return headnode;
    }

    public static int findNode(ListNode headnode,int target){
        int index = 1;
        while(headnode!=null){
            if (headnode.val == target)
                return index;
            headnode = headnode.next;
            index++;
        }
        return index;
    }

    public static void alterList(ListNode HeadNode,int index,int n){
        for (int i = 1; i < index ; i++) {
            HeadNode = HeadNode.next;
        }
        HeadNode.val = n;
    }
}

其实对于链表的操作而言，难点在于“节点”的定位，所有函数中都使用临时指针来进行操作，可以把其当成数组的索引（下标）。

比如在插入节点操作中，其难点就在于要定位至要插入位置的前一个节点，也就是说要临时指针指向插入位置的前一个节点。

还有一个小问题我纠结了好久，就是在初学时不同资料在遍历定位时使用HeadNode或者HeadNode.next，其实这很无所谓，只要搞明白你要使用什么去操作，习惯用节点就使用HeadNode，习惯放弃头节点而专注于HeadNode.next就用HeadNode.next。

对于环形链表和双向链表而言，其操作的核心思想和单链表大同小异。在环形链表中，难点除了上面提到的，便是对于“头节点”的定位，环形链表中，为了不迷路，方便操作，最好使用一个指针指定一个节点作为“头节点”，也就是要指定一个方向标！而双向链表更加简单，仅仅只是在定义节点时要加上前驱指针，同时操作时也要考虑前驱节点。

数组VS链表