关于链表的学习

 前言：

    在java内部提供了list、set、map等数据类型，链表常用的有ArrayList和LinkedList，它们二者的区别在于：

• ArrayList实现了随机访问（RandomAccess）的接口，基于动态数组；LinkedList实现了队列（Quene）的接口，基于链表的数据结构。
• ArrayList适合随机读取，可以一步get(index)，但是添加数据的时候就会很慢，如果添加到中间位置，要依次移动后面的数据；而LinkedList添加数据很方便，只需要更改这个数据前后的指针就能添加到链表中去，但是读取速度会很慢，要依次查询。
• ArrayList的扩容方式采用oldSize*3/2+1，相当于只要容量不足就要增加1/2的容量；LinkedList采用动态链接，除此之外还有的是数组的容量固定不可改变，且存储在连续存储区域。
• 实现栈和队列方面，LinkedList要优于ArrayList。增删操作LinkedList开销一致比ArrayList更好。

        当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

   下面记录一下LinkedList实现栈和队列的操作细节：（记录只为更好的学习~~）

import java.util.*;

class Stack{
    private LinkedList list;
    public Stack(){
        list=new LinkedList();
    }
    
    public Object top(){   //输出最上面的元素
        if(list.size()!=0){
            return list.getFirst();
        }
        return -1;
    }
    
    public void pop(){   //出栈
        if(list.size()!=0){
            list.removeFirst();
        }
    }
    
    public void push(Object v){ //入栈
        list.addFirst(v);
    }
    
    public int getLen(){
        return list.size();
    }
}

   再记录一下利用ArrayList处理斐波拉契数列的问题：

import java.util.ArrayList;
import java.util.Scanner;
 
/**
 * Created by ygh.
 */
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(0);  //斐波拉契数列头两个元素是0和1
        list.add(1);
        Scanner sc = new Scanner(System.in); 
        while (sc.hasNext()) {
            int n = sc.nextInt();   // 表示查询斐波拉契数列的第n个元素
            if (n >= list.size()) {   
                for (int i = list.size(); i <= n; i++) {
                    list.add(list.get(i - 2) + list.get(i - 1));   //依次遍历增加元素到list里，结果为前两个元素相加
                }
            }
            System.out.println(list.get(n));  //打印当前元素
        }
    }
}

 

下面进入重点：

      在平时编程中会用到自定义的链表，这时就要面向对象了，哈哈~。构建Node节点类，利用对象的指针进行链表的连接来实现自定义链表。下面是自定义的链表类：

 public class ListNode{  
        int value;  
        ListNode next;  

        public ListNode(int value){  
            this.value=value;  
            this.next=null;  
        }  
    }  

    比如说要实现查找链表中倒数第k个结点，直接上代码：

 public ListNode FindKthToTail(ListNode head,int k) {
       if(head==null||k<=0)return null;
           ListNode nodePre=head;    //两个指针都指向头结点
           ListNode nodeLast=head;
            
           for(int i=1;i<k;i++){
               if(nodePre.next!=null)nodePre=nodePre.next;
               else return null;
           }
            
           while(nodePre.next!=null){
               nodePre = nodePre.next;
               nodeLast=nodeLast.next;
           }
           return nodeLast;
    }

    要说一下，这里查找倒数第k个节点是采用两个指针，第一个先往前读，直到到了第k-1个元素时停止，第二个还在头节点，这时他们相距k-1的距离，然后就让它们一起向前读，直到第一个读到链表的末尾，就停止操作，此时第二个的指针指向的就是倒数第k个结点，是不是很机智，嘿嘿~~

    也可以采用先遍历出链表长度n，再重新走到第n-k+1个元素的位置，这也可以找出倒数第k个结点：

public ListNode FindKthToTail(ListNode head,int k) {
        ListNode p,q;
        q=head;
        p=head;
        int count=0;
        if(p==null){
            return null;
        }
        while(p.next!=null){
            p=p.next;
            count++;
        }
        if(k>(count+1)){
            return null;
        }
        else{
           for(int i=0;i<=(count-k);i++){
                q=q.next;
            }
        }
        return q;
    }

    还有一些链表操作的方法，感受下~   不论是什么都要举一反三，没有固定不变的，这只是给自己提供一种解决问题的好思路。

比如：

•  查找单链表的中间结点  

public static Node getMiddleNode(Node head){  
        if(head==null||head.next==null)return head;  
        Node target=head;  
        Node temp=head;  
        while(temp!=null&&temp.next!=null){  
            target=target.next;  
            temp=temp.next.next;  
        }  
        return target;  
    }  

• 合并两个有序的单链表head1和head2（采用循环的方式）

public static Node mergeSortedList(Node head1,Node head2){  
        if(head1==null)return head2;  
        if(head2==null)return head1;  
        Node target=null;  
        if(head1.value>head2.value){  
            target=head2;  
            head2=head2.next;  
        }  
        else{  
            target=head1;  
            head1=head1.next;  
        }  
        target.next=null;  
        Node mergeHead=target;  
        while(head1!=null && head2!=null){  
            if(head1.value>head2.value){  
                target.next=head2;  
                head2=head2.next;  
            }  
            else{  
                target.next=head1;  
                head1=head1.next;  
            }  
            target=target.next;  //指针向后移
            target.next=null;  
        }  
        if(head1==null)target.next=head2;  
        else target.next=head1;  
        return mergeHead;  
    }  

• 合并两个有序的单链表head1和head2（采用递归的方式）

 public static Node mergeSortedListRec(Node head1,Node head2){  
        if(head1==null)return head2;  
        if(head2==null)return head1;  
        if(head1.value>head2.value){  
            head2.next=mergeSortedListRec(head2.next,head1);  
            return head2;  
        }  
        else{  
            head1.next=mergeSortedListRec(head1.next,head2);  
            return head1;  
        }  
    }  

其他的比如排序的方法等详见博客：http://blog.csdn.net/kerryfish/article/details/24043099

（完）

                                                                                                              By  Still、