/**
 * 单链表节点类
 */
class Node
{
	int data;
	Node *next;

public:
	Node();
	Node(Node*, int);
};

/**
 * 单链表类
 * @description 带虚拟头节点
 */
class LinkedList
{
private:
	Node *head;
	Node *tail;

public:
	LinkedList();
	virtual ~LinkedList();
	Status Init();          // 初始化链表
	Status Destroy();       // 销毁链表

	int Length();           // 求链表长度(有效节点)节点个数
	bool IsEmpty();         // 链表是否为空
	Status Insert(int pos, int value);  // 在指定位置生产节点, 并插入数据
	Status Remove(int pos);  // 删除指定位置节点
	int GetValue(int pos);   // 读取指定位置节点数据
	Node* GetAddress(int pos); // 获取知道位置节点的地址
	int SearchPosition(int value); // 搜索第一个出现的元素值的节点位置
	Status Update(int pos, int value); // 更新指定位置节点数据
	Status ClearList(); // 清除链表数据(不包含头节点)
	Status PrintList(); // 顺序打印链表节点数据
	Status Reverse();   // 反转链表
};

#include "Node.h"
#include <cstdlib>

Node::Node() {
	data = 0;
	next = NULL;
}

Node::Node(Node* newNext, int newValue)
{
	data = newValue;
	next = newNext;
}

Node::~Node()
{
	// TODO Auto-generated destructor stub
}

#include "LinkedList.h"
#include <cstdlib>
#include <iostream>

using namespace std;

LinkedList::LinkedList() {
	head = NULL;
	tail = NULL;
}

LinkedList::~LinkedList() {
	Destroy();
}

/**
 * 初始化链表
 */
Status LinkedList::Init()
{
	// 创建虚拟头节点
	head = new Node(NULL, 0);

	if(head != NULL)
	{
		return OK;
	}

	return ERROR;
}

/**
 * 销毁链表
 * @description 与初始化操作相对, 删除所有链表节点, 包括头节点
 */
Status LinkedList::Destroy()
{
	if(head)
	{
		Node *curP = head;

		while(head)
		{
			curP = head->next;
			delete head;
			head = curP;
		}

		return OK;
	}
	else
	{
		cout <<"The list is NULL"<<endl;
				return ERROR;
	}
}

/**
 * 求链表长度(有效节点)节点个数
 * @description 从虚拟头节点的下一个节点开始计算有效节点数
 */
int LinkedList::Length()
{
	if(!head)
	{
		cout <<"The list is NULL"<<endl;
		exit(-1);
	}

	Node *curP = head->next;
	int n = 0;
	while(curP != NULL)
	{
		n ++;
		curP = curP->next;
	}

	return n;
}

/**
 * 判断链表是否为空
 * @description 判断依据: 虚拟头节点head == NULL
 * 注: 长度为0 不代表链表为空
 */
bool LinkedList::IsEmpty()
{
	return (head == NULL);
}

/**
 * 在指定位置生产节点, 并插入数据
 * @param pos [in] 待插入位置. 从头节点的后继开始为0计数，所需要经过的节点数。范围：0~n-1
 * @param value [in] 待插入节点数据域
 */
Status LinkedList::Insert(int pos, int value)
{
	if(IsEmpty())
	{
		cout <<"The list is NULL. Pls Create an List and init it first."<<endl;
		exit(-1);
	}

	// create a new Node
	Node *newNode = new Node(NULL, value);

	if(pos == 0)
	{
		newNode->next = head->next;
		head->next = newNode;
	}
	else if(pos >0 && pos <= Length())
	{
		// find the predecessor node to be inserted
		Node *p = GetAddress(pos-1);

		// insert the new Node to List
		if(p != NULL)
		{
			if(p->next != NULL)
			{// not tail
				newNode->next  = p->next;
			}
			p->next = newNode;
		}
	}
	else
	{
		cout<<"Error: Input param Pos is illegal(<0)"<<endl;
		return ERROR;

	}

	return OK;
}

/**
 * 删除指定位置节点
 * @param pos [in] 待插入位置. pos有效范围: [0, n), 0代表虚拟节点后面一个节点, 虚拟节点无法通过此API删除
 *
 */
Status LinkedList::Remove(int pos)
{
	// find the prior node
	Node *curP = GetAddress(pos);
	if(curP == NULL)
	{
		return ERROR;
	}

	// get the node to be delete
	Node *tmp = curP->next;

	// delete the node
	if(tmp != NULL)
	{// not NULL node
		if(tmp->next != NULL)
		{// not tail
			curP->next = tmp->next;
			tmp->next = NULL;
		}
		else
		{
			curP->next =  NULL;
			delete tmp;
		}
	}

	return OK;
}

