单链表的简单实现

线性表的存储表示有两种：顺序存储（顺序表，是用数组作为表的存储结构）和链表存储

顺序表优点：

• 无需为表示结点间的逻辑关系而增加额外的存储空间，存储利用率高
• 可以方便的进行随机存取顺序表中的任一结点，存取速度块

顺序表缺点：

• 表中插入或者删除某一元素时，为了保持其他元素相对次序不变，平均要移动一半的元素，运行效率低
• 难以确定合适的存储空间，多了造成浪费空间，少了则容易发生溢出

同样的，链表相比顺序，优缺点也就显现出来了。

滑动窗口（指针追赶）：利用指针移动速度的不同实现

线性链表的其他变形：

• 循环链表：表尾结点的link不为NULL，而是指向链表的头结点。判断是否到达表尾 current->link == first。实例：求解约瑟夫环
• 双向链表：每个结点至少三个域，前驱指针、数据、后驱指针。做某些操作是应设置一个标识位去标识搜索方向。

静态链表：为数组中每个元素附加一个链接指针，就形成静态链表结构。允许我们不改变各元素的物理位置，只要重新链接就能够改变这些元素的逻辑顺序

因为正常的数组我们已经使用的够多了，但是链表这样指针形式的还是使用的非常少，这里我就以链表形式，实现单链表。

单链表分为两部分 指针域link 和  数据域data，各个结点之间用各结点的指针域link连接

#include<iostream>
using namespace std;

struct LinkNode{
    int data;
    LinkNode *link;
    LinkNode(LinkNode *ptr = NULL ){
        link = ptr;
    }
    LinkNode(const int& item, LinkNode *ptr = NULL){
        data = item;
        link = ptr;
    }
}; 

class List {
    public:
        LinkNode *first;
    public:
        List(){
            first = new LinkNode;
        }
        List(const int& x){
            first = new LinkNode(x);
        }
        List(List& L){//复制构造函数 
            int value;
            LinkNode *srcptr = L.getHead();
            LinkNode *destptr = first = new LinkNode;
            while(srcptr->link != NULL){
                value = srcptr->link->data;
                destptr->link = new LinkNode(value);
                destptr = destptr->link;
                srcptr = srcptr->link;
            } 
            destptr->link = NULL;
        };
        ~List(){
            makeEmpty();
        }
        void makeEmpty(){//清空链表 
            LinkNode *q;
            while(first->link != NULL){
                q = first->link;
                first->link = q->link;
                delete q;
            }
        };
        int Length() const{
            int len = 0;
            LinkNode    *p = first->link;
            while( p != NULL){
                p = p->link;
                len++;
                
            } 
            return len;
        };
        LinkNode *getHead() const {return first;}
        LinkNode *Search(int x){
            LinkNode *p = first->link;
            while(p!=NULL){
                if(p->data != x){
                    p = p->link;
                }else{
                    break;
                }
            }
            return p;
        };
        LinkNode *Locate(int i){
            if(i<0) return NULL;
            LinkNode *p  = first->link;
            int k = 0;
            while(p != NULL && k < i){
                p = p->link;
                k++;
            }
            return p;
        }
        bool getData(int i, int& x){
            if(i < 0) return NULL;
            LinkNode *p = Locate(i);
            if(p == NULL) return false;
            else{
                x = p->data;
                return true;
            }
        };
        bool setData(int i,int& x){
            if(i<0) return false;
            LinkNode *p = Locate(i);
            if(p!=NULL){
                p->data = x;
                return true;
            }else{
                return false;
            }
        };
        bool Insert(int i,int& x){
            LinkNode *p = Locate(i);
            if(p == NULL) return false; 
            LinkNode *newNode = new LinkNode(x);
            if(newNode == NULL) {
                cout<<"插入失败，存储分配错误"<<endl;
                exit(1);
            } 
            
            newNode->link = p->link;
            p->link = newNode;
            return true;
        };
        bool Remove(int i, int& x){
            LinkNode *p = Locate(i-1);
            if(p == NULL || p->link == NULL){
                return false;
            }
            LinkNode *del = p->link;
            p->link = del->link;
            x = del->data;
            delete del;
            return true;
        };
        bool Isempty() const{
            return first->link == NULL ? true : false;
        }
        bool IsFull()const {
            if(first->link == NULL){
                return false;
            }else{
                return true;
            }
        }
        void Sort();
        void input(){
        };
        void output(){
            LinkNode *p = first->link;
            if(p == NULL){
                cout<<"这是一个空链表"<<endl; 
            } 
            //cout<<"已经到输出了"<<endl; 
            int i=0;
            while(p!=NULL){
                cout<<"链表第"<<i<<"个数据为"<<p->data<<endl;
                i++;
                p = p->link;
            }
        };        
};

int main(){
    //定义的链表，第一个节是从 0 开始 
    LinkNode *first = new LinkNode;;
    
    List list;
    list.first = first;
    cout<<first<<endl;
    
    LinkNode *p = new LinkNode;
    //添加两个结点 
    list.first->link = p;
    p->data = 1;
    LinkNode *p1 = new LinkNode;
    p1->data = 2;
    p->link = p1;

    cout<<"该链表是为空:"<<list.Isempty()<<endl; 
    
    int i;
    cout<<"在 1 的位置插入："; 
    cin>>i; 
    cout<<"第0个元素之后插入成功？："<<list.Insert(1,i)<<endl;
    
    cout<<"1 位置的元素为："<<list.Locate(1)->data<<endl;
    cout<<"链表长度为："<<list.Length()<<endl;
    int o;
    cout<<"设置 0 位置的元素值为：";
    cin>>o; 
    cout<<"设置 0 位置元素的值成功?："<<list.setData(0,o)<<endl;
    cout<<"---------------------"<<endl;
    cout<<"输出单链表："<<endl; 
    list.output();
    
    int t;
    list.getData(1,t);
    cout<<" 1 位置的是:"<<t<<endl;
    list.makeEmpty();//清空链表 
    cout<<"该链表是为空:"<<list.Isempty()<<endl; 
    list.output();//输出链表 
    
    return 0;
}

 运行截图：