/**
	 * 連結串列節點定義
	 *
	 */
	private class Node {
		private Object data;
		private Node next;

		public Node getNext() {
			return next;
		}

		public void setNext(Node next) {
			this.next = next;
		}

		public Node(Object data) {
			this.data = data;
		}
	}

	private Node head;
	private int size;

	public LinkedListOnePoint() {
		head = null;
		size = 0;
	}

	public boolean isEmpty() {
		return size == 0 ? true : false;
	}

	public int size() {
		return size;
	}

	public Object headNode() {
		if (size == 0) {
			return null;
		}
		return head.data;
	}

	/**
	 * 在連結串列表頭插入一個節點（入棧）
	 * 
	 * @param obj
	 */
	public void insertInHead(Object obj) {
		Node node = new Node(obj);
		if (size == 0) {
			head = node;
		} else {
			node.next = head;
			head = node;
		}
		size ++;
	}

	/**
	 * 刪除連結串列表頭節點（出棧）
	 * @return
	 */
	public Object deleteHeadNode() {
		if (size == 0) {
			return null;
		}

		Object objct = head.data;
		if (head.next == null) {
			head = null;
		} else {
			head = head.next;
		}
		
		size--;
		return objct;

	}
	
	/**
	 * 刪除節點
	 * 1. 首先需找到刪除的節點
	 * 2.然後讓前一個節點指向刪除節點的下一個節點
	 * @param obj
	 * @return
	 */
	public boolean deleteNode(Object obj){
		if (size == 0) {
			return false;
		}
		
		Node previousNode  = null;
	    Node currentNode = head;
	    while (currentNode.data != obj) {
			if (currentNode.next == null) {
				return false;
			}
		}
		
		while (currentNode.data  !=obj) {
			if (currentNode.next == null) {
				return false;
			}
			
			previousNode = currentNode;
			currentNode = currentNode.next;
		}
		
		if (currentNode == head) {
			this.deleteHeadNode();
		} else {
			previousNode.next = currentNode.next;
			size -- ;
		}
		
		return true;
	}
	
	/**
	 * 判斷連結串列是否存在某個元素
	 * @param obj
	 * @return
	 */
	public boolean containObject(Object obj){
		if (size == 0) {
			return false;
		}
		
		Node n =head;
		while (n.next!=null) {
			if (n.data == obj) {
				return false;
			}else {
				n = n.next;
			}
		}
		
		return false;
	}
	
	public void display(){
		if (size == 0) {
			System.out.println("連結串列為空");
		}
		
		Node n = head;
		
		while (n != null) {
			System.out.print("<-"+n.data);
			n= n.next;
		}
		
		System.out.println();
	}
	
	/**
	 * 插入節點
	 * @param obj
	 */
	public void insertNode(Object obj){
		Node newNode = new Node(obj);
		if (size ==0) {
			head = newNode;
		}else {
			Node node = head ;
			while (node.next!=null) {
				node = node.next;
			}
			
			node.next = newNode;
		}
		size++;
		
	}
	
	/**
	 * 反轉連結串列（遞迴）
	 * 
	 * 在反轉連結串列的時候需要判斷反轉的節點是否還有下一個節點
	 * 
	 * 
	 * @param previousNode
	 * @return
	 */
	public static Node ReverseByRecursive(Node previousNode) {
		
		if (previousNode ==null || previousNode.getNext()==null) {
			return previousNode;
		}else {
			Node rehead = ReverseByRecursive(previousNode.getNext());
			previousNode.getNext().setNext(previousNode);
			previousNode.setNext(null);
			return rehead;
		}
	}

	
	public static void main(String[] args) {
		LinkedListOnePoint list = new LinkedListOnePoint();
		list.insertNode(0);
		list.insertNode(1);
		list.insertNode(2);
		list.insertNode(3);
		list.display();
		
		list.head = ReverseByRecursive(list.head);
		list.display();
		
		
	}