#pragma once
#include "SHTable.h"
#include "SHQuene.h"

template<class T> class SHArray
{
public:
	
	SHArray(long size = 0);
	SHArray(const SHArray<T>& array);
	SHArray(const SHTable<T>& table);
	SHArray<T>& operator = (const SHArray<T>& array);
	virtual ~SHArray();

	//space
	void Realloc(long newLength,bool bCopy = true);

	//attribute
	bool IsValidIndex(long index) const;
	bool IsEmpty() const;
	long GetLength() const;
	long GetLastIndex() const;
	bool operator == (const SHArray<T>&array) const;
	bool operator != (const SHArray<T>&array) const;

	//random visit
	T& operator[](long index);
	const T& GetAt(long index) const;
	void SetAt(long index,const T&t);
	T* GetBuffer() const;

	//insert/delete
	void Insert(long index,const T&t);
	void InsertHead(const T&t);
	long AddTail(const T&t);
	void Del(long index);
	void DelFirst();
	void DelTail();
	void Clear();

	//search
	long Find(const T&t,long from = 0,long to = -1) const;
	long Find(const T&t,SHQuene<long>&quene,long from = 0,long to = -1) const;
	long FindOrAddTail(const T&t);
	void FindOrInsertHead(const T&t);
	long FindAndDel(const T&t);
	//二分查找，适用于升序表
	long BFind(const T&t,long from = 0,long to = -1) const;

	//operate
	void SetAll(const T&t);
	//稳定计数排序
	void Arrange(bool bIncrease = true);
	void Arrange(int (*cmp)(const T&,const T&));
	//倒序
	void Reverse(long from = 0,long to = -1);

protected:
	long length;
	T * pData;
};

template<class T>
SHArray<T>::~SHArray()
{
	if (pData  !=  NULL)
	{
		delete[] pData;
	}
}

template<class T>
bool SHArray<T>::IsValidIndex(long index) const
{
	return index >=0 && index < length;
}

template<class T>
bool SHArray<T>::IsEmpty() const
{
	return length  ==  0;
}

template<class T>
long SHArray<T>::GetLength() const
{
	return length;
}

template<class T>
long SHArray<T>::GetLastIndex() const
{
	return length - 1;
}

template<class T>
bool SHArray<T>::operator  !=  (const SHArray<T>&array) const
{
	return !((*this)  ==  array);
}

template<class T>
T& SHArray<T>::operator[](long index)
{
	return pData[index];
}

template<class T>
const T& SHArray<T>::GetAt(long index) const
{
	return pData[index];
}

template<class T>
void SHArray<T>::SetAt(long index,const T&t)
{
	pData[index] = t;
}

template<class T>
T* SHArray<T>::GetBuffer() const
{
	return pData;
}

template<class T>
void SHArray<T>::InsertHead(const T&t)
{
	Insert(0, t);
}

template<class T>
long SHArray<T>::AddTail(const T& t)
{
	Insert(length, t);
	return GetLastIndex();
}

template<class T>
void SHArray<T>::DelFirst()
{
	Del(0);
}

template<class T>
void SHArray<T>::DelTail()
{
	Del(length - 1);
}

template<class T>
void SHArray<T>::Clear()
{
	if (pData  !=  NULL)
	{
		delete[] pData;
		pData = NULL;
		length = 0;
	}
}