/**
 * 读取指定位置节点数据
 */
int LinkedList::GetValue(int pos)
{
	// find the  node
	Node *curP = GetAddress(pos);
	if(curP != NULL)
	{
		return curP->data;
	}
	else
	{
		return 0;
	}
}

/**
 * 获取位置节点的地址
 * @param pos [in] 从头节点的后继开始为0计数，所需要经过的节点数。范围：[0, n-1], n是链表长度(有效数据节点数)
 * @return 节点的地址
 */
Node* LinkedList::GetAddress(int pos)
{
	// valid list is null or not
	if(!head)
	{
		cout <<"The list is NULL"<<endl;
		exit(-1);
	}

	// valid intput param
	if(pos < 0 || pos >= Length())
	{
		cout <<"Insert position is out of the list‘s bounds"<<endl;
		exit(-1);
	}

	// 顺序查找位置pos的节点
	int i = 0;
	Node *curP = head->next;
	while(curP != NULL)
	{
		if(i == pos)
		{
			return curP;
		}

		i ++;

		curP = head->next;
	}

	return NULL;
}

/**
 * 搜索第一个出现的元素值的节点位置
 * @param value 待查找值
 * @return 链表第一个节点的数据域=value的位置
 * - ERROR 错误
 * - >=0 位置序号
 */
int LinkedList::SearchPosition(int value)
{
	// valid list is null or not
	if(!head)
	{
		cout <<"The list is NULL"<<endl;
		exit(-1);
	}

	// sequential search
	Node *p = head->next;
	int i = 0;
	while(p != NULL)
	{
		i ++;
		if(p->data == value)
			return i;
		else
			p = p->next;
	}

	cout<< "Can‘t find the value in list"<<endl;
	return ERROR;
}

/**
 * 更新指定位置节点数据
 * @param pos [in] 待更新节点位置
 * @param value [in] 待更新节点要修改的目标值
 * @return 更新结果
 * - OK 正常更新
 * - ERROR 没有找到待更新节点, 可能由位置错误或者链表为空导致
 */
Status LinkedList::Update(int pos, int value)
{
	// find the node
	Node *curP = GetAddress(pos);
	if(curP != NULL)
	{
		curP->data = value;
		return OK;
	}

	return ERROR;
}

/**
 * 清除链表数据(不包含头节点)
 */
Status LinkedList::ClearList()
{
	// valid list is null or not
	if(!head)
	{
		cout <<"The list is NULL"<<endl;
		exit(-1);
	}

	Node *p = head->next;
	Node *tmp = NULL;

	while(p!=NULL)
	{
		tmp = p;
		p = p->next;
		delete tmp;
	}

	head->next = NULL;

	return OK;
}

/**
 * 顺序打印链表节点数据
 */
Status LinkedList::PrintList()
{
	// valid list is null or not
	if(IsEmpty())
	{
		cout <<"The list is NULL. Pls Create an List and init it first."<<endl;
		return ERROR;
	}

	cout <<"List:[ ";
	if(Length() == 0)
	{
		cout<<"NULL";
	}
	else
	{
		Node *p = head->next;

		while(p != NULL)
		{
			cout<<p->data<<" ";
			p = p->next;
		}
	}
	cout <<"] "<<endl;
	return OK;
}

/**
 * 反转链表, 除虚拟头节点
 */
Status LinkedList::ReverseList()
{
	// valid list is null or not
	if(IsEmpty())
	{
		cout <<"The list is NULL. Pls Create an List and init it first."<<endl;
		exit(-1);
	}

	if(Length() == 0)
	{
		cout <<"The list length = 0. Pls insert new Node."<<endl;
		exit(-1);
	}

	// reverse List
	Node *pre = head->next; // precursor Node
	Node *cur = pre->next;  // current Node
	Node *nxt = NULL;       // successor Node

	while(cur != NULL)
	{
		nxt = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nxt;
	}

	// set the tail Node
	head->next->next = NULL;

	// set the head Node‘s next field
	head->next = pre;

	return OK;
}

#include <iostream>
#include "LinkedList.h"

using namespace std;

int main()
{
	cout<<"This is Linked List Demo."<<endl;

	cout<<"Create&Init List:"<<endl;
	LinkedList *list = new LinkedList();
	list->Init();
	list->PrintList();

	// 顺序插入100~109到链表中
	cout<<"Insert List:"<<endl;
	int i ;
	const int base = 100;
	for(i = base; i < base+10; i ++)
	{
		list->Insert(0, i);
	}
	list->PrintList();

	cout<<"Reverse List:"<<endl;
	list->ReverseList();
	list->PrintList();

	return 0;
}