线性表

（一）线性表顺序存储结构：

优点：无须为表示表中元素之间的逻辑关系而增加额外的存储空间。

　　　可以快速地存取表中任一位置的元素。

缺点：插入和删除操作需要移动大量元素。

　　   当线性表长度变化较大时，难以确定存储空间的容量。

　　　造成存储空间的"碎片"。

代码如下：

#define MAXSIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int ElemType;
typedef int Status;
typedef struct
{
    ElemType data[MAXSIZE];
    int length;
}SqList;
class SequenceList
{
public:
    Status GetElem(SqList L,int i,ElemType *e);
    Status InsertElem(SqList L,int i,ElemType *e);
    Status DeleteElem(SqList L,int i,ElemType *e);
    Status ModifyElem(SqList L,int i,ElemType *e);
    SequenceList(void);
    ~SequenceList(void);
};
Status GetElem(SqList L,int i,ElemType *e)
{
    if (L.length==0)
    {
        return ERROR;
    }
    if(i<1||i>L.length)
        return ERROR;
    *e=L.data[i-1];
    return OK;
}
Status InsertElem(SqList L,int i,ElemType *e)
{
    if(L.length==MAXSIZE)
        return ERROR;
    if(i<1||i>L.length+1)
        return ERROR;
    if(i<=L.length){
        for (int k=L.length-1; k>=i-1; k--)
        {
            L.data[k+1]=L.data[k];
        }
    }
    L.length++;
    L.data[i-1]=*e;
    return OK;
}

Status DeleteElem(SqList L,int i,ElemType *e)
{
    if(L.length==0)
        return ERROR;
    if(i<1||i>L.length)
        return ERROR;
    *e=L.data[i-1];
    if (i<L.length)
    {
        for (int k= i; k < L.length; k++)
        {
            L.data[i-1]=L.data[i];
        }
    }
    L.length--;
    return OK;
}
Status ModifyElem(SqList L,int i,ElemType *e)
{
    if(i<1||i>L.length)
        return ERROR;
    L.data[i-1]=*e;
    return OK;
}

链式结构：

1. 

typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node *next;
}List;
List *p,*q,*l;

void InitList(List *list){
    list=(List*)malloc(sizeof(List));
    list->next=NULL;
    return ;
}
void InsertFirstList(List *L,ElemType e)
{
    p=(List*)malloc(sizeof(List));
    if(p==NULL)
    {
     cout << "链表为空，插入值失败！" << endl;  
     exit(1);
    }
    p->data=e;
    p->next=L;
    L=p;
    return ;
}
void InsertLastList(List *L,ElemType e)
{
    p=q=(List*)malloc(sizeof(List));
    p=L;
    if(p==NULL)
    {
         cout << "链表为空，插入值失败！" << endl; 
         exit(1);
    }
    while (p->next!=NULL)
    {
        p=p->next;
    }
    q->data=e;
    q->next=p->next;
    p->next=q;
    return;
}
//在第i个位置前面添加
List *Insert(ElemType e,List *L,int i)
{
    p=q=(List*)malloc(sizeof(List));
    if(i==1)
    {
        p->data=e;
        p->next=L;
        return p;
    }
    p=FindKth(i-1,L);
    if (p==NULL)
    {
        cout<<"参数错误！"<<endl;
        return NULL;
    }
    q->data=e;
    q->next=p->next;
    p->next=q;
    return L;

}
List *Delete(int i,List *L)
{
    p=q=(List*)malloc(sizeof(List));
    if(i==1)
    {
        p=L;
        if(L!=NULL)
            L=L->next;    
        else return NULL;
        free(p);
        return L;
    }
    p=FindKth(i-1,L);
    if(p==NULL||p->next==NULL)
    {
        cout<<"位置错误！"<<endl;
        return NULL;
    }
    q=p->next;
    p->next=q->next;
    free(q);
    return L;
}
List *FindKth(int k,List * L)
{
    int i=0;
    p=(List*)malloc(sizeof(List));
    p=L;
    while (&p->next!=NULL&&i<k)
    {
        p=p->next;
        i++;
    }
    if(i==k)return p;
    else
        return NULL;
}
List *Find(ElemType e,List *L)
{
    p=(List*)malloc(sizeof(List));
    p=L;
    while (p->data!=e&&p->next!=NULL)
    {
        p=p->next;
    }
    return p;
}
int GetLength(List *L)
{
    int length=0;
    p=(List*)malloc(sizeof(List));
    p=L;
    while (p->next!=NULL)
    {
        length++;
        p=p->next;
    }
    return length;
}

void DestroyList(List *L)
{
     q = p = (LinkList *)malloc(sizeof(LinkList));  
     p = L;//得到头结点的地址   
     q = p->next;   
     //逐一对结点的内存进行释放！   
     while (q != NULL){  
           p = q;  
           free(q);   
           q = p->next;   
     }   
     free(L);//释放头结点的内存   
     return ;   
}

 广义表：

 

多重链表：

例如 稀疏矩阵