file:LinkedList.hpp

#ifndef LinkedList_hpp
#define LinkedList_hpp

#include 
#include "Node.hpp"

class LinkedList{
public:
    LinkedList();
    ~LinkedList();
    void ClearList();
    bool ListEmpty();
    int ListLength();
    bool getElem(int index,Node *pNode);
    int locateElem(Node *pNode);
    bool preElem(Node *pCurrentNode,Node *pPreNode);
    bool nextElem(Node *pCurrentNode,Node *pNextNode);
    void ListTraverse();
    bool ListInsert(int index,Node *pNode);
    bool ListDelete(int index,Node *pNode);
    bool ListInsertHead(Node *pNode);
    bool ListInsertTail(Node *pNode);
private:
    int m_iLength;
    Node *m_pList;
};

#endif /* LinkedList_hpp */

file:LinkedList.cpp

#include "LinkedList.hpp"
#include 

using namespace std;

LinkedList::LinkedList(){
    m_pList = new Node;
    m_pList->next = NULL;
    m_iLength = 0;
}

bool LinkedList::ListEmpty(){
    return m_iLength==0?true:false;
}

int LinkedList::ListLength(){
    return m_iLength;
}

void LinkedList::ClearList(){
    Node *CurrentNode = m_pList->next;
    while(CurrentNode != NULL){
        Node *temp = CurrentNode->next;
        delete CurrentNode;
        CurrentNode = temp;
    }
    m_pList->next = NULL;
    m_iLength = 0;
}

LinkedList::~LinkedList(){
    ClearList();
    delete m_pList;
    m_pList = NULL;
}

bool LinkedList::ListInsertHead(Node *pNode){
    Node *temp = m_pList->next;
    Node *newNode = new Node;
    if(newNode == NULL){
        return false;
    }
    else{
        m_pList->next = newNode;
        newNode->data = pNode->data;        
        newNode->next = temp;

        m_iLength++;
        return true;
    }
}

bool LinkedList::ListInsertTail(Node *pNode){
    Node *CurrentNode = m_pList;
    while(CurrentNode->next != NULL){
        CurrentNode = CurrentNode->next;
    }
    Node *newNode = new Node;
    if(newNode == NULL){
        return false;
    }
    else{
        CurrentNode->next = newNode;
        newNode->data = pNode->data;
        newNode->next = NULL;

        m_iLength++;
        return true;
    }
}

bool LinkedList::ListInsert(int index, Node *pNode){
    if(index  m_iLength){
        return false;
    }
    else{
        Node *CurrentNode = m_pList;
        for(int k = 0;k next;
        }
        Node *newNode = new Node;
        if(newNode == NULL){
            return false;
        }
        else{
            newNode->data = pNode->data;
            newNode->next = CurrentNode->next;
            CurrentNode->next = newNode;

            m_iLength++;
            return true;
        }
    }
}

bool LinkedList::ListDelete(int index, Node *pNode){
    if(index  m_iLength){
        return false;
    }
    else{
        Node *CurrentNode = m_pList;
        Node *CurrentNodePre = NULL;
        for(int k = 0;k next;
        }
        CurrentNodePre->next = CurrentNode->next;
        pNode->data = CurrentNode->data;
        delete CurrentNode;
        CurrentNode = NULL;
        m_iLength--;
        return true;
    }
}

bool LinkedList::getElem(int index,Node *pNode){
    if(index  m_iLength){
        return false;
    }
    else{
        Node *CurrentNode = m_pList;
        Node *CurrentNodePre = NULL;
        for(int k = 0;k next;
        }
        pNode->data = CurrentNode->data;
        return true;
    }
}

int LinkedList::locateElem(Node *pNode){
    Node *CurrentNode = new Node;
    int count = 0;
    while(CurrentNode->next != NULL){
        CurrentNode = CurrentNode->next;
        if(CurrentNode->data == pNode->data){
            return count;
        }
        else{
            count ++;
        }
    }
    return -1;
}

bool LinkedList::preElem(Node *pCurrentNode,Node *pPreNode){
    Node *CurrentNode = m_pList;
    Node *tempNode = NULL;
    while(CurrentNode->next != NULL){
        tempNode = CurrentNode;
        CurrentNode = CurrentNode->next;
        if(CurrentNode->data == pCurrentNode->data){
            if(tempNode == m_pList){
                return false;
            }
            else{
                pPreNode->data = tempNode->data;
                return true;
            }
        }
    }
    return false;
}

bool LinkedList::nextElem(Node *pCurrentNode,Node *pNextNode){
    Node *CurrentNode = m_pList;
    while(CurrentNode->next != NULL){
        CurrentNode = CurrentNode->next;
        if(CurrentNode->data == pCurrentNode->data){
            if(CurrentNode->next == NULL ){
                return false;
            }
            else{
                pNextNode->data = CurrentNode->next->data;
                return true;
            }
        }
    }
    return false;
}

void LinkedList::ListTraverse(){
    Node *CurrentNode = m_pList;
    int count = 1;
    while(CurrentNode->next != NULL){
        CurrentNode = CurrentNode->next;
        cout printData();
        count ++;
    }
    cout 

file:Node.hpp

#ifndef Node_hpp
#define Node_hpp

#include "Person.hpp"

class Node{
public: 
    void printData();

public:
    Person data;
    Node *next;
    Node *prev;
};

#endif /* Node_hpp */

file:Node.cpp

#include "Node.hpp"
#include 

using namespace std;

void Node::printData(){
    cout 

file:Person.hpp

#ifndef Person_hpp
#define Person_hpp

#include 
#include 

using namespace std;

class Person{
public:
    friend ostream &operator

file:Person.cpp

#include "Person.hpp"
#include 

ostream &operatorname = person.name;
    this->phone = person.phone;
    return *this;
}

bool Person::operator==(Person &person){
    if(this->name == person.name && this->phone == person.phone){
        return true;
    }
    else{
        return false;
    }
}

file:demo.cpp

#include 
#include 
#include "LinkedList.hpp"

using namespace std;

int Menu(){
    //显示通讯录功能菜单
    cout > order;

    return order;
}

void createPerson(LinkedList *pList){
    Node node;
    Person person;
    cout > person.name;
    cout > person.phone;
    node.data = person;
    pList->ListInsertTail(&node);
}

void deletePerson(LinkedList *pList){
    Node node;

    int index = 0;
    cout > index;

    pList->ListDelete(index, &node);
    cout >新建联系人：" >删除联系人：" >浏览通讯录：" ListTraverse();
                break;
            case 4:
                cout >退出通讯录："