链表系列文章(一)

参考 http://www.cnblogs.com/skywang12345/p/3561803.html在此致谢！

采用C++，实现了单链表和双向循环链表：

1. 单链表

#ifndef SINGLE_LIST_H
#define SINGLE_LIST_H

#ifndef INT_MAX
#define INT_MAX 2147483647
#define INT_MIN (-INT_MAX - 1)
#endif
#define ERROR INT_MIN
#define OK 0
#ifndef NULL
#define NULL 0
#endif
template<class T>
struct ListNode {
    T var;
    ListNode<T> *next;
    ListNode() : next(NULL) { }
    ListNode(T v, ListNode<T> *p = NULL) {
        var = v;
        next = p;
    }
};

template<class T>
class Mylist {
public:
    Mylist();
    ~Mylist();
    
    int size();
    bool empty();
    
    int insert(int i, T t);
    int append(T t);
    int insert_first(T t);
    
    T get(int i);
    
    int erase(int i);

private:
    ListNode<T> *head;    
    int len;
};
template<class T>
Mylist<T>::Mylist() {
    len = 0;
    head = new ListNode<T>();
}
template<class T>
Mylist<T>::~Mylist() {
    if(head) {
        int i = 0;
        ListNode<T> *p = NULL;
        while(i++ < len) { 
            p = head->next; 
            head->next = p->next;
            delete p;
        }
    }
    delete head;
}
template<class T>
int Mylist<T>::size() {
    return len;
}
template<class T>
bool Mylist<T>::empty() {
    return 0 == len;
}
template<class T>
int Mylist<T>::insert(int i, T t) {
    if(i < 1 || i > len && len) return ERROR;

    ListNode<T> *p = head;
    int j = 1;
    while(p && j++ < i) { p = p->next; }
    
    ListNode<T> *s = p->next;
    p->next = new ListNode<T>(t);
    p->next->next = s; 
    
    len++;
    return OK;
}
template<class T>
int Mylist<T>::append(T t) {
    ListNode<T> *p = head;
    int j = 0;
    while(p && j++ < len) { p = p->next; }
    p->next = new ListNode<T>(t);
    len++;
    return OK;
}
template<class T>
int Mylist<T>::insert_first(T t) {
    return insert(1, t); 
}
template<class T>
T Mylist<T>::get(int i) {
    if(i < 1 || i > len) return ERROR;
    ListNode<T> *p = head->next;
    int j = 1;
    while(p && j < i) { p = p->next; j++; }
    return p->var;
}
template<class T>
int Mylist<T>::erase(int i) {
    if(i < 1 || i > len) return ERROR;
    ListNode<T> *p = head;
    int j = 1;
    while(p && j < i) { p = p->next; j++; }
    
    ListNode<T> *s = p->next;
    p->next = s->next;
    delete s;
    
    len--;
    return OK;
}

#endif

2. 双向循环链表

#ifndef BI_LINK_H
#define BI_LINK_H

#ifndef INT_MAX
#define INT_MAX 0x8fffffff
#define INT_MIN (-INT_MAX - 1)
#endif
#define ERROR INT_MIN
#define OK 0
#ifndef NULL
#define NULL 0
#endif

template<class T>
struct BLinkNode {
    T var;
    BLinkNode<T> *prev;
    BLinkNode<T> *next;
    BLinkNode() : prev(NULL), next(NULL) { }
    BLinkNode(T v, BLinkNode<T> *p = NULL, BLinkNode<T> *n = NULL) : var(v), prev(p), next(n) { }
};

template<class T>
class Bilink {
public:
    Bilink();
    ~Bilink();
    
    int size();
    bool empty();

    T get(int index);
    T get_first();
    T get_last();

    int insert(int index, T t);
    int insert_first(T t);
    int append_last(T t);

    int erase(int index);
    int erase_first();
    int erase_last();
private:
    int len;
    BLinkNode<T> *head;
};

template<class T>
Bilink<T>::Bilink():len(0) {
    head = new BLinkNode<T>();
    head->prev = head->next = head;
}
template<class T>
Bilink<T>::~Bilink() {
    BLinkNode<T> *p = NULL;
    int i = 0;
    while(i++ < len) {
        p = head->next;
        head->next = p->next;
        delete p;
    }
    delete head;
}
template<class T>
int Bilink<T>::size() {
    return len;
}
template<class T>
bool Bilink<T>::empty() {
    return 0 == len;
}
template<class T>
T Bilink<T>::get(int index) {
    if(index < 1 || index > len) return head->var;
    int i = 0;
    BLinkNode<T> *p = head;
    while(i++ < index) {
        p = p->next;
    }
    return p->var;
}
template<class T>
T Bilink<T>::get_first() {
    if(len) {
        return head->next->var;
    }
    return head->var;
}
template<class T>
T Bilink<T>::get_last() {
    if(len) {
        return head->prev->var;
    }
    return head->var;
}
template<class T>
int Bilink<T>::insert(int index, T t) {
    if(index < 1 || index > len && len) return ERROR;
    if(index == 1) return insert_first(t);
    int mid = (len + 1) >> 1;
    BLinkNode<T> *p = head;
    BLinkNode<T> *s = new BLinkNode<T>(t);
    int i = 1;
    if(index <= mid) {
        while(i++ < index) { p = p->next; }
        s->prev = p;
        s->next = p->next;
        p->next->prev = s;
        p->next = s;
    }
    else {
        while(i++ <= index) { p = p->prev; }
        s->next = p;
        s->prev = p->prev;
        p->prev->next = s;
        p->prev = s;
    }
    len++;
    return OK;
}
template<class T>
int Bilink<T>::insert_first(T t) {
    BLinkNode<T> *s = new BLinkNode<T>(t);
    BLinkNode<T> *p = head;
    s->prev = p;
    s->next = p->next;
    p->next->prev = s;
    p->next = s;
    len++;
    return OK;
}
template<class T>
int Bilink<T>::append_last(T t) {
    BLinkNode<T> *s = new BLinkNode<T>(t);
    BLinkNode<T> *p = head;
    s->prev = p->prev;
    s->next = p;
    p->prev->next = s;
    p->prev = s;
    len++;
    return OK;
}
template<class T>
int Bilink<T>::erase(int index) {
    if(index < 1 || index > len) { return ERROR; }
    BLinkNode<T> *p = head;
    int mid = len >> 1;
    int i = 1;
    if(index <= len) {
        while(i++ < index) { p = p->next; }
        BLinkNode<T> *s = p->next;
        s->next->prev = p;
        p->next = s->next;
        delete s;
    }
    else {
        while(i++ < index) { p = p->prev; }
        BLinkNode<T> *s = p->prev;
        s->prev->next = p;
        p->prev = s->prev;
        delete s;
    }
    len--;
    return OK;
}
template<class T>
int Bilink<T>::erase_first() {
    if(!len) return ERROR;
    BLinkNode<T> *p = head;
    BLinkNode<T> *s = p->next;
    s->next->prev = p;
    p->next = s->next;
    len--;
    return OK;
}
template<class T>
int Bilink<T>::erase_last() {
    if(!len) return ERROR;
    BLinkNode<T> *p = head;
    BLinkNode<T> *s = p->prev;
    s->prev->next = p;
    p->prev = s->prev;
    len--;
    return OK;    
}

#endif

由于本人水平有限，文章中难免有不当和错误之处，欢迎大家批评指正，愿共同进步！！！