C++的单链表实现

简易的单链表实现

头文件：

#include<iostream>
using namespace std;
typedef int ElementType;

class LinkList

{

private:

 class Node

 {

 public:

 ElementType data;

 Node * next;

 Node():next(0) {}//默认构造函数

 Node(ElementType dataValue):data(dataValue), next(0){}//显值构造函数

 };

public:

 typedef Node * NodePointer;

 LinkList();   //构造函数

 LinkList(const LinkList & origList);//复制构造函数

 ~LinkList();  //析构函数

 void release();

 const LinkList & operator=(const LinkList & rightSide); //赋值运算符重载

 bool empty();  //链表判空

 void insert(ElementType dataVal, int index); //在链表指定位置插入节点

 void erase(int index);  //删除链表中指定位置的节点

 NodePointer search(ElementType dataVal); //查找链表中指定值的节点

 void display(ostream & out) const;//输出链表节点值

 int nodeCount();   //计算节点个数

 void reverse();      //链表反转，即尾结点变为链表第一个节点

 bool ascendingOrder();  //判断链表是否为升序排列

 void ListMerge(LinkList & templist);//链表B合并到链表A末尾

 void MergeList(LinkList & listA,LinkList & listB);//链表A和链表B合并到链表C上

 ElementType get(NodePointer temp); 

private:

 NodePointer first; //指向第一个节点的指针

 int mySize; //节点的数目

 friend ostream& operator<<(ostream& out, const LinkList& List);

friend istream& operator>>(istream& in, LinkList& List);
};

源文件：

