数据结构c++实现——线性表的链式结构

1.全部基于c++模板实现。

2.实现了

• 单向链表（link_list.h）
• 循环链表（c_link_list.h）
• 双向链表（d_link_list.h）

//-----------------------------------------------------------------------------------------

• link_list.h

#ifndef LINK_LIST_H
#define LINK_LIST_H

#include <string>

template<typename T>
class Link_list;

template<typename T>
class Node
{
    friend class Link_list<T>;
public:
    Node(){}
    Node(T d, Node* ptr):
        data(d), next(ptr){}
    ~Node(){}

private:
    T data;
    Node* next;
};

template<typename T>
class Link_list
{
public:
    Link_list():count(0) {
        head = new Node<T>();
        head->next = nullptr;
    }
    Link_list(size_t cnt, Node<T>* _head):
        count(cnt), head(_head){}
    ~Link_list(){}

    //链表长度
    size_t size();
    //是否为空
    bool empty();

    //获取元素
    T get(size_t);
    //插入元素
    void insert(size_t, Node<T>*);
    //删除元素
    void remove(size_t);

    //遍历
    void print();

    //查找节点数据位置
    size_t find(T);

private:
    size_t count;
    Node<T>* head;
    //找到当前节点
    Node<T>* find_curr(size_t);
};

#endif // LINK_LIST_H


template<typename T>
size_t Link_list<T>::size()
{
    return count;
}

template<typename T>
bool Link_list<T>::empty()
{
    return count == 0;
}

template<typename T>
T Link_list<T>::get(size_t sz)
{
    Node<T>* result_node_ptr = find_curr(sz);
    return result_node_ptr->data;
}

template<typename T>
void Link_list<T>::insert(size_t sz, Node<T>* node)
{
    Node<T>* curr_node_ptr = find_curr(sz);
    if(curr_node_ptr)
    {
        node->next = curr_node_ptr->next;
        curr_node_ptr->next = node;
        ++count;
    }
}

template<typename T>
void Link_list<T>::remove(size_t sz)
{
    //找到插入处的前驱节点
    Node<T>* pre_node_ptr = find_curr(sz-1);

    pre_node_ptr->next = pre_node_ptr->next->next;
    --count;
}

template<typename T>
void Link_list<T>::print()
{
    for(size_t i = 1; i <= count; ++i)
    {
        auto curr_node = find_curr(i);
        std::cout<<i<<" :"
                 <<curr_node<<" "
                 <<curr_node->data<<std::endl;
    }
}

template<typename T>
size_t Link_list<T>::find(T t)
{
    for(size_t i = 1; i <= count; ++i)
    {
        if(find_curr(i)->data == t)
            return i;
    }
    std::cout<<"no found."<<std::endl;
    return -1;
}

template<typename T>
Node<T>* Link_list<T>::find_curr(size_t sz)
{
    size_t temp = 0;
    Node<T>* curr_node_ptr = head;
    while(temp != sz)
    {
        ++temp;
        curr_node_ptr = curr_node_ptr->next;
    }
    return curr_node_ptr;
}

• c_link_list.h

#ifndef C_LINK_LIST_H
#define C_LINK_LIST_H

#include <string>

template<typename T>
class C_link_list;

template<typename T>
class CNode
{
    friend class C_link_list<T>;
public:
    CNode(){}
    CNode(T d, CNode* ptr):
        data(d), next(ptr){}
    ~CNode(){}

private:
    T data;
    CNode* next;
};

template<typename T>
class C_link_list
{
public:
    C_link_list():count(0) {
        head = new CNode<T>();
        //改动此处即可,让链表构成循环
        head->next = head;
    }
    C_link_list(size_t cnt, CNode<T>* _head):
        count(cnt), head(_head){}
    ~C_link_list(){}

    //链表长度
    size_t size();
    //是否为空
    bool empty();

    //获取元素
    T get(size_t);
    //插入元素
    void insert(size_t, CNode<T>*);
    //删除元素
    void remove(size_t);

