链表的实现

1. 简单的实现了链表的初始化
2. 添加数据
3. 删除链表第index个节点
4. 返回链表长度，打印链表
5. 从尾到头输出单链表，采用递归方式实现
6. 采用快慢指针的方式查找单链表的中间节点，快指针一次走两步，慢指针一次走一步
7. 当快指针走完时，慢指针刚好到达中间节点

package Link;

/*
 * 链表的实现
 */
public class Link {
	//初始化链表
	ListNode head = null;
	    public class ListNode {
	        int val;
	        ListNode next = null;
	
	    public ListNode(int val) {
	            this.val = val;
	        }
	    }
	
	    //向链表添加数据
	    public void addNode(int d) {
	    	ListNode node = new ListNode(d);
	    	if(head == null) {
	    		head = node;
	    		return;
	    	}
	    	ListNode tmp = head;
	    	while(tmp.next != null) {
	    		tmp = tmp.next;
	    	}
	    	tmp.next = node;
	    }
	
	    //删除链表第index个节点
	    public boolean delNode(int index) {
	    	if(index < 1 || index > length()) {
	    		return false;
	    	}
	    	if(index == 1) {
	    		head = head.next;
	    	}
	    	int i = 1;
	    	ListNode preListNode = head;
	    	ListNode curListNode = preListNode.next;
	    	while (curListNode != null) {
	            if (i == index-1) {
	            	preListNode.next = curListNode.next;
	                return true;
	            }
	            preListNode = curListNode;
	            curListNode = curListNode.next;
	            i++;
	        }
			return false;
	    }
	    
	    //返回链表长度
	    public int length() {
	    	int length = 0;
	    	ListNode tmp = head;
	    	while(tmp != null) {
	    		length++;
	    		tmp = tmp.next;
	    	}
	    	return length;
	    }
	    
	    //打印链表
	    public void printList() {
	    	ListNode tmp = head;
	        while (tmp != null) {
	            System.out.println(tmp.val);
	            tmp = tmp.next;
	        }
	    }
	    
	    //从尾到头输出单链表，采用递归方式实现
	    public  void printListReversely(ListNode list) {
	    	if(list != null) {
	    		this.printListReversely(list.next);
	    		System.out.println(list.val);
	    	}
	    }
	    
	    //采用快慢指针的方式查找单链表的中间节点，快指针一次走两步，慢指针一次走一步，当快指针走完时，慢指针刚好到达中间节点
	    public ListNode SearchMid(ListNode head) {
	    	ListNode p = this.head, q = this.head;
	        while (p != null && p.next != null && p.next.next != null) {
	            p = p.next.next;
	            q = q.next;
	        }
	        System.out.println("Mid:" + q.val);
	        return q;
	    }
	    
	    public static void main(String[] args) {
	    	Link list;
	    	list = new Link();
	        list.addNode(51);
	        list.addNode(32);
	        list.addNode(1);
	        list.addNode(2);
	        list.addNode(55);
	        list.addNode(36);
	        System.out.println("linkLength:" + list.length());
	        System.out.println("head.data:" + list.head.val);
	        list.printList();
	        list.delNode(2);
	        System.out.println("After deleteNode:");
	        list.printList();
	       // list.printListReversely(list.head);
	       // list.SearchMid(list.head);
	        list.ReverseList(list.head);
	    }
}