List（1）List单链表的链式实现

若有错误，诚请指正

list.h

/*-----------------------------------------------  
Created By EverSteins  
Email:EverSteins@gmail.com 
转载请注明出处 
------------------------------------------------*/   
#ifndef LIST_H
#define LIST_H
#include "utility.h"

typedef int ElemType;

class LinkList
{
	
public:
	LinkList():count_(0),head_node_(NULL){}
	~LinkList();

	bool Empty() const
	{
		return count_ == 0;
	}

	int Size() const
	{
		return count_;
	}

	bool Insert(const int position,const ElemType &item);
	bool Remove(const int position,ElemType &item);
	bool Remove(const int position);
	bool Retrieve(const int position,ElemType &item) const;
	bool Replace(const int position,const ElemType &item);

	void ShowAllEntry() const;

private:
	struct LinkListNode
	{
		LinkListNode(ElemType entry,LinkListNode *next):entry_(entry),next_(next){}
		ElemType entry_;
		LinkListNode *next_;	
	};

	LinkListNode * SetPosition(const int position) const;

	int count_;
	LinkListNode *head_node_;

#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
  TypeName(const TypeName&);               \
  void operator=(const TypeName&)

	DISALLOW_COPY_AND_ASSIGN(LinkList);

#undef DISALLOW_COPY_AND_ASSIGN



};

#endif

list.cc

/*-----------------------------------------------  
Created By EverSteins  
Email:EverSteins@gmail.com 
转载请注明出处 
------------------------------------------------*/  
#include "stdafx.h"
#include <iostream>
#include "utility.h"
#include "list.h"
using namespace std;


//时间复杂度O(n)
LinkList::LinkListNode * LinkList::SetPosition(const int position) const
{
	//pre:0<=position<count(LinkList::Insert时可以position等于count)
	assert(position>=0);	
	LinkListNode *tmp_node=head_node_;
	for (int i=0;i<position;++i)
		tmp_node=tmp_node->next_;
	return tmp_node;
}

//时间复杂度O(n)
bool LinkList::Insert(const int position,const ElemType &item)
{
	//pre:0<=position<=n
	assert(position>=0);
	if (position<0 || position>count_)
		return false;

	if (position>0)
	{
		LinkListNode *previous_node=SetPosition(position-1);
		LinkListNode *following_node=previous_node->next_;
		LinkListNode *new_node=new LinkListNode(item,following_node);
		previous_node->next_=new_node;
	}
	else //position == 0时
	{
		LinkListNode *new_node=new LinkListNode(item,head_node_);
		head_node_=new_node;
	}

	++count_;
	assert(count_>=0);           //防止溢出
	return true;
}

//时间复杂度O(n)
bool LinkList::Remove(const int position)
{
	//pre:0<=position<=n-1
	assert(position>=0);
	if (position<0 || position>=count_)
		return false;

	if (position>0) //当不是删除在第一个位置的节点，说明至少有2个节点
	{
		LinkListNode *previous_node=SetPosition(position-1);
		LinkListNode *remove_node=previous_node->next_;
		LinkListNode *following_node=remove_node->next_;
		previous_node->next_=following_node;
		delete remove_node;		
	}
	else //当删除第一个位置的节点
	{
		LinkListNode *following_node=head_node_->next_;
		delete head_node_;
		head_node_=following_node;
	}

	--count_;
	return true;
}

//时间复杂度O(n)
bool LinkList::Remove(const int position,ElemType &item)
{
	assert(position>=0);
	if (position<0 || position>=count_)
		return false;

	if (position>0) //当不是删除在第一个位置的节点，说明至少有2个节点
	{
		LinkListNode *previous_node=SetPosition(position-1);
		LinkListNode *remove_node=previous_node->next_;
		LinkListNode *following_node=remove_node->next_;
		previous_node->next_=following_node;

		item=remove_node->entry_;
		delete remove_node;		
	}
	else //当删除第一个位置的节点
	{
		LinkListNode *following_node=head_node_->next_;
		item=head_node_->entry_;
		delete head_node_;
		head_node_=following_node;
	}

	--count_;
	assert(count_>=0);
	return true;
}

//时间复杂度O(n)
bool LinkList::Retrieve(const int position,ElemType &item) const
{
	assert(position>=0);
	if (position<0 || position>=count_)
		return false;

	LinkListNode *current_node = SetPosition(position-1);
	item = current_node->entry_;

	return true;
}

//时间复杂度O(n)
bool LinkList::Replace(const int position,const ElemType &item)
{
	assert(position>=0);
	if (position<0 || position>=count_)
		return false;

	LinkListNode *current_node = SetPosition(position-1);
	current_node->entry_ = item;

	return true;
}

void LinkList::ShowAllEntry() const
{
	LinkListNode *tmp_node=head_node_;
	while (tmp_node != NULL)
	{
		cout<<tmp_node->entry_<<' ';
		tmp_node=tmp_node->next_;
	}
	cout<<endl;
}

LinkList::~LinkList()
{
	while (!Remove(0));
	
}

utility.h

/*----------------------------------------------- 
Created By EverSteins 
Email:EverSteins@gmail.com
转载请注明出处
------------------------------------------------*/ 

#ifndef UTILITY_H
#define UTILITY_H
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <stdlib.h>


#endif

main.cc

/*-----------------------------------------------  
Created By EverSteins  
Email:EverSteins@gmail.com 
转载请注明出处 
------------------------------------------------*/   
#include "stdafx.h"
#include "list.h"
#include <iostream>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	LinkList list1;
	list1.Insert(0,1);
	list1.Insert(1,3);
	list1.Insert(1,2);

	list1.ShowAllEntry();

	list1.Remove(1);
	list1.Remove(1);
	list1.Remove(1);
	list1.Remove(1);

	list1.ShowAllEntry();

	cin.get();

	return 0;
}