package linkedlist;

import java.util.Stack;

/* 
 * 单向链表:
 * 现在明确要干什么:
 * 单向链表节点类:
 * 1.date域
 * 2.next指针
 * 3.这里给多一个int型的number类型
 * 
 * 单向链表类:
 * 1.一个头节点
 * 3.增加节点的方法,直接在后面增加
 */
public class SingleLinkedList
{
	public Node head=new Node("", 0);
	/*
	 * 普通地在后面增加节点方法
	 */
	public void add(Node node)
	{
		Node temp=this.head;
		while(temp.next!=null)
		{
			temp=temp.next;
		}
		temp.next=node;
	}
	/*
	 * 第二种方式添加节点时，根据number编号从小到大将节点插入到指定位置
	 * (如果有这个number值的时候，则添加失败，并给出提示)
	 * 这里是有一个flag标记是否能找到这样子的位置,
	 * 当存在有number号和node相等的时候flag=true,这时就不能添加
	 */
	public void add2(Node node)
	{
		Node temp=head;
		boolean flag=false;
		while(true)
		{
			//这里表示要么这个链表是空的,要么是到了链表的最后
			if(temp.next==null)
				break;
			if(temp.next.number>node.number)
				break;
			if(temp.next.number==node.number)
			{
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag)
		{
			System.out.println("这个编号已经存在");
		}
		else
		{
			node.next=temp.next;
			temp.next=node;
		}
	}
	/*
	 * 修改节点的信息,根据number来修改
	 */
	public void update(Node node)
	{
		Node temp=head;
		boolean flag=false;
		while(true)
		{
			//要么这个链表是空的,要么到了链表尾,都是找不到
			if(temp.next==null)
				break;
			if(temp.next.number==node.number)
			{
				flag=true;
				break;
			}
			temp=temp.next;
		}
		//如果找到了就干什么
		if(flag)
		{
			temp.next.date=node.date;
		}
		else
			System.out.println("不存在这个编号");
	}
	/*
	 * 删除节点,方法和前面的差不多
	 */
	public void delete(int number)
	{
		Node temp=head;
		boolean flag=false;
		while(true)
		{
			if(temp.next==null)
				break;
			if(temp.next.number==number)
			{
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag)
		{
			temp.next=temp.next.next;
		}
		else
		{
			System.out.println("不存在这样的节点");
		}
	}
	/*
	 * 遍历这个链表
	 */
	public void show()
	{
		if(head.next==null)
		{
			System.out.println("链表是空的");
			return;
		}
		Node temp=head.next;
		while(true)
		{
			if(temp==null)
			{
				break;
			}
			System.out.println(temp);
			temp=temp.next;
		}
	}
	
	/*
	 * 将单链表反转
	 * 就是将这个链表传进来,然后将这个链表的节点翻转过来
	 */
	public  void reverse1(SingleLinkedList list)
	{
		//如果这个链表是空链表或者是长度为1的链表,就不用翻转
		if(list.head.next==null||list.head.next.next==null)
		{
			return;
		}
		//确定是要翻转了,然后新建一个头节点,然后再遍历这个链表
		//每一次遍历的节点就加入到新的头节点的最前面
		//这里需要保存一下每一次遍历的节点的下一个节点,因为如果我们将
		//遍历的节点加入到新的头节点的链表后,就无法找到当前节点的下一个节点了
		Node head=new Node("", 0);
		Node temp1=list.head.next;
		Node tempnext;
		while(temp1!=null)
		{
			tempnext=temp1.next;
			
			temp1.next=head.next;
			head.next=temp1;
			
			temp1=tempnext;
		}
		list.head.next=head.next;
	}
	/*
	 * 说到翻转,最可能是想到栈的数据结构,它的先进后出的结构可以很轻松地实现
	 * 翻转地效果
	 */
	public void reverse2(SingleLinkedList list)
	{
		Stack<Node> stack=new Stack<Node>();
		Node temp=list.head.next;
		while(temp!=null)
		{
			stack.push(temp);
			temp=temp.next;
		}
		while(stack.size()>0)
		{
			System.out.println(stack.pop());
		}
	}
	/*
	 * 查找单链表中的倒数第k个结点
	 * 这里是这样子,先利用getlength的方法得到list的长度
	 * 然后利用长度length-index就是刚刚好是倒数index位置的节点
	 */
	public Node find(SingleLinkedList list,int index)
	{
		int length=this.getlength(list);
		//我觉得应该先处理一些不用返回的情况
		if(list.head.next==null||index<=0||index>length)
		{
			System.err.println("找不到");
			return null;
		}
		Node temp=list.head.next;
		for (int i = 0; i < length-index; i++)
		{
			temp=temp.next;
		}
		return temp;
	}
	/*
	 * 返回这个链表地长度
	 */
	public int getlength(SingleLinkedList list)
	{
		Node temp=list.head.next;
		int length=0;
		while(temp!=null)
		{
			length++;
			temp=temp.next;
		}
		return length;
	}
	public static void main(String[] args)
	{
		Node h1 = new Node("a", 1);
		Node h2 = new Node("b", 2);
		Node h3 = new Node("c", 3);
		Node h4 = new Node("d", 4);
		
		//创建要给链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		
		//加入
		singleLinkedList.add2(h1);
		singleLinkedList.add2(h4);
		singleLinkedList.add2(h2);
		singleLinkedList.add2(h3);
		singleLinkedList.show();
		System.out.println();
		singleLinkedList.update(new Node("z", 3));
		singleLinkedList.show();
		System.out.println("翻转");
		singleLinkedList.reverse1(singleLinkedList);
		singleLinkedList.show();
		System.out.println();
		singleLinkedList.reverse2(singleLinkedList);
		System.out.println("删除");
		singleLinkedList.delete(3);
		singleLinkedList.show();
		System.out.println();
		System.out.println(singleLinkedList.find(singleLinkedList, 0));
	}
}
class Node
{
	public String date;
	public int number;
	public Node next;
	public Node(String date, int number)
	{
		this.date = date;
		this.number = number;
	}
	@Override
	public String toString()
	{
		return "Node [date=" + date + ", number=" + number + "]";
	}
	
}