Linked list optimization

[firix]

Hi

I tried to write the linked list code but,
I think many did not succeed.
How can I improve this code ?

thanks for reading...

template<class T>
class List{
public:
	struct node{
	T  val;
	node *pnext;
	node *prev;
	node()
	{	
		pnext = 0;
		prev = 0;
	}
};
	node *phead;
	node *ptail;
	size_t count;
	List<T>()
	{
		phead = 0;
		ptail  = 0;
		count = 0;
	}


	void print()
	{
		node *p = phead;
		if (p == 0)
			cout << "Empty\n" << endl;
		int n = count;
		while(n--) {
			cout << p->val << endl;
		p = p->pnext;
		}	
	}

node *AddlistnodeHead(T val)
{
	node *pnewnode = new node;
	pnewnode->val = val;
	pnewnode->pnext = 0;
	pnewnode->prev = 0;

	pnewnode->pnext = phead;

	if (count >= 1) {
		pnewnode->pnext = phead;
		phead->prev = pnewnode;
	}


	phead = pnewnode;
	if (ptail == 0)
		ptail = pnewnode;
	count++;

	return pnewnode;

}

node *AddlistnodeTail(T val)
{
	node *pnewnode = new node;
	pnewnode->pnext = 0;
	pnewnode->prev = 0;

	pnewnode->val = val;

	if (ptail == 0) {
		ptail = pnewnode;
		phead = pnewnode;
	}
	else 
	{
		pnewnode->prev = ptail;
		ptail->pnext = pnewnode;
		ptail = pnewnode;

	}

	count++;


	return pnewnode;
}



node *insert_node(node *pnode, T val)
{
	node *pnewnode = new node;
	pnewnode->pnext = 0;
	pnewnode->prev = 0;
	pnewnode->val =val;

	if (ptail == pnode) {
		pnewnode->prev = ptail;
		ptail->pnext = pnewnode;
		ptail = pnewnode;
	}

	else if (count == 1) {
		ptail->pnext = pnewnode;
		pnewnode->prev = ptail;
		ptail = pnewnode;
	}
	else {
	
	pnewnode->pnext = pnode->pnext;
	pnewnode->prev = pnode;
	pnewnode->pnext->prev = pnewnode;
	pnode->pnext = pnewnode;
	}

	
	count++;
	return pnewnode;
}

node *insert_node_index(size_t index, T val)
{
	node *pnode;

	if (index == 0)
		return AddlistnodeHead(val);


	pnode = phead;

	for (int k = 0; k < index - 1; ++k)
		pnode = pnode->pnext;

	return insert_node(pnode, val);



}


void delete_node(node *pnode)
{
	node *ptemp;

	if (count == 1) {
		ptemp = pnode;
		pnode = 0;
		ptail = 0;
	}


	else {
	ptemp = pnode->pnext;

	if (ptail == ptemp)
		ptail = pnode;
	pnode->pnext = ptemp->pnext;
	ptemp->prev = pnode;
	}
	--count;

	delete ptemp;


}

bool delete_node_index(size_t index)
{
	
	node *pnode, *ptemp;

	pnode = phead;
	if (index >= count)
		return false;

	ptemp = phead;
	//if (count == 1) {
	//	ptail = 0;
	//	phead  = 0;
	//	delete ptemp;
	//	return true;
	//}

	if (index == 0) {
		phead->prev = 0;
		phead = phead->pnext;
		delete ptemp;
		--count;
		return true;

	}

		for (int i= 0; i < index -1; ++i)
			pnode = pnode->pnext;
		delete_node(pnode);

		return true;

}




};



int main()
{

	List<string> ilist;


	ilist.AddlistnodeHead("Apple");

	ilist.AddlistnodeHead("IBM");

	ilist.AddlistnodeHead("Microsoft");

              ilist.print();

              return 0;
}