【数据结构】（1）顺序表

运行环境：codeblocks

//顺序表的动态分配创建、查找、插入、修改、删除、截取、合并
#include <stdio.h>
#include <stdlib.h>
#define INIT_SIZE 200;
#define SIZE_INCREMENT 10;

typedef struct
{
    int *elem;//指向数组的存储基址
    int length;//顺序表的长度
    int listsize;//顺序表的容量
} List;

//初始化
void InitList(List *L)
{
    int size=INIT_SIZE;
    L->elem=(int *)malloc(size*sizeof(int));
    L->length=0;
    L->listsize=size;
}
void showList(List *L)
{
    int i;
    printf("表长%d\n元素：",L->length);
    for(i=0; i<L->length; i++)
    {
        printf("%d    ",L->elem[i]);
    }
    printf("\n");
}

//重新分配顺序表的大小
void ReallocateList(List *L)
{
    if(L->length>=L->listsize-1)
    {
        int newbase=(int *)realloc(L->elem,(L->listsize+10)*sizeof(int));
        L->elem=newbase;
        L->listsize+=SIZE_INCREMENT;
    }
}

//创建表
void createList(List *L)
{
    printf("输入顺序表的元素，以0结束\n");
    int i=0;
    scanf("%d",&L->elem[i]);
    L->length=1;
    for(i=1; L->elem[i-1]!=0; i++)
    {
        //判断表是否超出容量，如果超出，再分配部分地址
        ReallocateList(L);

        scanf("%d",&L->elem[i]);
        L->length=i;

    }
    showList(L);
}
//查找表中是否有某元素
int searchElem(List *L,int elem)
{
    printf("正在查找元素%d......",elem);
    int i,flag=0;
    for(i=0; i<L->length; i++)
    {
        if(L->elem[i]==elem)
        {
            printf("\n找到元素%d，表中第%d位\n",elem,i+1);
            flag=1;
        }
    }
    if(!flag)
    {
        printf("表中未找到该元素\n");
    }
}

//插入,在表中下标为index的位置插入元素elem
int insert(List *L,int index,int elem)
{
    printf("正在插入元素......");
    if(index>=0 && index<=L->length)//检查index是否越界
    {
        int i;
        for(i=L->length; i>index; i--)
        {
            ReallocateList(L);
            L->elem[i]=L->elem[i-1];
        }
        L->elem[index]=elem;
        L->length++;
        showList(L);
    }
    else
    {
        printf("错误：index越界\n");
    }
}

//将表中下标为index的元素修改为elem
int edit(List *L,int index,int elem)
{
    printf("正在修改元素......");
    if(index>=0 && index<L->length)//检查index是否越界
    {
        L->elem[index]=elem;
        showList(L);
    }
    else
    {
        printf("错误：index越界\n");
    }
}

//删除表中所有的元素elem
int delete(List *L,int elem)
{
    printf("正在删除元素......");
    int i,j,len=L->length;
    for(i=len-1; i>=0; i--)
    {
        if(L->elem[i]==elem)
        {
            for(j=i; j<L->length-1; j++)
            {
                L->elem[j]=L->elem[j+1];
            }
            L->length--;
            showList(L);
        }
    }
    showList(L);
}

//截取并返回从index1到index2之间的元素
List sub(List *L,int index1,int index2)
{
    printf("正在截取元素......");
    if(index1>=0 && index2>=0 && index1<L->length && index2<L->length)
    {
        int i,j;
        if(index1>index2)
        {
            int tmp=index1;
            index1=index2;
            index2=tmp;
        }
        List subList;
        InitList(&subList);
        subList.length=0;//通过结构体指针变量访问用"->";通过结构体变量访问用"."
        for(i=index1,j=0; i<=index2; i++,j++)
        {
            ReallocateList(&subList);
            subList.elem[j]=L->elem[i];
            subList.length++;
        }
        return subList;
    }
    else
    {
        printf("错误：index越界，返回原表\n");
        return *L;
    }
}

//合并表L1和表L2
List concat(List *L1,List *L2)
{
    printf("正在合并......");
    List concatList;
    InitList(&concatList);
    int i,j;
    for(i=0; i<L1->length; i++)
    {
        concatList.elem[i]=L1->elem[i];
    }
    for(j=0,i=L1->length; j<L2->length;i++,j++)
    {
        concatList.elem[i]=L2->elem[j];
    }
    concatList.length=L1->length+L2->length;
    return concatList;
}

int main()
{
    List L;
    InitList(&L);
    createList(&L);
    //searchElem(&L,1);
    //insert(&L,3,666);
    //edit(&L,1,999);
    //delete(&L,1);
    //List subList=sub(&L,1,3);//showList(&subList);
    //List concatList=concat(&subList,&subList);showList(&concatList);
    return 0;
}

---

比较坑的一个是结构体的 . 和 > ：
通过结构体指针变量访问用”->”通过结构体变量访问用”.”

int agestruct student one;
struct student *ptr;

引用时：
one.age
ptr->age