算法与数据结构【C++】：普通单向链表

普通单向链表应该包含的数据和方法：

结点类（Node）：

    属性：
        AnyType value;    //任意类型的数据
        Node* next;        //指向下一个节点的指针
    方法：
        构造方法 Node(AnyType* value, Node* next);

链表类（LinkedList）：

    Node* head;        //链表头结点的指针
    Node* tail;        //链表尾结点的指针，可选
    int length;        //链表长度，可选

    int isEmpty();    //链表是否为空
    int contains();    //链表是否包含某个值
    void addToHead(AnyType value);    //向链表头添加数据
    void addToTail(AnyType value);    //向链表尾添加数据
    void addNode(AnyType value, int index)    //向链表指定下标处添加数据
    int deleteFromHead();    //从链表头删除一个数据，返回被删除的数据
    int deleteFromTail();    //从链表尾删除一个数据，返回被删除的数据
    int deleteNode();    //删除指定下标处的数据，返回被删除的数据

 

实现每种方法的思路：

    1、因为LinkedList类的属性有：head，tail，length
        所以要根据不同情况更新三个属性
    2、所以每种方法，都要处理：
        1）head发生变化
        2）tail发生变化
        的情况

下方是C++代码，有详细注释：

#include
#include
#include
using namespace std;

//节点类，代表链表的结点
class Node{
	public:
		int value;	//存储节点的值 
		Node* next;	//存储下一个节点的指针 
		Node(int aValue, Node* aNext = NULL){	//构造函数，必须传入结点的值，下一个节点默认为NULL
			this->value = aValue;
			this->next = aNext;
		}	
};

class LinkedList{	//普通单向链表类
	public:
		int length = 0;		//链表长度，该属性不重要，下面的方法中也没有用到，但是维护了该属性
		Node* head = 0;		//链表头节点的指针
		Node* tail = 0;		//链表尾节点的指针
	LinkedList(){
		
	}
	
	int isEmpty(){			//判断链表是否为空，头指针为0代表空
		return head == 0;
	}

	//向链表头添加数据
	int addToHead(int aValue){
		head = new Node(aValue, head);	//添加节点
		if (tail == 0) tail = head;		//如果尾指针为空，说明链表本身为空，更新尾指针
		length++;	
	}

	//向链表尾添加数据
	int addToTail(int aValue){
		//如果尾指针为空，说明链表本身为空，更新尾指针和头指针
		if (tail == 0) head = tail = new Node(aValue);	
		//否则只更新尾指针
		else tail = tail->next = new Node(aValue);
		length++;
	}

	//从链表头删除数据
	int deleteFromHead(){	
		//如果链表为空，无法删除，返回-1
		if (head == 0) return -1;
		//记录被删除的结点指针和值
		Node* deletedNode = head;
		int deletedValue = head->value;
		if (head == tail)	//如果链表只有一个结点，那么删除后头和尾都为空
			head = tail = 0;
		else 
			head = head->next;
		length--;
		delete deletedNode;
		return deletedValue;	//返回被删除的值
	}
	
	int deleteFromTail(){
		//如果链表为空，无法删除，返回-1
		if (head == 0) return -1;
		//记录被删除的结点指针和值
		Node* deletedNode = tail;
		int deletedValue = tail->value;
		if (head == tail)	//如果链表只有一个结点，那么删除后头和尾都为空
			head = tail = 0; 
		else {
			Node* now = 0;
			for(now=head; now->next!=tail; now=now->next);		//遍历链表，找到倒数第二个结点
			//printf("Fine -2 Node Value: %d\n", now->value);
			now->next = 0;
			tail = now;
		}
		length--; 
		delete deletedNode; 
		return deletedValue;	//返回被删除的值
	}
	
	int deleteNode(int index){
		if (index <= 0) return -1;
		//如果链表为空，无法删除，返回-1
		if (head == 0) return -1;
		Node* now = 0;
		int cnt = 1;	//计数器
		/*
			下面的循环作用：
					情况1：正常情况下，找到要删除的结点的前一个结点；
					情况2：如果要删除的结点序号大于总结点数，使得找到的值停止在NULL
		*/
		for(now=head; cnt+1next);
		//printf("Find now: value: %d\n", now->value);

		if(now == 0) return -1; 	//情况2发生，直接返回
		//记录被删除的结点指针和值
		Node* deletedNode = now->next;
		int deletedValue = deletedNode->value;
		
		//情况1：将该结点删除
		if (cnt == index-1)
			now->next = now->next->next;
		length--;
		//如果末尾结点被删除，更新tail
		if (deletedNode->next == 0){
			tail = now;
		}	
		delete deletedNode;
		return deletedValue;
	}

	//向指定序号处插入结点
	void addNode(int value, int index){	//index starts from 1
		if (index <= 0) return;
		//处理链表为空插入结点的情况
		if (head == 0 && index == 1)	{
			head = tail = new Node(value);
			length++;
			return ;
		}
		//处理在链表头插入数据的情况
		if (index == 1){
			head = new Node(value, head);
			length++;
			return ;
		}
		Node* aheadOfAdd = NULL;
		int cnt = 1;
		//循环找到要插入的结点之前的那个结点
		for (aheadOfAdd=head,cnt=1; aheadOfAdd!=0&&cnt+1next);
		//如果以上循环因为条件“cnt+1value);
		aheadOfAdd->next = new Node(value, aheadOfAdd->next);
		length++;
		//如果向尾部插入了结点，更新tail
		if (aheadOfAdd->next->next == 0) tail = aheadOfAdd->next;
	}
	

	
	void printSelf(){	//打印链表内容
		Node* nodeToPrint = this->head;
		printf("Content of LinkedList:");
		while(nodeToPrint != NULL){
			printf("%d ", nodeToPrint->value);
			if(nodeToPrint == tail)
				printf("tail is reached!\n");
			nodeToPrint = nodeToPrint->next;
		}	
		printf("\n");
	}
	
	//判断链表是否包含某个值
	bool contains(int value){
		for(Node* now=head; now!=0; now=now->next)
			if (now->value == value)
				return true;
		return false;
	}
};

//测试程序
int main(){

	LinkedList* list = new LinkedList();printf("		%d\n", list->length);
	list->addToHead(1);list->printSelf();printf("		%d\n", list->length);
	list->addToHead(2);list->printSelf();printf("		%d\n", list->length);
	list->addToHead(3);list->printSelf();printf("		%d\n", list->length);
	list->addToHead(4);list->printSelf();printf("		%d\n", list->length);
	list->addToTail(100);list->printSelf();printf("		%d\n", list->length);
	list->addToTail(101);list->printSelf();printf("		%d\n", list->length);
	list->addToTail(102);list->printSelf();printf("		%d\n", list->length);
	list->addToTail(103);list->printSelf();printf("		%d\n", list->length);
	list->deleteNode(8);list->printSelf();printf("		%d\n", list->length);
	printf("%d",list->contains(103));
}