「数据结构」: 链表的实现

此次实现的数据结构仍为线性表，物理结构上采用链表结构，与顺序表相比有以下特点：

优点：不再有存储空间上的限制（主要取决了机器的存储能力，不会提前分配一定量的空间）

缺点：失去了随机存储特性，若只用简单的链表则查找、插入、删除都将占用O(K)的时间(K为操作位置)

使用C＋＋语言实现。

代码如下：

//linkList.h
#ifndef __LINKLIST__
#define __LINKLIST__
#include <iostream>
#include "excp.h"
using namespace std;

template<class T>
class linkList;

template<class T>
class Node {
public:
    Node(const T& newData) 
    {
        data = newData;
        next = NULL;
    }
    friend class linkList<T>;
private:
    T data;
    Node<T> *next;
};

template<class T>
class linkList{
public:
    linkList(Node<T>* first){head = first;}
    linkList(){head = 0;}
    ~linkList();
    bool isEmpty() const {return head == 0;}
    int Length() const;
    bool findElement(int k, T& x) const;
    int searchElement(const T& x) const;
    linkList<T>& deleteElement(int k, T& x);
    linkList<T>& insertElement(int k, const T& x);
    void output(ostream& out) const;
private:
    Node<T> *head;
};

//deconstructor
template<class T>
linkList<T>::~linkList()
{
    Node<T> *next;
    while (head)
    {
        next = head->next;
        delete head;
        head = next;
    }
}

//get the length of the linkList
template<class T>
int linkList<T>::Length() const
{
    Node<T> *cur = head;
    int len = 0;
    while (cur)
    {
        len++;
        cur = cur->next;
    }
    return len;
}

//find function, x carry the value of the index-k
template<class T>
bool linkList<T>::findElement(int k, T& x) const
{
    if (k<1)
        return false;
    Node<T> *cur = head;
    int index = 1;
    while (index<k && cur)
    {
        index++;
        cur = cur->next;
    }
    if (cur)
    {
        x = cur->data;
        return true;
    }
    return false;
}


//search function
template<class T>
int linkList<T>::searchElement(const T& x) const
{
    Node<T> *cur = head;
    int index = 1;
    while (cur)
    {
        if (x == cur->data)
            return index;
        index++;
        cur = cur->next;
    }
    return 0;
}

//call the override function later
template<class T>
void linkList<T>::output(ostream& out) const
{
    Node<T> *cur = head;
    while (cur)
    {
        out<<cur->data<<" ";
        cur = cur->next;
    }
    out<<endl;
}

//override
template<class T>
ostream& operator<<(ostream& out, const linkList<T>& x)
{
    x.output(out);
    return out;
}

//delete operation
template<class T>
linkList<T>& linkList<T>::deleteElement(int k, T& x)
{
    if (k<1 || !head)
        throw OutOfBounds();
    Node<T> *cur = head;
    if (k == 1)
    {
        head = head->next;
        x = cur->data;
        delete cur;
        return *this;
    }
    else
    {
         int index = 1;
         //find the prior fo the kth node
         while (index<k-1 && cur)
         {
             index++;
             cur = cur->next;
         }
         if (!cur || !(cur->next))
             throw OutOfBounds();
         Node<T> *de = cur->next;
         cur->next = de->next;
         x = de->data;
         delete de;
         return *this;
    }
}

//insert operation
template<class T>
linkList<T>& linkList<T>::insertElement(int k, const T& x)
{
    if (k<=0)
        throw OutOfBounds();
    Node<T> *newNode = new Node<T>(x);
    if (k==1)
    {
        newNode->next = head;
        head = newNode;
    }
    else
    {
        Node<T> *cur = head;
        for (int index=1; index<k-1; index++)
            cur = cur->next;
        if (!cur)
        {
            delete newNode;
            throw OutOfBounds();
        }
        newNode->next = cur->next;
        cur->next = newNode;
    }
    return *this;
}
#endif

//excep.h异常类
#ifndef _EXCP_
#define _EXCP_
#include <new>
using namespace std;

class OutOfBounds {
public:
    OutOfBounds(){}
};

class FullMemery {
public:
    FullMemery(){}
};

void my_new_handler()
{
    throw FullMemery();
}

new_handler old_handler = set_new_handler(my_new_handler);
#endif

//linkList.cpp测试主函数
#include <iostream>
#include "linkList.h"
#include "excp.h"
using namespace std;
int main()
{
    try{
        linkList<int> L;
        cout<<"Length = "<<L.Length()<<endl;
        cout<<"IsEmpty = "<<L.isEmpty()<<endl;
        L.insertElement(1 ,2).insertElement(2, 6).insertElement(2, 3).
        insertElement(3, 6);
        cout<<"List is "<<L<<endl;
        cout<<"IsEmpty ="<<L.isEmpty()<<endl;
        int c;
        L.findElement(1, c);
        cout<<"First element is "<<c<<endl;
        cout<<"Length = "<<L.Length()<<endl;
        L.deleteElement(1, c).deleteElement(3, c);
        cout<<"Delete element is "<<c<<endl;
        cout<<"List is "<<L<<endl;
    }
    catch(...)
    {
        cerr<<"This is a error"<<endl;
    }
    return 0;
}

总结：

1、对于表的下标起始位置要统一，本次程序采用起始下标为1。

2、利用友元类的访问权限，但要适度。

3、注意处理内存垃圾。