【线性表】单链表

SingleLinkedList.h

#ifndef SINGLELINKEDLIST_H
#define SINGLELINKEDLIST_H

#include<iostream>
//list node
template<typename T>
struct list_node{
	typedef list_node<T>* pointer;
	T data;
	pointer next;
	list_node() :next(NULL){}
	list_node(const T value) :data(value), next(NULL){}
};
//SingleLinkedList
template<typename T>
class SingleLinkedList{
public:
	typedef T value_type;
	typedef T* pointer;
	typedef list_node<T>* link_type;
	SingleLinkedList();//constructor
	~SingleLinkedList();//destructor
	void create_head(int n);//head interpolation method,only for T is int,double...  
	void create_tail(int n);//tail interpolation method,only for T is int,double...  
	int get_length();//get length
	bool is_empty(); // whether SingleLinkedList is empty or not
	void traverse();//traverse SingleLinkedList
	void clear();//clear SingleLinkedList
	bool get_elem(int i, pointer value);//get the ith data
	int locate(value_type value);//find the position of value
	bool insert(int i, value_type value);//insert data in the ith place
	bool remove(int i, pointer value);//remove the ith data
	void invert();//invert the SingleLinkedList
private:
	link_type head;
};
//constructor
template<typename T>
SingleLinkedList<T>::SingleLinkedList() :head(new list_node<T>()){}
//destructor
template<typename T>
SingleLinkedList<T>::~SingleLinkedList(){
	clear();
	delete head;
}
//head interpolation method,only for T is int,double...
template<typename T>
void SingleLinkedList<T>::create_head(int n){
	value_type value;
	for (int i = 0; i < n; i++){
		std::cin >> value;
		link_type p = new list_node<T>(value);
		p->next = head->next;
		head->next = p;
	}
}
//tail interpolation method,only for T is int,double...
template<typename T>
void SingleLinkedList<T>::create_tail(int n){
	value_type value;
	link_type q = head;
	for (int i = 0; i < n; i++){
		std::cin >> value;
		link_type p = new list_node<T>(value);
		q->next = p;
		q = p;
	}
}
//get length
template<typename T>
int SingleLinkedList<T>::get_length(){
	int count = 0;
	link_type p = head->next;
	while (p!=NULL){
		p = p->next;
		count++;
	}
	return count;
}
// whether SingleLinkedList is empty or not
template<typename T>
bool SingleLinkedList<T>::is_empty(){
	return head->next == NULL ? true : false;
}
//traverse SingleLinkedList
template<typename T>
void SingleLinkedList<T>::traverse(){
	link_type p = head->next;
	while (p != NULL){
		std::cout << p->data << " ";
		p = p->next;
	}
	std::cout << std::endl;
}
//clear SingleLinkedList
template<typename T>
void SingleLinkedList<T>::clear(){
	link_type p;
	while (head->next != NULL){
		p = head->next;
		head->next = p->next;
		delete p;
	}
}
//get the ith data
template<typename T>
bool SingleLinkedList<T>::get_elem(int i, pointer value){
	int count = 0;
	link_type p = head;
	while (p != NULL&&count < i){
		p = p->next;
		count++;
	}
	if (p == NULL)
		return false;
	*value = p->data;
	return true;
}
//find the position of value
template<typename T>
int SingleLinkedList<T>::locate(value_type value){
	link_type p = head->next;
	int count = 1;
	while (p != NULL){
		if (p->data == value)
			return count;
		p = p->next;
		count++;
	}
	return 0;
}
//insert data in the ith place
template<typename T>
bool SingleLinkedList<T>::insert(int i, value_type value){
	if (i < 1)
		return false;
	int count = 1;
	link_type p = head;
	while (p != NULL&&count < i){
		p = p->next;
		count++;
	}
	if (p == NULL)
		return false;
	link_type q = new list_node<T>(value);
	q->next = p->next;
	p->next = q;
	return true;
}
//remove the ith data	
template<typename T>
bool SingleLinkedList<T>::remove(int i, pointer value){
	if (i < 1)
		return false;
	int count = 1;
	link_type p = head;
	while (p->next != NULL&&count < i){
		p = p->next;
		count++;
	}
	if (p->next == NULL)
		return false;
	link_type q = p->next;
	p->next = q->next;
	*value = q->data;
	delete q;
	return true;
}
//invert the SingleLinkedList
template<typename T>
void SingleLinkedList<T>::invert(){
	link_type p = head->next;
	head->next = NULL;
	link_type q;
	while (p != NULL){
		q = p->next;
		p->next = head->next;
		head->next = p;
		p = q;
	}
}

#endif

main.cpp

#include"SingleLinkedList.h"
using namespace std;

int main(){
	SingleLinkedList<int> int_list;
	cout << int_list.get_length() << endl; //0
	cout << boolalpha << int_list.is_empty() << endl;//true
	for (int i = 0; i < 10; i++){
		int_list.insert(i, i);
	}
	int_list.traverse();//1 2 3 4 5 6 7 8 9 
	int_list.invert();
	int_list.traverse();//9 8 7 6 5 4 3 2 1
	int_list.invert();
	int value;
	if (int_list.get_elem(5, &value))
		cout << "get element succeed,value is " << value << endl;//get element succeed,value is 5
	else
		cout << "get element fail" << endl;

	if (int_list.insert(7, 20))
		cout << "insert succeed" << endl;//insert succeed
	else
		cout << "insert fail" << endl;

	if (int_list.remove(8, &value))
		cout << "remove succeed,remove value is " << value << endl;//remove succeed,remove value is 7
	else
		cout << "remove fail" << endl;
	int_list.traverse();//1 2 3 4 5 6 20 8 9 
	cout << int_list.locate(20) << endl;//7
	cout << int_list.get_length() << endl;//9
	int_list.clear();
	cout << int_list.get_length() << endl;//0

	int_list.create_head(8);
	int_list.traverse();
	int_list.clear();

	int_list.create_tail(8);
	int_list.traverse();
	int_list.clear();

	return 0;
}