数据结构——链表

链表

定义：

由结点构成，开始于头结点，止于指向NULL的指针。

分类：

1.单向链表；
2.双向链表；
3.循环链表；

详解：

1.单向链表：

(1)图解:

(2)头结点概述：

			①数据域无意义（可存放链表长度）；
			②可操作在第一个结点前的插入与删除；
			③非必要元素；

(3)单链表的创建：

(4)代码实现：

<1>LinkList属性及构造方法：

//头结点：
    private Node head;
    //长度:
    private int length;
    
    //构造方法(链表初始化)：
    public _LinkList(){
        head = new Node(null,null);
        length = 0;
    }

<2>结点的内部类Node：

//内部结点类Node:
    private class Node{
        //数据域：
        public T item;
        //指针域：
        public Node next;

        //构造方法：
        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
    }

<3>清空列表方法：

//清空链表：
    public void clear(){
        head.next = null;
        length = 0;
    }

<4>判断是否为空：

//判断是否为空：
    public boolean isEmpty(){
        if (length == 0)  return true;
        return false;
    }

<5>获取链表长度：

//获取链表长度：
    public int getLength(){
        return length;
    }

<6>获取第j个位置的元素：

//获取第j个位置的元素：
    public T getElement(int j){
        Node n = head;
        for (int i = 0;i < j;i++){
            n = n.next;
        }
        return n.item;
    }

<7>在位置j插入元素：

//向j处添加元素：
    public void insert(int j,T insertElement){
        Node n = head;
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        n.next = new Node(insertElement,null);
        length++;
    }

<8>删除位置j处的元素并返回删除元素：

//删除j处的元素：
    public T delete(int j){
        Node n = head;
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        T deleteElement = n.next.item;
        n.next = n.next.next;
        length--;
        return deleteElement;
    }

<9>查找元素第一次出现的位置：

//查找元素第一次出现的位置
    public int selectIndex(T selectElement){
        int j = 0;
        Node n = head;
        while(n.next!=null){
            n = n.next;
            j++;
            if (n.item.equals(selectElement)){
                return j;
            }
        }
        return -1;
    }

<10>遍历链表:

//遍历链表：
    public void Iteration(){
        Node n = head;
        while(n.next!=null){
            n = n.next;
            System.out.println(n.item);
        }
    }

2.双向链表：

(1)图解:

(2)双向链表的创建：

(3)代码实现：

<1>LinkList属性与构造方法：

//头结点：
    private Node head;
    //尾结点：
    private Node last;
    //链表长度：
    private int length;
    
    //构造方法：
    public DoubleLinkList(){
        head = null;
        last = null;
        length = 0;
        }

<2>结点内部类Node：

//内部类Node
    private class Node{
        //数据域：
        public T item;
		//前一个结点：
        public Node pre;
		//后一个结点：
        public Node next;
        
        //构造方法：
        public Node(T item,Node pre,Node next){
            this.item = item;
            this.pre = pre;
            this.next = next;
        }
    }

<3>向位置j处插入元素：

//向位置j处添加元素：
    public void insert(int j,T insertValue){
        Node n = head;
        //得到前一个元素：
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        //创建处新结点：
        Node newNode = new Node(insertValue,n,n.next);
        //修改后一个元素的前置位：
        n.next.pre = newNode;
        //修改前一个元素的后置位：
        n.next = newNode;
        //长度+1：
        length++;
    }

<4>删除位置j处的元素：

//删除位置j的元素：
    public void remove(int j){
        Node n = head;
        //找到前一个元素：
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        //修改后一个的pre属性：
        n.next.next.pre = n;
        //修改前一个的next属性：
        n.next = n.next.next;
        //链表长度-1：
        length--;
    }

<5>获取首位元素与末尾元素：

	//获取首个元素：
    public T firstElement(){
        if (isEmply()==true) return null;
        return head.next.item;
    }
    //----------------------------------------------------------------
	//获取末尾元素：
    public T lastElement(){
        if (isEmply()==true)  return null;
        return last.item;
        }

3.链表的应用：

(1)单向链表的反转：

方法递归思想
类比盗梦空间的多层梦境：

当链表中有三个元素时：
第一层：（该层中，curr是原第一个元素）
{
reserve()传入第一个元素head.next;
第二层：(该层中，curr是原第二个元素)
{
reserve()传入第二个元素curr.next;
第三层：(该层中，curr是原第三个元素)
{
reserve()传入第三个元素curr.next;
进入if条件语句块(第三个元素是最后一个元素)，将第三个元素赋值给头 结点的下一个(即第一个元素位置)，返回第三个元素结点(即为新的第一个结点)给第二层；
第三层结束
}
新的首结点newHead的下一个改为第二个元素。（本例中第二个不变）
第二个元素的下一个(新的第三个元素)为null；
返回第二个元素给第一层；
第二层结束
}
将第二个结点的下一个（新的尾结点）赋值为原第一个结点；
尾结点的下一个赋值为null；
第一层结束
得到新的链表为反转链表。
}

	//反转整个链表：
    public void reverse(){
        if (isEmpty())   return;
        reverse(head.next);
    }
    //反转一对结点：
    public Node reverse(Node curr){
        //如果判断是最后一个：
        if (curr.next == null){
            head.next = curr;
            return curr;
        }
        //返回值是反转后当前结点的上一个结点；
        Node newHead = reserve(curr.next);
        newHead.next = curr;
        curr.next = null;
        return curr;
    }

(2)快慢指针：

概述：快指针一次移动两个或者多格，慢指针一次移动一格。

<1>中间值问题：

		//得到中间值的方法：
        public static String getMid(Node <String> first){
            //设置快慢指针：
            Node<String> fast = first;
            Node<String> slow = first;
            //遍历循环链表，当快指针到链表尾部的时候，慢指针所指为中间值：
            while (fast.next!=null){
                fast = fast.next.next;
                slow = slow.next;
            }
            //返回中间值：
            return slow.item;
        }

<2>是否有环问题：

解法思路：设置快慢指针，当快慢指针相遇，证明链表有环。

	//判断是否存在闭环的方法：
    public static boolean isCircle(Node<Integer> first){
        //定义快慢指针：
        Node<Integer> fast = first;
        Node<Integer> slow = first;
        //循环遍历链表，当快慢指针指在相同位置时说明存在闭环：
        while(fast != null&&fast.next!=null){
           fast = fast.next.next;
           slow = slow.next;
           if (slow.equals(fast)){
               return true;
           }
        }
        return false;

    }

<3>求解有环链表入口问题：

解法思路：设置快慢指针，当快慢指针相遇时，引入新指针，移动速度与慢指针相同，当慢指针与新指针相遇时，该位置即为换的入口。

	//找闭环入口的方法：
    public static Node getEntrance(Node<Integer> first){
        //创建快慢指针与临时判断指针：
        Node<Integer> fast = first;
        Node<Integer> slow = first;
        Node<Integer> flag = null;
        //遍历链表，当闭环存在时，
        while (fast != null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast.equals(slow)){
                //当存在闭环的时候，引入临时指针flag
                flag = first;
                continue;
            }
            if (flag != null){
                flag = flag.next;
                if (flag.equals(slow)){
                    break;
                }
            }
        }
        return slow;
    }

完！