数据结构之——单链表的实现

/*
使用嵌套类实现【单链表】
学习要点：、
（1）实现单链表数据结构的定义以及各种操作
（1）区别深拷贝（另外动态分配内存进行拷贝） 和 浅拷贝（直接拷贝赋值）
（2）实现深拷贝构造和深拷贝赋值函数
（3）实现操作运算符的重载
=    （深拷贝赋值）
<<    输出运算符重载：建立全局函数，在类中定义时可声明为friend函数；
friend函数可访问类中private成员

*/

#include<iostream>
using namespace std;

class List{
public:
//构造函数 和  析构函数
List(void) : m_head(NULL){}
~List(){
clear();
}

// 深度拷贝构造  和  深度拷贝赋值
List(const List& that):m_head(NULL){
for(Node* node = that.m_head; node; node = node->m_next){
this->push_back(node->m_data);
}
}
List& operator=(const List& that){
if(this != &that){
List temp = that;
this->m_head  = temp.m_head;
temp.m_head = NULL;
}
return *this;
}

//清空链表
void clear(void){
for(Node* node = m_head, *next; node; node = next){
next = node->m_next;
delete node;
}
m_head = NULL;
}

//是否为空
bool empty(void) const {
return !m_head;
}

//元素个数
size_t size(void)const{
size_t count = 0;
for(Node* node = m_head; node; node = node->m_next){
count++;
}
return count;
}

//得到首元素
int& front(void){
if(empty()){
throw underflow_error("list under flow");
}
return m_head->m_data;
}

const int& front(void) const{
return const_cast<List*>(this)->front();
}

//插入首元素
void push_front(const int& data){
m_head = new Node(data, m_head);
}

//删除首元素
void pop_front(void){
if(empty()){
throw underflow_error("list under flow");
}
Node* temp =  m_head;
m_head = m_head->m_next;
delete temp;
temp = NULL;
}

//得到尾元素
int& back(void){
if(empty()){
throw underflow_error("list under flow");
}
Node* node = m_head;
while(node){
if(!node->m_next){
return node->m_data;
}
node = node->m_next;
}
}
const int& back(void) const {
return const_cast<List*>(this)->back();

}

//插入尾元素
void push_back(const int& data){
Node* node = m_head;
while(node){
if(!node->m_next){
node->m_next = new Node(data, NULL);
return;
}
node = node->m_next;
}
}

//删除尾元素
void pop_back(void){
if(empty()){
throw underflow_error("list under flow");
}

Node* node = m_head;
while(node){
if(!node->m_next->m_next){
Node* temp = node->m_next;
node->m_next = NULL;
delete temp;
temp = NULL;
break;
}
node = node->m_next;
}
}

//删除某个特定的元素
void remove(const int& data){
while(data == m_head->m_data){
this->pop_front();
}
for(Node* node = m_head; node; node = node->m_next){
if(node->m_next && data == node->m_next->m_data){
Node* temp = node->m_next;
node->m_next = node->m_next->m_next;
delete temp;
temp = NULL;
}
}
}

//打印整个链表
friend ostream& operator<<(ostream& os, const List& list){
for(Node* node = list.m_head; node; node = node->m_next){
os << node;
}
return os;
}

private:
class Node{
public:
int   m_data;
Node* m_next;
Node(int data, Node* next = NULL):m_data(data), m_next(next){}
/* 注意：重载输出/入运算符， 要定义全局函数，在类内定义时可定义为friend函数  */
//打印节点
friend ostream& operator<<(ostream& os, const Node& node){
return os << "["<< node.m_data << "]";
}
};
Node* m_head;

};
//  主函数测试
int main(){
List list;
cout << list.size() << endl;
list.push_front(5);
list.push_front(6);
list.push_front(5);
list.push_front(5);
cout << list.empty() << endl;
list.push_back(21);
list.push_back(22);
cout << list.size() << endl;
cout << list.empty() << endl;
cout << "================" << endl;
cout << list.front() << endl;
cout << list.back() <<endl;
list.pop_front();
list.pop_back();
cout << list.size() << endl;
cout << list.empty() << endl;
cout << "================" << endl;
list.remove(5);
cout << list.size() << endl;
cout << list.empty() << endl;
list.clear();
cout << list.size() << endl;
cout << list.empty() << endl;
return 0;
}