#ifndef chainWithHeader_
#define chainWithHeader_
#include<iostream>
#include<string>    //陣列
#include<algorithm> //STL中的演算法
#include<sstream>  //istringstream流
#include<exception>//異常處理
#include<vector>//迭代器
#include<numeric>//標準庫中的數學操作函式
#include<iterator>
#include<array>
#include "chainNode.h"
using namespace std;
template<typename T>
class chainWithHeader
{
public:
	 chainWithHeader(int initialCapacity=10);
	~chainWithHeader();



	bool empty() const { return listSize == 0; }
	int size() const { return listSize; }
	void insert(int theIndex, const T& theElement);
	void insertsort();
	void output(ostream& out)const;
	void bubblingSort();
	void selectionSort();
	void rankSort();
private:
	chainNode<T>*headerNode;   //指向連結串列第一個節點的指標
	int listSize;
};
template<typename T>
chainWithHeader<T>::chainWithHeader(int initialCapacity)
{
	if (initialCapacity<1)
	{
		ostringstream s;
		s << "Initial capacity= " << initialCapacity << "Must be>0";
		throw illegalParameterValue(s.str());
	}
	headerNode = new chainNode<T>();
	headerNode->next= NULL;
	listSize = 0;
}
//解構函式，~chain(),思想，不斷的刪除首節點
template<typename T>
chainWithHeader<T>::~chainWithHeader()
{
	while (headerNode->next!= NULL)
	{
		chainNode<T>* nextNode = headerNode->next;
		delete headerNode;
		headerNode = nextNode;
	}
}
//插入函式
template<typename T>
void chainWithHeader<T>::insert(int theIndex, const T& theElement)
{
	if (theIndex == 0)//把連結串列頭賦給自己
		headerNode->next = new chainNode<T>(theElement, headerNode->next);
	else
	{
		chainNode<T>* p =headerNode->next;
		for (int i = 0; i < theIndex - 1; i++)
			p = p->next;
		p->next = new chainNode<T>(theElement, p->next);
	}
	listSize++;
}
//輸出函式
template<typename T>
void chainWithHeader<T>::output(ostream& out)const
{
	for (chainNode<T>*p = headerNode; p->next != NULL; p = p->next)
		out << p->next->element << " ";
}
//插入排序
template<typename T>
void chainWithHeader<T>::insertsort()
{
	//將連結串列分成兩段，一段有1個元素，另一段有n-1個元素，這是基礎
	chainNode<T>*p= headerNode->next->next;     //p代表第二個節點，此表從第二個節點開始
	headerNode->next->next = NULL;              //只要一個元素的表，等待插入          
	chainNode<T>*r,*q;
	while (p!= NULL)
	{
		r = p->next;                           //儲存p後面還沒比較的節點
		q = headerNode;                        //新表的表頭，每次從表頭開始找
		while (q->next != NULL&&q->next->element<= p->element)  //找到大於p的那個節點前驅
			q = q->next;
		p->next = q->next;                                 //p->next指向q->next的值
		q->next = p;               //q->next指向p處的值，相當於從p指的連結串列找到一個元素放入headerNode所指連結串列的合適位置
		p = r;                                             //進行下一次比較
	}
}
//氣泡排序（有頭結點）
template<typename T>
void chainWithHeader<T>::bubblingSort()
{
	    chainNode<T>*pr, *pt,*pb,*pf,*pd;//pd表示每次要比較的尾元素,pr表示比較元素的前一個，pt表示比較元素的後一個
	    pb = headerNode;            //pb為第一個比較元素的前驅
	    pr = headerNode->next;
	    pd = NULL;
		pf = headerNode;            //pf就是為了得到每次排完序的頭節點
		bool swapped = true;        //為了在已經有序的情況下能及時退出
		while (pf->next!=pd&&swapped)
		{
			pb = pf;                //pb為第一個比較元素的前驅
			pr = pf->next;
			swapped = false;        //目前為止未交換
			while (pr->next!=pd)
			{
                pt = pr->next;
				if (pr->element > pt->element)//如果兩相鄰的節點無序，則交換
				{
					pb->next = pt;
					pr->next = pt->next;
					pt->next = pr;
					swapped = true;
				}
				pb = pb->next;
				pr = pb->next;
			}
			pd = pr;//新的末尾
		}
}
//選擇排序（有頭節點）
template<typename T>
void chainWithHeader<T>::selectionSort()
{
	chainNode<T>*pd,*pf,*pe,*pa,*pmax;
	pf = headerNode;
	pd = NULL;
	bool sorted = false;                         //已經排好序之後退出迴圈
	while (pf->next->next!=pd&&!sorted)
	{
		pmax = pf;
		pa= pf->next;
		sorted = true;
		T temp;
		while (pa->next!= pd)
		{
			if (pmax->next->element<=pa->next->element)//找最大的元素
				pmax= pa;
			else sorted = false;
	        pe = pa;                           //記錄每次查詢完的最後一個元素的前驅
			pa= pa->next;
		}
		/*pb = pe->next;
		pbmax = pmax->next;

		pmax->next = pb;
		pbmax->next = pb->next;
		pb->next = pbmax->next;
		pe->next = pbmax;*/
		temp = pmax->next->element;          //和最大值和尾值交換
		pmax->next->element=pe->next->element;
		pe->next->element = temp;
        
		pd = pe->next;                             //記錄尾節點，值最大
	}
}
//計數排序
template<typename T>
void chainWithHeader<T>::rankSort()
{
	//求排名
	chainNode<T>*p, *pr;
	p = headerNode->next->next;       //指向第二個元素
	int*r= new int[listSize]();   //記錄排名,預設初始化為0
	int i = 1,j=0;
	while (p != NULL)
	{
		pr = headerNode->next;
		j = 0;
		while (pr!= p)
		{
            if(pr->element <= p->element)
				 ++r[i];
			else ++r[j];
			pr = pr->next;
			++j;
		}
		p = p->next;
		++i;
	}
	//根據名次排列
	chainNode<T>*pb = headerNode->next;
	int k = 0,t;
	T temp;
	while (pb != NULL)
	{
		 int i =0;
		chainNode<T>*pd = headerNode->next;
		while (k!=r[i])
		{
			pd = pd->next;
			++i;
		}
		if (k!=r[k])         //如果實際位置和名次相同，則不交換
		{
			//交換資料
			temp = pb->element;
			pb->element = pd->element;
			pd->element = temp;
            //交換名次
			t = r[i];
			r[i] = r[k];
			r[k] = t;
		}
		pb = pb->next;
		++k;
	}
	delete [] r;
}

#endif