c语言顺序表的实现

创建顺序表，实现相关操作 代码如下

/**
  * @filename 1_seqlist.c
  * @author   haohaibo  
  * @data      2017/4/10
  * @brief       顺序表操作，包括插入，删除，修改，合并，排序        
**/
#include <stdio.h>
#include <stdlib.h>
#define N 32
typedef int datatype_t ;

typedef    struct{
    datatype_t data[N];
    datatype_t last;
}seqlist_t;

/**
  * @brief  变量数据交换
 */ 
void swap(datatype_t *a,datatype_t *b)
{
    datatype_t temp;
    temp=*a;
    *a=*b;
    *b=temp;
}

/**
  * @brief     创建一个顺序表
 */ 
seqlist_t *seqlist_create()
{
    seqlist_t *s1;
    s1=(seqlist_t *)malloc(sizeof(seqlist_t));
    s1->last=-1;
    return s1;
}

/**
  * @brief     检查顺序表是否满
 */ 
datatype_t seqlist_full(seqlist_t *s1)
{
    if(s1->last>=N-1)
    return (datatype_t)-1;
    else
    return 0;
}

/**
  * @brief     插入数据
 */ 
datatype_t seqlist_insert(seqlist_t *s1,datatype_t value)
{
    if(seqlist_full(s1)==-1)
    {        
        printf("%s --> %s --> %d\n", __FILE__, __func__, __LINE__);
        return 0;
    }
    s1->last++;
    s1->data[s1->last]=value;
    return 0;
}

/**
  * @brief     按位置插入数据
 */ 
datatype_t seqlist_insert_pos(seqlist_t *s1,datatype_t pos,datatype_t value)
{
    datatype_t i=0;
    if(seqlist_full(s1)==-1)
    {    puts("error");
        printf("%s --> %s --> %d\n", __FILE__, __func__, __LINE__);
        return 0;
    }
    if(pos<0||pos>s1->last+1)
    {    
        puts("pos error");
        printf("%s --> %s --> %d\n", __FILE__, __func__, __LINE__);
        return 0;
    }
    s1->last++;
    for(i=s1->last;i>=pos;i--)
    {
        s1->data[i]=s1->data[i-1];
    }
    s1->data[pos]=value;
    return 0;
}

/**
  * @brief     按位置删除数据
 */ 
datatype_t seqlist_del_pos(seqlist_t *s1,datatype_t pos)
{
    datatype_t i,value;
    if(pos<0||pos>s1->last+1)
    {    
        puts("del pos error");
        printf("%s --> %s --> %d\n", __FILE__, __func__, __LINE__);
        return 0;
    }
    value=s1->data[pos-1];
    for(i=pos-1;i<s1->last;i++)
    {
        s1->data[i]=s1->data[i+1];
    }
    s1->last--;
    return value;


}
/**
  * @brief     从顺序表顶端删除数据
 */ 
datatype_t seqlist_del_top(seqlist_t *s1,datatype_t count)
{    
    datatype_t value=s1->data[s1->last];
    s1->data[s1->last]=0;
    printf("Number of deleted data is:%d. \n",count-1);
    while(count--)
    {    
        if(s1->last==0)
        {
            puts("seqlist is empty");
            return 0;
        }
        else
        {
            s1->last--;
            s1->data[s1->last]=0;
            
        }
    }
    return 0;    
}

/**
  * @brief     从顺序表底端删除数据
 */ 
datatype_t seqlist_del_buttom(seqlist_t *s1,datatype_t count)
{
    datatype_t value=s1->data[s1->last];
    datatype_t i=1;
    datatype_t h=s1->last-count;    
    if(s1->last<=count)
    {
        puts("Number of deleted data is over !");
        return (datatype_t)-1;
    }
    while(h--)
    {
        swap(&s1->data[s1->last],&s1->data[s1->last-count-i]);
        s1->last--;
        i++;
    }
    s1->last=s1->last-count;
}

/**
  * @brief     删除顺序表中重复数据到只剩一个
 */ 
int seqlist_repeatnum(seqlist_t *s1)
{
        int i,j=0;
        for(i=0;i<s1->last;i++)
        {
            for(j=i+1;j<=s1->last;j++)
            {
                if(s1->data[i]==s1->data[j])
                {
                    seqlist_del_pos(s1,j+1);
                    j--;
                }
            }
        }
        return 0;
}

/**
  * @brief     根据位置查找数据
 */ 
datatype_t seqlist_check_pos(seqlist_t *s1, datatype_t pos)
{
    printf("find %d.\n",pos);
    if(pos<0||pos>s1->last)
    {
        puts("the pos is not exist\n");
        return (datatype_t)-1;
    }
    else
    printf("the s1->data[%d] =%d\n",pos,s1->data[pos]);
}

/**
  * @brief     根据已知数据查找它在顺序表中的位置
 */ 
datatype_t seqlist_check_num(seqlist_t *s1,datatype_t num)
{
    datatype_t i,flag=0;
    for(i=0;i<=s1->last;i++)
    {
        if(s1->data[i]==num)
        {
            printf("find Number %d,its pos %d\n",num,i);
            flag=1;
        }
    }    
        if(0==flag)
        printf("the Number %d is not exist in data\n",num);
}

/**
  * @brief     合并俩个顺序表中不重复的数据，
  */
datatype_t seqlist_merge(seqlist_t *s1,seqlist_t*s2)
{
    int i=0,j=0,flag=0;
    if((s1->last+s2->last)>=N)    
    {
        puts("error");
        printf("%s --> %s --> %d\n", __FILE__, __func__, __LINE__);
        return (datatype_t)-1;
    }
    puts("the merge result is:\n");
    for(i=0;i<=s2->last;i++)
    {
        flag=1;    
        for(j=0;j<=s1->last;j++)
        {
            if(s2->data[i]==s1->data[j])
            flag=0;
        }
        if(1==flag)
        {
            seqlist_insert(s1,s2->data[i]);
            flag=0;
        }
    }
    return 0;
}

/**
  * @brief  打印顺序表
 */ 
datatype_t seqlist_show(seqlist_t *s1)
{
    datatype_t i=0;
    for(i=0;i<=s1->last;i++)
    {
        printf("%d ",s1->data[i]);
    }
    putchar(10);
    return 0;
}
datatype_t main(datatype_t argc, const char *argv[])
{
    seqlist_t  *s1=seqlist_create();
    seqlist_t  *s2=seqlist_create();
    seqlist_insert(s1,1);
    seqlist_insert(s1,3);
    seqlist_insert(s1,5);
    seqlist_insert(s1,7);
    seqlist_insert(s2,1);
    seqlist_insert(s2,2);
    seqlist_insert(s2,3);
    seqlist_insert(s2,4);
    seqlist_insert(s2,5);
    seqlist_insert(s2,6);
    seqlist_insert(s2,7);
    seqlist_insert(s2,8);
//    printf("the s1->last is:%d\n",s1->last);
    seqlist_show(s1);
    seqlist_show(s2);
    seqlist_merge(s1,s2);
    seqlist_show(s1);
    /*seqlist_del_buttom(s1,8);
    seqlist_show(s1);
    seqlist_show(s1);
    seqlist_show(s1);*/
    return 0;
}