template<class T>
long SHArray<T>::BFind(const T& t, long from, long to) const
{
	if (to < 0 || to >= GetLength())
	{
		to = GetLastIndex();
	}

	if (from > to)
	{
		return -1;
	}

	if (t < GetAt(from))
	{
		return -1;
	}

	if (t > GetAt(to))
	{
		return -1;
	}

	while(from <= to)
	{
		long mid = (from + to) / 2;
		const T& tCur = GetAt(mid);
		if (t > tCur)
		{
			from = mid + 1;
		}
		else if (t < tCur)
		{
			to = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

template<class T>
SHArray<T>::SHArray(long l)
{
	if (l <= 0)
	{
		length = 0;
		pData = NULL;
	}
	else
	{
		length = l;
		pData = new T[l];
	}
}

template<class T>
SHArray<T>::SHArray(const SHArray<T>& array) : pData(NULL), length(0)
{
	Realloc(array.GetLength());
	for (long i = 0;i < length; i++)
	{
		pData[i] = array.GetAt(i);
	}
}

template<class T>
SHArray<T>& SHArray<T>::operator = (const SHArray<T>& array)
{
	Realloc(array.GetLength());
	for (long i = 0; i < length; i++)
	{
		pData[i] = array.GetAt(i);
	}
	return *this;
}

template<class T>
SHArray<T>::SHArray(const SHTable<T>& table) : length(0), pData(NULL)
{
	Realloc(table.GetLength());
	long i = 0;
	for (const T* pCur = table.GetFirst(); pCur  !=  NULL; pCur = table.GetNext(pCur), i++)
	{
		pData[i] = *pCur;
	}
}

template<class T>
void SHArray<T>::Realloc(long l,bool bCopy)
{
	if (l  !=  length)
	{
		if (l <= 0)
		{
			if (pData!=NULL)
			{
				delete[] pData;
			}
			length = 0;
			pData = NULL;
		}
		else
		{
			T* pTemp = pData;
			pData = new T[l];
			if (bCopy)
			{
				if (l > length)
					for (long i = 0;i < length; i++)
					{
						pData[i] = pTemp[i];
					}
				else
				{
					for (long i = 0; i < l; i++)
					{
						pData[i] = pTemp[i];
					}
				}
			}
			length = l;
			if (pTemp != NULL)
			{
				delete[] pTemp;
			}
		}
	}
}

template<class T>
void SHArray<T>::SetAll(const T&t)
{
	for (long i = 0; i < length; i++)
	{
		pData[i] = t;
	}
}

template<class T>
bool SHArray<T>::operator  == (const SHArray<T>& array) const
{
	if (length != array.GetLength())
	{
		return false;
	}
	for (long i = 0; i < length; i++)
	{
		if (pData[i] != array.GetAt(i))
		{
			return false;
		}
	}
	return true;
}

template<class T>
void SHArray<T>::Insert(long index,const T& t)
{
	T* pTemp = pData;
	length++;

	pData = new T[length];
	for (long i = 0; i < length; i++)
	{
		if (i < index)
		{
			pData[i] = pTemp[i];
		}
		else if ( i > index)
		{
			pData[i] = pTemp[i - 1];
		}
		else
		{
			pData[i] = t;
		}
	}
	if ( pTemp != NULL)
	{
		delete[] pTemp;
	}
}

template<class T>
void SHArray<T>::Del(long index)
{
	T* pTemp = pData;
	length--;

	if (length == 0)
	{
		pData = NULL;
	}
	else
	{
		pData = new T[length];
	}

	for (long i = 0; i < length; i++)
	{
		if (i < index)
		{
			pData[i] = pTemp[i];
		}
		else
		{
			pData[i] = pTemp[i + 1];
		}
	}
	delete[] pTemp;
}

template<class T>
long SHArray<T>::FindAndDel(const T&t)
{
	long count = 0;
	for (long i = 0;i < GetLength(); i++)
	{
		if (pData[i] == t)
		{
			Del(i);
			i--;
			count++;
		}
	}
	return count;
}

template<class T>
long  SHArray<T>::Find(const T&t,long from,long to) const
{
	if (to < 0 || to >= length)
	{
		to = length - 1;
	}

	for (long i = from; i <= to; i++)
	{
		if (pData[i] == t)
		{
			return i;
		}
	}
	return -1;
}

template<class T>
long SHArray<T>::Find(const T&t,SHQuene<long> &quene,long from,long to) const
{
	if (to < 0 || to >= length)
	{
		to = length-1;
	}
	for (long i = from; i <= to; i++)
	{
		if (pData[i] == t)
		{
			quene.EnQuene(i);
		}
	}
	return quene.GetLength();
}

//稳定计数排序
template<class T>
void SHArray<T>::Arrange(bool bIncrease)
{
	if (GetLength() < 2)
	{
		return;
	}
	long *count = new long[GetLength()];
	long i;
	for (i = 0;i<GetLength();i++)
	{
		count[i] = i;
	}
	if (bIncrease)
	{
		for (i = 0;i < GetLastIndex(); i++)
		{
			for (long j = i + 1; j < GetLength(); j++)
				if (pData[i] > pData[j])
				{
					count[i]++;
					count[j]--;
				}
		}
		for (i = 0;i < GetLength();i++)
		{
			if (count[i] != i)
			{
				long k,j;
				T temp1 = pData[i],temp2;
				k = count[i];
				while(k != i)
				{
					temp2 = pData[k];//save
					pData[k] = temp1;//transport data
					temp1 = temp2;
					j = k;
					k = count[j];//save
					count[j] = j;//count ok
				}
				pData[i] = temp1;
				count[i] = i;
			}
		}
	}
	else
	{
		for (i = 0; i < GetLastIndex(); i++)
		{
			for (long j = i + 1; j < GetLength();j++)
			{
				if (pData[i] < pData[j])
				{
					count[i]++;
					count[j]--;
				}
			}
		}

		for (i = 0;i < GetLength();i++)
		{
			if (count[i] != i)
			{
				long k,j;
				T temp1 = pData[i],temp2;
				k = count[i];
				while(k != i)
				{
					temp2 = pData[k];//save
					pData[k] = temp1;//transport data
					temp1 = temp2;
					j = k;
					k = count[j];//save
					count[j] = j;//count ok
				}
				pData[i] = temp1;
				count[i] = i;
			}
		}
	}
	delete[] count;
}

//稳定计数排序
template<class T>
void SHArray<T>::Arrange(int (*cmp)(const T&,const T&))
{
	if (GetLength() < 2)
	{
		return;
	}

	long i;
	long *count = new long[GetLength()];
	for (i = 0; i < GetLength(); i++)
	{
		count[i] = i;
	}

	for (i = 0; i < GetLastIndex(); i++)
	{
		for (long j = i + 1; j < GetLength(); j++)
		{
			if (cmp(pData[i], pData[j]) > 0)
			{
				count[i]++;
				count[j]--;
			}
		}
	}
	for (i = 0;i < GetLength(); i++)
	{
		if (count[i] != i)
		{
			long k,j;
			T temp1 = pData[i],temp2;
			k = count[i];
			while(k != i)
			{
				temp2 = pData[k];//save
				pData[k] = temp1;//transport data
				temp1 = temp2;
				j = k;
				k = count[j];//save
				count[j] = j;//count ok
			}
			pData[i] = temp1;
			count[i] = i;
		}
	}

	delete[] count;
}

template<class T>
void SHArray<T>::Reverse(long start,long end)
{
	if (end == -1)
	{
		end = length - 1;
	}
	if (!IsValidIndex(start) || !IsValidIndex(end))
	{
		return;
	}

	long halfLength = (end - start + 1) / 2;
	for (long i = 0; i < halfLength; i++)
	{
		T temp = pData[i + start];
		long j = end - i;
		pData[i + start] = pData[j];
		pData[j] = temp;
	}
}

template<class T>
long SHArray<T>::FindOrAddTail(const T&t)
{
	long pos = Find(t);
	return pos != -1 ? pos : AddTail(t);
}

template<class T>
void SHArray<T>::FindOrInsertHead(const T&t)
{
	long pos = Find(t);
	if (pos == -1)
	{
		InsertHead(t);
	}
}