数据结构（线性表，队列，栈，树，图）

1.线性链表的顺序存储构建（SeqList.h）

顺序表构建

//顺序表构建
#include <stdio.h>
#define MaxSize 100
typedef int DataType;

typedef struct
{
    DataType list[MaxSize];
    int size;
} SeqList;

//初始化顺序表L
void ListInitiate(SeqList *L)
{    
    L->size = 0;      //定义初始数据元素个数
}

//返回顺序表L的当前数据元素个数
int ListLength(SeqList L)    
{
    return L.size;
}

//在顺序表L的位置i（0≤i≤L.size）前插入数据元素值x,插入成功返回1，插入失败返回0
int ListInsert(SeqList *L, int i, DataType x)
{
    int j;
    if(L->size >= MaxSize)
    {
        printf("顺序表已满无法插入! 
");    
        return 0; 
    }
    else if(i < 0 || i > L->size )
    {
        printf("参数i不合法! 
");
        return 0;
    }
    else
    {
        for(j = L->size+1; j > i; j--) 
        L->list[j] = L->list[j-1];               //为插入做准备

        L->list[i] = x;                          //插入
        L->size ++;                    　　　　　　//元素个数加1
                          
        return 1;
    }
}

//删除顺序表L中位置i（0≤i≤L->size-1）的数据元素值并存放到参数x中,删除成功返回1，删除失败返回0
int ListDelete(SeqList *L, int i, DataType *x)    
{ 
    int j;
    if(L->size == 0)
    {
        printf("顺序表已空无数据元素可删! 
");

        return 0;
    }
    else if(i <0 || i > L->size-1)
    {
        printf("参数i不合法");
        return 0;
    }
    else
    {
        *x = L->list[i];                  //保存删除的元素到参数x中

        for(j = i +1; j <= L->size; j++) 
        L->list[j-1] = L->list[j];        //依次前移

        L->size--;                       //数据元素个数减1

        return 1;
    }
}

//取顺序表L中第i个数据元素的值存于x中，成功则返回1，失败返回0
int ListGet(SeqList L, int i, DataType *x)
{
    if(i < 0 || i > L.size-1)
    {
        printf("参数i不合法! 
");
        return 0;
    }
    else
    {
        *x = L.list[i];
        return 1;
    }
}

示例——对顺序表的操作（增删改查）

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
#define ListLenth 50
typedef int DataType;

//定义顺序表的类型SeqList
typedef struct
{
    DataType list[MaxSize];
    int size;
} SeqList;

//初始化数据
void CreList(SeqList *L)
{
    int i;

    L->size=50;
    //顺序表加入数据，依次为0-49
    for(i=0;i<50;i++)
    {
        L->list[i]=i;
    }
}

//初始化顺序表*L
void ListInitiate(SeqList *L)
{
    L->size=0;
}

//返回顺序表L的当前数据元素个数 
int ListLength(SeqList *L)
{
    return L->size;
}

//查找功能，传参——线性表L和查找元素DataType x，成功返回x在L中的序号否则返回-1
int ListLocate(SeqList L,DataType x)
{
    int i=0;
    while(i<L.size&&L.list[i]!=x)
    {
        i++;
    }
    if(i<L.size) 
        return (i);
    else
        return (-1);
}

//插入功能，传参——线性表L、插入位置i和所插入元素x，成功返回1否则返回0
int ListInsert(SeqList *L,int i,DataType x)
{
    int j;
    if(L->size>=MaxSize-1)
    {
        printf("顺序表已满无法插入！
");
        return 0;
    }
    else if(i<0||i>L->size+1)
    {
        printf("参数i不合法！
");
        return 0;
    }
    else
    {
        for(j=L->size;j>i;j--)
        {
            L->list[j]=L->list[j-1];        //为插入做准备
        }
        L->list[i]=x;                    //插入
        L->size++;                        //元素个数加1
        return 1;
    }
}

//删除功能，传参——顺序表L、删除元素的序号i和要返回所删除的元素
int ListDelete(SeqList *L,int i,DataType *x)
{
    int j;
    if(L->size==0)
    {
        printf("顺序表已空无数据元素可删！
");
        return 0;
    }
    else if(i<0||i>L->size-1)
    {
        printf("参数i不合法！
");
        return 0;
    }
    else
    {
        *x=L->list[i];
        for(j=i+1;j<L->size;j++)
        {
            L->list[j-1]=L->list[j];
        }
        L->size--;

        return 1;
    }
}

void ListShow(SeqList L)
{
    int i;
    
    printf("当前List表为
");
    for(i=0;i<L.size;i++)
    {
        printf("%d ",L.list[i]);
    }
    printf("
共%d个元素

",L.size);
    
    return ;
}

main()
{

    int i;
    SeqList L;
    DataType x;
    
    //初始化顺序表L 
    ListInitiate(&L);
    //初始化顺序表数据为0-49 
    CreList(&L);

    //显示链表 
    ListShow(L);
    
    //删除操作 
    printf("1.删除20位置元素
");
    ListDelete(&L,20,&x);
    printf("所删除元素为：%d
",x);
    ListShow(L);
    
    //增加操作 
    printf("2.在1位置插入元素10
");
    ListInsert(&L,1,10);
    ListShow(L);
    
    //查询操作 
    printf("3.查询30在链表中的位置：%d
",ListLocate(L,30));
    printf("
");
    printf("4.查询20(已删除)在链表中的位置：%d
",ListLocate(L,20));
     
    return 0;    
}

运行结果

To be continued ,

learning...（Date：2016-01-10）