单项链表的实现

实现基于单向链表的list类。

struct node {

     int x;

     int y;

     node(int xx, int yy) {

         x = xx;

         y = yy;

        }

}

 1.构造函数时先设置一个head结点，其指向空。如下：

        

2.插入结点：

当position为0时，本来应该是这样的： 

                                                                                                   

但是，这个函数在这里插入结点时，如果count=0，则将图中position位置看成NULL，那么下面的插入方法仍然成立不受影响。所以这就是设置头结点的优点是所在了，在position=0时插入结点就不需要通过条件判断了（这种判断很容易忘记漏写，导致苦逼的debug），在这里只要通过current找到插入的位置position前的结点，然后将新的结点插在current后面，新结点的next为current->next即可完成insert的工作。

 

3.remove结点：

 如图所示的方法删除position位置的结点，同样是利用head来减少判断步骤。

 

附代码及注释：

#include <iostream>
using namespace std;
enum Error_code {
         success,
         underflow,
         overflow
};
template <class List_entry>
struct Node {
         List_entry entry;
         Node<List_entry> *next;
};
template <class List_entry>
class MyList {
public:
         MyList() {
             head = new Node<List_entry>;//设置一个头结点
             head->entry = 0;
             head->next = NULL;
             count = 0;//当前链表为空（头部之后的结点才是我们存进去的，count指的是我们存进去的结点数）
             curPosition = -1;//头部的位置为-1
             current = head;//当前位置指向链表的头部
         }
         /*设置头部的作用主要体现在insert（int position, const List_entry &entry）,remove(...), retrieve(...),
         replay(...)这些函数里面，详见相关函数*/
         ~MyList() {
             current = NULL;
             curPosition = -1;
             Node<List_entry> *temp = head, *a;
             while (head != NULL) {
                 head = temp->next;
                 a = temp;
                 delete a;
                 temp = head;
             }
             count = 0;
         }
         // 拷贝构造函数和赋值运算符重载，注意深拷贝与浅拷贝的差异
         MyList(const MyList<List_entry> &copy) {
             head = new Node<List_entry>;//this start...
             head->entry = 0;
             head->next = NULL;
             count = 0;
             curPosition = -1;
             current = head;//this end...拷贝构造函数，相当于构造一个MyList()之后将copy这个链表的内容复制进去
             if (copy.count != 0) {//拷贝链表内容
                 count = copy.count;
                 Node<List_entry> *a, *b;
                 a = copy.head->next;
                 b = head;
                 for (int i = 0; i < copy.count; i++) {
                     b->next = new Node<List_entry>;
                     b = b->next;
                     b->entry = a->entry;
                     b->next = NULL;
                     a = a->next;
                 }
             }
         }
         //跟拷贝构造函数不一样，这个函数实现的前提是已经MyList()例如MyList a，然后将copy复制到a
         void operator =(const MyList<List_entry> &copy) {
             if (!empty()) clear();//清空
             if (copy.count != 0) {//同上拷贝链表内容
                 count = copy.count;
                 Node<List_entry> *a, *b;
                 a = copy.head->next;
                 b = head;
                 for (int i = 0; i < copy.count; i++) {
                     b->next = new Node<List_entry>;
                     b = b->next;
                     b->entry = a->entry;
                     b->next = NULL;
                     a = a->next;
                 }
             }
         }
         // 清空list，清空时候保留头结点，数据恢复到原始状态
         void clear() {
             if (!empty()) {
                 Node<List_entry> *temp = head->next, *a;
                 while (temp != NULL) {
                     head->next = temp->next;
                     a = temp;
                     temp = head->next;
                     delete a;
                     count--;
                 }
                 current = head;
                 curPosition = -1;
             }
         }
         // 判断list是否为空
         bool empty() const {
             if (count != 0) return false;
             return true;
         }
         // 判断list是否已满
         bool full() const {
             return false;
         }
         // 获取list的元素数量
         int size() const {
             return count;
         }
         // 在第position个位置插入值为entry的元素，如果position为0则插入在head（head的position为-1）后面，依次类推
         // 若position < 0 或者 position > count，则返回underflow
         Error_code insert(int position, const List_entry &entry) {
             if (position < 0 || position > count) return underflow;
             Node<List_entry> *new_node, *pre, *follow;
             //new一个新的结点
             new_node = new Node<List_entry>;
             new_node->entry = entry;
             //setPosition的作用是设置当前的位置current指向position-1这个位置，在position-1后面插入new_node
             //当position==0时，应该插在头部后面的位置，pre指向头部。若没有head，则需要讨论当position == 0时候的情况，容易漏判断
             setPosition(position - 1);
             pre = current;
             follow = current->next;
             //新结点指向follow，pre前一个结点指向新结点new_node
             new_node->next = follow;
             pre->next = new_node;
             count++;
             return success;
         }
         // 删除第position个位置的元素，并将该元素的值保存在entry中
         // 若position < 0 或者 position >= count，则返回underflow
         Error_code remove(int position, List_entry &entry) {
             if (position < 0 || position >= count) return underflow;
             Node<List_entry> *pre, *now, *follow;
             //去掉position位置的结点，应该让pre指向该位置的前一个，所以应该先找出position-1位置的结点
             setPosition(position - 1);
             pre = current;
             now = current->next;
             entry = now->entry;
             follow = now->next;
             pre->next = follow;
             delete now;//删掉position的结点
             count--;
             return success;
         }
         // 获取第position个位置的元素，保存在entry中
         // 若position < 0 或者 position >= count，则返回underflow
         Error_code retrieve(int position, List_entry &entry) const {
             if (position < 0 || position >= count) return underflow;
             setPosition(position);
             entry = current->entry;
             return success;
         }
         // 将第position个位置的元素替换为entry
         // 若position < 0 或者 position >= count，则返回underflow
         Error_code replace(int position, const List_entry &entry) {
             if (position < 0 || position >= count) return underflow;
             setPosition(position);
             current->entry = entry;
             return success;
         }
         // 用visit函数遍历list内所有的元素
         void traverse(void (*visit)(List_entry &)) {
             Node<List_entry> *a = head->next;
             for (int i = 0; i < count; i++) {
                 (*visit)(a->entry);
                 a = a->next;
             }
         }
protected:
         int count;                                                                          // 记录list内元素数量
         Node<List_entry> *head;                                         // 链表头指针
         mutable int curPosition;                                   // current指针的位置编号
         mutable Node<List_entry> *current;                 // current指针
        // 设置current指针的位置，指向第position个位置
        void setPosition(int position) const {
             if (position < curPosition) {
                 curPosition = -1;
                 current = head;
             }
             for (; curPosition < position; curPosition++) {
                 current = current->next;
             }
         }
};