动态表头的双向链表

来源：互联网发布：最大公约数的算法编辑：程序博客网时间：2024/05/20 13:10

Description

请实现以下基于双向链表的list类

enum Error_code

{

success,

underflow,

overflow

};

template <class List_entry>

struct Node

{

List_entry entry;

Node<List_entry> *next;

Node<List_entry> *back;

};

template <class List_entry>

class MyList

{

public:

MyList();

~MyList();

// 拷贝构造函数和赋值运算符重载，注意深拷贝与浅拷贝的差异

MyList(const MyList<List_entry> &copy);

void operator =(const MyList<List_entry> &copy);

// 清空list

void clear();

// 判断list是否为空

bool empty() const;

// 判断list是否已满

bool full() const;

// 获取list的元素数量

int size() const;

// 在第position个位置插入值为entry的元素，如果position为0则插入在链表头，依次类推

// 若position < 0 或者 position > count，则返回underflow

Error_code insert(int position, const List_entry &entry);

// 删除第position个位置的元素，并将该元素的值保存在entry中

// 若position < 0 或者 position >= count，则返回underflow

Error_code remove(int position, List_entry &entry);

// 获取第position个位置的元素，保存在entry中

// 若position < 0 或者 position >= count，则返回underflow

Error_code retrieve(int position, List_entry &entry) const;

// 将第position个位置的元素替换为entry

// 若position < 0 或者 position >= count，则返回underflow

Error_code replace(int position, const List_entry &entry);

// 用visit函数遍历list内所有的元素

void traverse(void (*visit)(List_entry &));

protected:

int count; // 记录list内元素数量

mutable int curPosition; // current指针的位置编号

mutable Node<List_entry> *current; // current指针

// 设置current指针的位置，指向第position个位置

void setPosition(int position) const;

};

注意，不需要提交main函数。

Hint

注意，不需要提交main函数。

Problem Source: 第五周 5班

enum Error_code {    success,    underflow,    overflow};template <class List_entry>struct Node {    List_entry entry;    Node<List_entry> *next;    Node<List_entry> * back;    Node<List_entry>() {        next = NULL;        back = NULL;    }    Node<List_entry>(List_entry e, Node<List_entry> * b = NULL, Node<List_entry> * n = NULL) {        entry = e;        next = n;        back = b;    }};template <class List_entry>class MyList {public:    MyList() {        count = 0;        current = NULL;        curPosition = 0;    }    ~MyList() {        clear();    }    // 拷贝构造函数和赋值运算符重载，注意深拷贝与浅拷贝的差异    MyList(const MyList<List_entry> &copy) {        count = 0;        current = NULL;        curPosition = 0;        *this = copy;    }    void operator =(const MyList<List_entry> &copy) {        clear();        if (copy.empty()) return;        Node<List_entry> * copyHead = copy.current;        while (copyHead->back) copyHead = copyHead->back;        current = new Node<List_entry>(copyHead->entry);        while (copyHead->next) {            copyHead = copyHead->next;            current->next = new Node<List_entry>(copyHead->entry, current);            current = current->next;        }        count = copy.count;        curPosition = count - 1;        setPosition(copy.curPosition);    }    // 清空list    void clear() {        if (!current) return;        setPosition(0);        while (current) {            Node<List_entry> * temp = current;            current = current->next;            delete temp;        }        count = 0;        current = NULL;        curPosition = 0;    }    // 判断list是否为空    bool empty() const {return count == 0;}    // 判断list是否已满    bool full() const {  // 试着new一个节点，如果new不了了说明满了        Node<List_entry> * temp = new Node<List_entry>;        if (temp) {            delete temp;            return false;        } else {            return true;        }    }    // 获取list的元素数量    int size() const {return count;}    // 在第position个位置插入值为entry的元素，如果position为0则插入在链表头，依次类推    // 若position < 0 或者 position > count，则返回underflow    Error_code insert(int position, const List_entry &entry) {        if (position < 0 || position > count) return underflow;        Node<List_entry> * temp = new Node<List_entry>(entry);        if (position == 0) {            if (count == 0) {                current = temp;            } else {                setPosition(0);                temp->next = current;                current->back = temp;                current = temp;  // 由于此前调用setPosition函数使得curPosition的位置为0，这里current指针必须和curPosition相对应            }        } else {            setPosition(position - 1);            Node<List_entry> * oriNext = current->next;            current->next = temp;            temp->back = current;            temp->next = oriNext;            if (oriNext) oriNext->back = temp;        }        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;        if (position == 0) {            if (count == 1) {                entry = current->entry;                delete current;                current = NULL;            } else {                setPosition(0);                Node<List_entry> * temp = current;                current = current->next;                current->back = NULL;                entry = temp->entry;                delete temp;            }        } else {            Node<List_entry> * temp;            setPosition(position - 1);            temp = current->next;            current->next = current->next->next;            if (current->next) current->next->back = current;            entry = temp->entry;            delete temp;        }        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> * temp = current;        if (temp == NULL) return;        while (temp->back != NULL) temp = temp->back;        while (temp != NULL) {            visit(temp->entry);            temp = temp->next;        }    }protected:    int count;  // 记录list内元素数量    mutable int curPosition;  // current指针的位置编号    mutable Node<List_entry> *current;  // current指针    // 设置current指针的位置，指向第position个位置    void setPosition(int position) const {        if (position < curPosition) {            while (curPosition != position) {                curPosition--;                current = current->back;            }        } else {            while (curPosition != position) {                curPosition++;                current = current->next;            }        }    }};

0 0