线性表的链式实现——单链表

template<typename DataType>
class LinkList{
public:
	LinkList();
	LinkList(DataType a[],int n);
	~LinkList();
	int Length();
	DataType Get(int i);
	int Locate(DataType x);
	void Insert(int i,DataType x);
	DataType Delete(int i);
	int Empty();
	void PrintList();
private:
	Node<DataType> *first; 
}

无参构造

template <typename DataType>
LinkList<DataType>::LinkList(){
	first=new Node<DataType>;
	first->next=nullptr;
}

判空

template<typename DataType>
int LinkList<DataType>::Empty(){
	if(first->next==nullptr)
		return 1;
	return 0;
}

遍历

template <typename DataType>
void LinkList<DataType>::PrintList(){
	Node<DataType> *p=first->next;
	while(p!=nullptr){
		cout<<p->data<<"\t";
		p=p->next;
	}
	cout<<endl;
}

求单链表长度

template <typename DataType>
int LinkList<DataType>::Length(){
	Node<DataType> *p=first->next;
    int count=0;
	while(p!=nullptr){
		p=p->next;
        count++;
	}
	return count;
}

按位查找

template <typename DataType>
DataType LinkList<DataType>::Get(int i){
	Node<DataType> *p=first->next;
	int count=1;
	while(p!=nullptr&&count<i){
		p=p->next;
		count++;
	}
	if(p==nullptr) throw"查找位置错误"
	else return p->data;
}

按值查找

template <typename DataType>
int LinkList<DataType>::Locate(DataType x){
	Node<DataType> *p=first->next;
	int count=1;
	while(p!=nullptr){
		if(p->data==x){
			return count;
		}esle{
			p=p->next;
			count++;
		}
	}
	return 0;
}

插入操作

template <typename DataType>
void LinkList<DataType>::Insert(int i,DataType x){
	Node<DataType> *p=first,*s=nullptr;
	int count=0;
	while(p!=nullptr&&count<i-1){
		p=p->next;
		count++;
	}
	if(p==nullptr) throw"插入位置错误";
	else{
		s=new Node<DataType>;
		s->data=x;
		s->next=p->next;
		p->next=s;
	}
}

建立单链表

头插法

template <typename DataType>
LinkList<DataType>::LinkList(DataType a[],int n){
	first=new Node<DataType>;
	first->next=nullptr;
	for(int i=0;i<n;i++){
		Node<DataType> *s=nullptr;
		s=new Node<DataType>;
		s->data=a[i];
		s->next=first->next;
		first->next=s;
	}
}

尾插法

template <typename DataType>
LinkList<DataType>::LinkList(DataType a[],int n){
	first=new Node<DataType>;
	Node<DataType> *p=first,*s=nullptr;
	for(int i=0;i<n;i++){
		s=new Node<DataType>;
		s->data=a[i];
		p->next=s;
		p=s;
	}
	p->next=nulptr;
}

删除操作

template <typename DataType>
DataType LinkList<DataType>::Delete(int i){
	DataType x;
	Node<DataType> *p=first,*q=nullptr;
	int count=0;
	while(p!=nullptr&&count<i-1){
        p=p->next;
        count++;
    }
    if(p==nullptr||p->next==nullptr){
        throw"删除位置错误"
    }
    else{
        q=p->next;
        x=q->data;
        p->next=q->next;
        delete q;
        return x;
    }
}
	

析构函数

```c++
template <typename DataType>
LinkList<DataType>::~LinkList(){
	Node<DataType> *p=first;
	while(first!=nullptr){
		first=first->next;
		delete p;
		p=first;
	}
}
```

完整代码

using namespace std;
template<class T>
struct Node{
    T data;
    Node<T> *next;
};
template<class T>
class LinkList{
public:
	LinkList();
	LinkList(T a[],int n);
	~LinkList();
	int Length();
	T Get(int i);
	int Locate(T x);
	void Insert(int i,T x);
	T Delete(int i);
	int Empty();
	void PrintList();
private:
    Node<T> *first;
};
template<class T>
LinkList<T>::LinkList(){
    first=new Node<T>;
    first->next=nullptr;
}
template<class T>
LinkList<T>::LinkList(T a[],int n){
    //头插法
    /*
    first=new Node<T>;
    first->next=nullptr;
    for(int i=0;i<n;i++){
        Node<T> *p=nullptr;
        p=new Node<T>;
        p->data=a[i];
        p->next=first->next;
        first->next=p;
    }
    */

    //尾插法
    first=new Node<T>;
    Node<T> *p=first,*s=nullptr;
    for(int i=0;i<n;i++){
        s=new Node<T>;
        s->data=a[i];
        p->next=s;
        p=s;
    }
    p->next=nullptr;
}
template<class T>
LinkList<T>::~LinkList(){
    Node<T> *p=nullptr;
    while(first!=nullptr){
        p=first;
        first=first->next;
        delete p;
    }
}
template<class T>
int LinkList<T>::Length(){
    int cnt=1;
    Node<T> *p=first->next;
    while(p->next!=nullptr){
        cnt++;
        p=p->next;
    }
    return cnt;
}
template<class T>
T LinkList<T>::Get(int i){
    int cnt=1;
    Node<T> *p=first->next;
    while(cnt<i&&p!=nullptr){
        p=p->next;
        cnt++;
    }
    //别漏了还有异常这种情况
    if(p==nullptr) throw"查找位置错误";
    else return p->data;
}
template<class T>
int LinkList<T>::Locate(T x){
    Node<T> *p=first->next;
    int pos=1;
    while(p!=nullptr){
        if(p->data==x)  return pos;
        p=p->next;
        pos++;
    }
    return 0;
}
template<class T>
void LinkList<T>::Insert(int i,T x){
    Node<T> *p=first;
    int cnt=0;
    //要将数据插入到第i个位置，就要找到第i-1个位置再做插入操作
    while(cnt<i-1&&p!=nullptr){
        p=p->next;
        cnt++;
    }
    if(p==nullptr)  throw"插入位置有误";
    else{
        Node<T> *s=new Node<T>;
        s->next=p->next;
        s->data=x;
        p->next=s;
    }

}
template<class T>
T LinkList<T>::Delete(int i){
    Node<T> *p=first;
    int cnt=0;
    //要删除第i个元素，就要找到第i-1个位置，再做删除操作
    while(cnt<i-1&&p!=nullptr){
        p=p->next;
        cnt++;
    }
    //p->next==nullptr：p不存在后继结点
    if(p==nullptr||p->next==nullptr)  throw"删除位置有误";
    else{
        Node<T> *s=p->next;
        T data=s->data;
        p->next=s->next;
        delete s;
        return data;
    }

}
template<class T>
int LinkList<T>::Empty(){
    if(first->next==nullptr)
        return 1;
    return 0;
}
template<class T>
void LinkList<T>::PrintList(){
    Node<T> *p=first->next;
    while(p!=nullptr){
        cout<<p->data<<endl;
        p=p->next;
    }
}