    //遍历
    void print();

    //查找节点数据位置
    size_t find(T);

private:
    size_t count;
    CNode<T>* head;
    //找到当前节点
    CNode<T>* find_curr(size_t);
};

#endif // C_LINK_LIST_H

template<typename T>
size_t C_link_list<T>::size()
{
    return count;
}

template<typename T>
bool C_link_list<T>::empty()
{
    return count == 0;
}

template<typename T>
T C_link_list<T>::get(size_t sz)
{
    CNode<T>* result_node_ptr = find_curr(sz);
    return result_node_ptr->data;
}

template<typename T>
void C_link_list<T>::insert(size_t sz, CNode<T>* node)
{
    CNode<T>* curr_node_ptr = find_curr(sz);
    if(curr_node_ptr)
    {
        node->next = curr_node_ptr->next;
        curr_node_ptr->next = node;
        ++count;
    }
}

template<typename T>
void C_link_list<T>::remove(size_t sz)
{
    //找到插入处的前驱节点
    CNode<T>* pre_node_ptr = find_curr(sz-1);

    pre_node_ptr->next = pre_node_ptr->next->next;
    --count;
}

template<typename T>
void C_link_list<T>::print()
{
    for(size_t i = 1; i <= count; ++i)
    {
        auto curr_node = find_curr(i);
        std::cout<<i<<" :"
                 <<curr_node<<" "
                 <<curr_node->data<<std::endl;
    }
}

template<typename T>
size_t C_link_list<T>::find(T t)
{
    for(size_t i = 1; i <= count; ++i)
    {
        if(find_curr(i)->data == t)
            return i;
    }
    std::cout<<"no found."<<std::endl;
    return -1;
}

template<typename T>
CNode<T>* C_link_list<T>::find_curr(size_t sz)
{
    size_t temp = 0;
    CNode<T>* curr_node_ptr = head;
    while(temp != sz)
    {
        ++temp;
        curr_node_ptr = curr_node_ptr->next;
    }
    return curr_node_ptr;
}

• d_link_list.h

#ifndef D_LINK_LIST_H
#define D_LINK_LIST_H

#include <string>

template<typename T>
class D_link_list;

template<typename T>
class DNode
{
    friend class D_link_list<T>;
public:
    DNode(){}
    DNode(T d, DNode* n_ptr = nullptr, DNode* p_ptr = nullptr):
        data(d), next(n_ptr), prior(p_ptr){}
    ~DNode(){}
    //延迟初始化
    void init(DNode &n1, DNode &n2, DNode &n3){
        n1.next = &n2;
        n1.prior = nullptr;
        n1.data = "i";

        n2.next = &n3;
        n2.prior = &n1;
        n2.data = "like";

        n3.next = nullptr;
        n3.prior = &n2;
        n3.data = "this";
    }

private:
    T data;
    DNode* next;
    DNode* prior;
};


template<typename T>
class D_link_list
{
public:
    D_link_list():count(0) {
        head = new DNode<T>();
        head->next = nullptr;
        head->prior = nullptr;
    }
    D_link_list(size_t cnt, DNode<T>* _head):
        count(cnt), head(_head){}
    ~D_link_list(){}

    //链表长度
    size_t size();
    //是否为空
    bool empty();

    //获取元素
    T get(size_t);
    //插入元素
    void insert(size_t, DNode<T>*);
    //删除元素
    void remove(size_t);

    //遍历
    void print();

    //查找节点数据位置
    size_t find(T);
private:
    size_t count;
    DNode<T>* head;
    DNode<T>* find_curr(size_t);
};

#endif // D_LINK_LIST_H


template<typename T>
size_t D_link_list<T>::size()
{
    return count;
}

template<typename T>
bool D_link_list<T>::empty()
{
    return count == 0;
}

template<typename T>
T D_link_list<T>::get(size_t sz)
{
    DNode<T>* result_node_ptr = find_curr(sz);
    return result_node_ptr->data;
}