#include<iostream>
#include"LinkList.h"
using namespace std;
ostream & operator<<(ostream & out, const LinkList& List){
	//插入运算符重载（可选做）
	LinkList::NodePointer ptr=List.first;
	while(ptr!=0){
		out<<ptr->data<<' ';
		ptr=ptr->next;
	}
	out<<endl;
	return out;
}
istream & operator>>(istream & in, LinkList &List){
	//提取运算符重载（可选做）
	ElementType x,y;//x为输入的节点个数，y为输入的值
	cout<<"请输入节点个数"<<endl;
	in>>x;
	for(int i=0;i<x;i++){
		cout<<"请输入"<<i+1<<"的值"<<endl;
		in>>y;
		List.insert(y,i);
	}
	return in;
}
LinkList::LinkList(){
	mySize = 0;
	first = 0;
}
LinkList::LinkList(const LinkList& origList){
	if(origList.mySize == 0){
		first = 0;
		mySize = 0;
		return;
	}
	this->mySize = origList.mySize;
	NodePointer ptr =  new Node(origList.first->data);
	first=ptr;
	int index=0;
	for(ptr = origList.first->next;ptr!=0;ptr=ptr->next){
		index++;
		this->insert(ptr->data,index);
	}
}
LinkList::~LinkList(){
	this->release();
}
void LinkList::release(){
		NodePointer p =first;
	while(first!=0){
		p=first;
		first=first->next;
		delete p;
	}
}
const LinkList& LinkList::operator=(const LinkList& rightSide){
	int index=0;
	if(rightSide.mySize == 0){
		first=0;
		mySize=0;
		return *this;
	}
	NodePointer ptr = new Node(rightSide.first->data);
	this->first=ptr;
	this->mySize=rightSide.mySize;
	for(ptr = rightSide.first->next;ptr!=0;ptr=ptr->next){
		index++;
		this->insert(ptr->data,index);
	}
	return *this;
}
bool LinkList::empty(){
	if(mySize) return 1;
	else return 0;
}
void LinkList::insert(ElementType dataVal,int index){
	NodePointer ptr=new Node(dataVal);
	if(index>mySize+1){
		cout<<"LinkList out of list"<<endl;
	}else if(index==0){
		mySize++;
		first=ptr;
	}else if(index==mySize){
		mySize++;
		NodePointer ptr2=first;
		while(ptr2->next!=0){
			ptr2=ptr2->next;
		}
		ptr->next=ptr2->next;
		ptr2->next=ptr;
	}//在中间插入
	else{
		int size=0;
		NodePointer ptr2=first;
		while(size!=index-1){
			size++;
			ptr2=ptr2->next;
		}
		ptr->next=ptr2->next;
		ptr2->next=ptr;
	}
}
void LinkList::erase(int index){
	NodePointer predptr = first;
	if(first!=0){
		cout<<"LinkList empty"<<endl;
		return;
	}
	if(index >mySize){
		cout<<"LinkList out of list"<<endl;
		return;
	}
	if(index == 0){
		NodePointer ptr=first;
		first = first->next;
		mySize--;
		delete ptr;
	}else{
		int index2=0;
		for(predptr=first;predptr!=0;predptr=predptr->next){
			index2++;
			if(index2 ==index){
				mySize--;
				NodePointer ptr =predptr->next;
				predptr->next=ptr->next;
				delete ptr;
			}
		}
	}
}
LinkList::NodePointer LinkList::search(ElementType dataVal){
	NodePointer ptr=first;
	while(ptr!=0){
		if(ptr->data==dataVal) return ptr;
	}
}
void LinkList::display(ostream& out) const{
	for(NodePointer ptr=first;ptr!=0;ptr=ptr->next){
		out<<ptr->data<<" ";
	}
	out<<endl;
}
int LinkList::nodeCount(){
	return mySize;
}
void LinkList::reverse(){
	LinkList list;
	list.mySize=mySize;//遍历
	NodePointer ptr=first,p2;
	while(ptr->next!=0){
		p2=new Node(ptr->data);
		p2->next=list.first;
		list.first=p2;
		ptr=ptr->next;
	}
	p2=new Node(ptr->data);
	p2->next=list.first;
	list.first=p2;
	(*this).release();
	*this=list;
}
bool LinkList::ascendingOrder(){
	NodePointer fptr=first,sptr=fptr->next;
	bool flag=1;
	while(sptr!=0){
		if(fptr->data>sptr->data){
			flag=0;
			return flag;
		}
		fptr=fptr->next;
		sptr=sptr->next;
	}
	return flag;
}
void LinkList::ListMerge(LinkList& templist){
	if(first==0){
		new(this) LinkList(templist);
	}else{
		NodePointer p2=this->first;
		while(p2->next!=0){
			p2=p2->next;
		}
		LinkList* p=new LinkList(templist);
		mySize+=templist.mySize;
		p2->next=p->first;
	}
}
void LinkList::MergeList(LinkList& A,LinkList& B){
	this->ListMerge(A);
	this->ListMerge(B);
}
ElementType LinkList::get(NodePointer temp){
	return temp->data;
}
int main(){
	LinkList ListA;
	ListA.insert(0, 0);
	ListA.insert(10, 1);
	ListA.insert(20, 2);
	ListA.insert(30, 3);
	cout << "display测试  " << endl;
	ListA.display(cout);
	ListA.insert(25, 3);
	cout << "插入测试" << '\n' << ListA << endl;
	if (ListA.empty()) cout << "链表非空" << endl;
	else cout << "链表为空" << endl;
	ListA.erase(1);
	cout << "删除测试" << '\n' << ListA << endl;
	cout << "节点个数  " << ListA.nodeCount() << endl;
	ListA.reverse();
	cout << "反转测试  " << ListA << endl;
	if (ListA.ascendingOrder()) cout << "升序" << endl;
	else cout << "非升序" << endl;
	cout << "查找指定值测试" << '\n' << ListA.get(ListA.search(30)) << endl;
	LinkList ListB;
	cin >> ListB;
	ListA.ListMerge(ListB);
	cout << "合并测试  " << ListA << endl;
	LinkList ListC;
	cin >> ListC;
	ListA.MergeList(ListC, ListB);
	cout << "3个合并测试  " << ListA << endl;

	return 0;

 

---

截止2022/10/14，该代码段的

计算链表节点数 有误

链表合并 有误

后续进行修复