顺序表（数组型）

顺序表（顺序存储和链形）

顺序存储

//顺序表基本运算算法
#include <stdio.h>
#include <malloc.h>
#define MaxSize 50
typedef int ElemType; 
typedef struct //定义顺序表的结构体
{
   ElemType data[MaxSize];  //存放顺序表元素
   int length; //存放顺序表的长度
} SqList;
//建立且初始化（这里指向赋值）顺序表
//这里的n控制了初始化时的顺序表长度
void CreateList(SqList *&L,ElemType a[],int n)
{
    int i = 0;
    int m = 0;
    while(i<n)
    {
        L->data[m] = a[i];
        m++;
        i++;
    }
    L->length = m;
}
//初始化一个顺序表框架
void InitList(SqList *&L)
{
	L = (SqList*)malloc(sizeof(SqList));
    L->length = 0;//定义一个顺序表实际物理长度为0
}
//释放顺序表（实际上是释放了结构体变量的）的空间
void DestroyList(SqList *&L)
{
	free(L);
}
//判断目标顺序表是否为空
bool ListEmpty(SqList *L)
{

	return(L->length == 0);
}
//统计顺序表的长度
int ListLength(SqList *L)
{
	return(L->length);
}
//输出目标顺序表
void DispList(SqList *L)
{
    printf("L:");
	 for(int i=0;i<L->length;i++)
     {
         printf("%d ",L->data[i]);
     }

}
//从目标顺序表中获取索引位为（i-1)，物理位为i的元素e
bool GetElem(SqList *L,int i,ElemType &e)
{ 
    if(i<1 || i>L->length)
    {
        return false;
    }
    else
    {
        e = L->data[i-1];
        return true;
    }
}
//查找目标顺序表中是否存在元素e，存在时返回e元素的物理位置索引
int LocateElem(SqList *L,ElemType e)
{
    int i = 0;
    while(i<L->length && L->data[i] != e)
    {
        i++;
    }
    if(i>=L->length)
    {
        return 0;
    }
    else
    {
        return i+1;
    }
}
//在合法可以插入的位置上，插入元素e
bool ListInsert(SqList *&L,int i,ElemType e)
{
    int j;
	 if(i<1 || i>L->length+1 || L->length == MaxSize)
     {
         return false;
     }
     i--;
     for(j=L->length;j>i;j--)
     {
         L->data[j] = L->data[j-1];
     }
     L->data[i] = e;
     L->length++;
     return true;
}
//在合法可以删除的位置上，删去目标元素e
bool ListDelete(SqList *&L,int i,ElemType &e)
{
    int j;
    if(i<1 || i>L->length)
    {
        return false;
    }
    i--;
    e = L->data[i];
    for(j=i;j<L->length-1;j++)
    {
        L->data[j] = L->data[j+1];
    }
    L->length--;
    return true;
}
int main()
{
    int a[10] = {1,2,2,1,0,2,4,2,3,1};//给一组初始的数组a，将按a数组的元素顺序建立顺序表
    int max=sizeof(a)/sizeof(int);//计数元素个数
    SqList *L;
	InitList(L);
    CreateList(L,a,max);
    DispList(L);
    DestroyList(L);
	return 1;
}

#### 顺序表的存储密度比较高。所谓的存储密度是指节点中数据元素本身所占的存储量和整个节点占用的存储量的比值，即：

存储密度 = 节点中的数据元素所占的存储量/整个节点所占的存储量

一般来说，存储密度越大，存储空间的空间利用率越高，顺序表（数组）的存储密度为1，每个顺序表的元素中存储一个线性表元素；链表的存储密度小于1，空间利用率小于数组型的顺序存储。

//顺序表基本运算算法
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
    struct LNode *next;
} LinkNode;
//单链表初始化
void InitList(LinkNode *&L)
{
    L = (LinkNode *)malloc(sizeof(LinkNode));
    L->next = NULL;
}
//空表时元素插入（头插法和尾插法）
void CreateListF(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s;
    for(int i=0;i<n;i++)
    {
        s = (LinkNode *)malloc(sizeof(LinkNode));
        s->data = a[i];
        s->next = L->next;
        L->next = s;
    }
}
void CreateListR(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    r = (LinkNode *)malloc(sizeof(LinkNode));
    r = L;
    for(int i = 0;i<n;i++)
    {
    	s = (LinkNode *)malloc(sizeof(LinkNode));
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}
//求链表长度
int ListLength(LinkNode *L)
{
    int n= 0;
    LinkNode *p =L;
    while(p->next != NULL)
    {
        n++;
        p = p->next;
    }
    return n;
}
//判断是否为空链
bool ListEmpty(LinkNode *L)
{
    return (L->next == NULL);
}
//输出线性表
void DispList(LinkNode *L)
{
    LinkNode *p = L->next;
    while(p != NULL)
    {
        printf("%d",p->data);
        p = p->next;
    }
    printf("\n");
}
//按序号求线性表中的元素
bool GetElem(LinkNode *L,int i,ElemType &e)
{
    int j = 0;//规定头结点的序号为0
    LinkNode *p = L;
    if(i<=0)
    {
        return false;
    }
    while(j<i && p != NULL)
    {
        j++;
        p = p->next;
    }
    if(p == NULL)
    {
        return false;
    }
    else
    {
        e = p->data;
        return true;
    }
}
//按元素值查找,返回对应元素值的逻辑序号i(物理位置)
int LocateElem(LinkNode *L,ElemType e)
{
 	int i = 1;
    LinkNode *p = L->next;
    while(p != NULL && p->data != e)
    {
        p = p->next;
        i++;
    }
    if(p == NULL)
    {
        return 0;
    }
    else
    {
        return i;
    }
}
//插入元素（非空表）,在序号为i的元素后插入e
bool ListInsert(LinkNode *&L,int i,ElemType e)
{
    int j = 0;
    LinkNode *p = L,*s;
    if(i<=0)
    {
        return false;
    }
    while(j<i-1 && p!= NULL)
    {
        j++;
        p = p->next;
    }
    if(p == NULL)
    {
        return 0;
    }
    else
    {
        s = (LinkNode *)malloc(shizeof(LinkNode));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}
//删除数据元素，删去序号为i的节点，且返回其值
bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
    int j= 0;
    LinkNode *p = L;
    LinkNode *s;
    if(i<=0)
    {
        return false;
    }
    while(j<i-1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if(p == NULL)
    {
        return false;
    }
    else
    {
        s = p->next;
        if(s == NULL)
        {
            return false;
        }
        else
        {
            e = s->data;
            p->next = s->next;
            free(s);
            return true;
        }
    }
}
//单链表的销毁
void DestroyList(LinkNode *&L)
{
    LinkNode *pre = L;
    LinkNode *p = L->next;
    while(p != NULL)
    {
        free(pre);
        pre = p;
        p = p->next;
    }
    free(pre);//尾结点释放
}