template<typename T>
void D_link_list<T>::insert(size_t sz, DNode<T>* node)
{
    DNode<T>* curr_node_ptr = find_curr(sz);
    //在末尾插入
    if(curr_node_ptr->next == 0)
    {
        curr_node_ptr->next = node;
        node->prior = curr_node_ptr;
        node->next = nullptr;
        ++count;
    }
    //在中间插入
    else
    {
        node->prior = curr_node_ptr;
        node->next = curr_node_ptr->next;
        curr_node_ptr->next->prior = node;
        curr_node_ptr->next = node;
        ++count;
    }
}

template<typename T>
void D_link_list<T>::remove(size_t sz)
{
    //找到插入处的前驱节点
    DNode<T>* pre_node_ptr = find_curr(sz-1);
    //在末尾删除
    if(pre_node_ptr->next->next == 0)
    {
        pre_node_ptr->next = nullptr;
        --count;
    }
    //在中间删除
    else
    {
        pre_node_ptr->next->next->prior = pre_node_ptr;
        pre_node_ptr->next = pre_node_ptr->next->next;
        --count;
    }
}

template<typename T>
void D_link_list<T>::print()
{
    for(size_t i = 1; i <= count; ++i)
    {
        auto curr_node = find_curr(i);
        std::cout<<i<<" :"
                 <<curr_node<<" "
                 <<curr_node->data<<std::endl;
    }
}

template<typename T>
size_t D_link_list<T>::find(T t)
{
    for(size_t i = 1; i <= count; ++i)
    {
        if(find_curr(i)->data == t)
            return i;
    }
    std::cout<<"no found."<<std::endl;
    return -1;
}

template<typename T>
DNode<T>* D_link_list<T>::find_curr(size_t sz)
{
    size_t temp = 0;
    DNode<T>* curr_node_ptr = head;
    while(temp != sz)
    {
        ++temp;
        curr_node_ptr = curr_node_ptr->next;
    }
    return curr_node_ptr;
}

• main.cpp

#include <iostream>
#include "link_list.h"
#include "c_link_list.h"
#include "d_link_list.h"
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
//------------------------------------------------------------------------------------------------
//link_list.h
//    Node<string> n3("this", NULL), n2("like", &n3), n1("i", &n2);
//    Link_list<string> l1;

//    l1.insert(0, &n1);
//    l1.insert(1, &n2);
//    l1.insert(2, &n3);

//    l1.print();
//    cout<<"---------------------"<<endl;
//    cout<<l1.empty()<<endl;
//    cout<<l1.get(2)<<endl;
//    cout<<l1.find("like")<<endl;
//    cout<<l1.size()<<endl;
//    cout<<"---------------------"<<endl;
//    l1.remove(3);
//    l1.print();

//------------------------------------------------------------------------------------------------
//c_link_list.h
//    CNode<string> n3("this", NULL), n2("like", &n3), n1("i", &n2);
//    C_link_list<string> l1;

//    l1.insert(0, &n1);
//    l1.insert(1, &n2);
//    l1.insert(2, &n3);

//    l1.print();
//    cout<<"---------------------"<<endl;
//    cout<<l1.empty()<<endl;
//    cout<<l1.get(2)<<endl;
//    cout<<l1.find("like")<<endl;
//    cout<<l1.size()<<endl;
//    cout<<"---------------------"<<endl;
//    l1.remove(3);
//    l1.print();

//------------------------------------------------------------------------------------------------
//d_link_list.h
    DNode<string> n3, n2, n1;
    n1.init(n1, n2, n3);
    D_link_list<string> l1;

    l1.insert(0, &n1);
    l1.insert(1, &n2);
    l1.insert(2, &n3);

    l1.print();
    cout<<"---------------------"<<endl;
    cout<<l1.empty()<<endl;
    cout<<l1.get(2)<<endl;
    cout<<l1.find("like")<<endl;
    cout<<l1.size()<<endl;
    cout<<"---------------------"<<endl;
    l1.remove(3);
    l1.print();

    return 0;
}