数组实现顺序表

1. 顺序存储结构:把数据元素放在 地址连续的存储单元里

 

定义一个结构放顺序存储的内容

typedef struct seqlist{
　　int data[10]; //顺序表中的实际内容
　　int last; // 顺序表中的数据元素,从 0 开始
}seqlist,*Seqlist;  // 顺序表类型
//重新定义一个指针类型 这只是声明了一个类型, 并没有实际的变量,也没有申请空间

2. 顺序表的操作

1. 建空表，

2. 插入元素，

3.删除元素，

4. 按位置查找元素，

5. 按照元素查找位置，

6. 去除表中重复元素，

7. 求表长度 ( 表中实际元素个数 ) ，

8. 修改表中元素值，合并2个顺序表，

9. 销毁顺序表

    

 3. 源码:一级指针建表方式实现

seqlist.c文件

/*
一级指针建表
*/
#include "seqlist.h"

//创建一个空的顺序表
Seqlist *creat_seqlist(void)
{
    Seqlist *list = NULL;//初始化为空
    list = (Seqlist*)malloc(sizeof(Seqlist));//堆中申请一个空间存放表
    //    list = (Seqlist*)malloc(-1); //失败，
    //     malloc函数没执行情况，list没有初始化，指向的是野指针
    if(NULL == list) //区分malloc的NULL与初始化的NULL
    {
        printf("	malloc error
");
        return NULL;
    }
    list->last = -1; //建表清空
    return list;
}

//清空表
void clear_seqlist(Seqlist *list)
{
    if(list ==NULL)//判断传入的值是否有效
    {
        printf("	list is NULL
");
        return ;
    }
    list->last = -1;
}

//判断表是否为空，1为空，  0为非空
int is_empty_seqlist(Seqlist *list)
{
    if(NULL == list)
    {
        printf("	list is NULL
");
        return -1;
    }
    return ((list->last==-1)?1:0) ;
}

//判断满 ， 1 满 ；0不满   -1 表空
int is_full_seqlist(Seqlist *list)
{
    if(NULL == list)
    {
        printf("	list is NULL
");
        return -1;
    }
    return ((list->last==(MAXSIZE-1))?1:0);
}

//插入数据 -1 失败   1成功
int inster_seqlist(Seqlist *list, int pos ,int value)
{
    if(NULL == list)
    {
        printf("	inster list is null
");
        return -1;
    }
    if(is_full_seqlist(list) == 1)//表满
    {
        printf("	inster list is full
");
        return -1;
    }
    if(pos<0 || pos > list->last+1)//插入位置无效
    {
        printf("	inster pos is error
");
        return -1;
    }

    int i=0;
    //把插入的pos位置到末尾这区域的值集体向后移动
    //就是下标pos至list->last集体后移一位
    for(i=list->last;i>=pos;i--)
    {
        list->data[i+1] = list->data[i];
    }

    list->data[pos] = value;
    list->last++;
    return 1;
}

//遍历显示顺序表中的内容，以last为准
void show_seqlist(Seqlist *list)
{
    if(NULL == list)
    {
        printf("	show list is null
");
        return ;
    }
    if(is_empty_seqlist(list)==1)
    {
        printf("	show list is empty
");
        return ;
    }
    int i=0;
    for(i=0;i<=list->last;i++)
    {
        printf("	%d
",list->data[i]);
    }
}

//删除表中一个元素    1成功   -1失败
//参数：要操作的表list，要删除的位置pos， 删除的内容放在value中
int del_seqlist(Seqlist *list, int pos, int *value)
{
    if(NULL == list)
    {
        printf("	delete list is null
");
        return -1;
    }
    if(is_empty_seqlist(list) == 1) //传的list是否为空
    {
        printf("	del_seqlist list is null
");
        return -1;
    }

    if(pos<0 || pos>list->last)//传入的位置合理，删除元素，元素下标 0~list->last
    {
        printf("	pos is error
");
        return -1;
    }
    *value = list->data[pos];//取出要删除位置的数据
    int i=0;
    //需要移动的数据下标范围，pos+1 ～ last
    //要删除的位置pos，要移动数据的位置pos+1～last
    //pos在最后一个位置时，循环条件不满足，直接不执行移位
    //    for(i=pos+1;i<=list->last;i++)
    //    {
    //        list->data[i-1] = list->data[i];
    //    }
    for(i=pos;i<list->last;i++)
    {
        list->data[i] = list->data[i+1];
    }
    list->last--;
    return 1;
}

//求表长,表中实际的元素个数
int length_seqlist(Seqlist *list)
{
    if(NULL == list)
    {
        printf("	length list is null
");
        return -1;
    }
    if(is_empty_seqlist(list)==1)//表空 0 个元素
    {
        return 0;
    }
    return  (list->last+1);
}

//获取数据
int getdata_seqlist(Seqlist *list, int pos)
{

    if(NULL == list)
    {
        printf("	getdata list is null
");
        return -1;
    }
    if(is_empty_seqlist(list)==1)
    {
        printf("	getdata list is empty
");
        return -1;
    }
    if(pos<0 || pos>list->last)
    {
        printf("	getdata pos is error
");
        return -1;
    }
    return list->data[pos];
}


//第一次出现的位置
//给元素获取位置
int getpos_seqlist(Seqlist *list, int data)
{
    if(NULL == list)
    {
        printf("	getpos list is null
");
        return -1;
    }
    if(is_empty_seqlist(list)==1)
    {
        printf("	getpos list is empty
");
        return -1;
    }
    int i=0;
    for(i=0;i<=list->last;i++)
    {
        if(data == list->data[i])
        {
            return i;
        }
    }
    return -1;
#if 0
    int tip=-1; 
    for(i=0;i<=list->last;i++)
    {
        if(list->data[i]==data)
        {
            tip=i;
            break;
        }
    }
    return tip;
#endif
}

/*销毁表时需要，传递需要销毁表的地址，类似于使用函数交换数据
 * 传值是不能修改数据内容的，需要传递地址，才可以修改数据内容，
 *此处也就是传递的二级指针
 * */
 //销毁表
void free_seqlist(Seqlist **list)
{
    if(list == NULL || *list == NULL)
    {
        printf("	list is null
");
    }

    free(*list);
    *list=NULL;
}
//修改表中的某个值
int change_seqlist(Seqlist *list, int pos, int value)
{
    if(list == NULL){ printf("change list is null
");return -1; }
    if(pos<0 || pos>list->last)//pos位置不合理
    {
        printf("change list pos is error
");
        return -1;
    }
    list->data[pos] = value;//改值
    return 1;
}
//删除表中重复的内容
int del_repeat_seqlist(Seqlist *list)
{
    int a;
    if(list == NULL){ printf("del repeat list is null
");return -1; }
    int i,j;
    for(i=0;i<length_seqlist(list);i++)//在删除元素时，表的长度是变化的
    {
        for(j=i+1;j<length_seqlist(list);j++)//查看表的长度是，表中数据个数
        {
            if(list->data[i]==list->data[j])//找到两个相等的元素
            {
                if(del_seqlist(list,j,&a) == -1) //删除过程失败
                {
                    printf("del_repeat_seqlist is error
");
                    return -1;
                }
                j--;
                printf("repeat data %d
",a);
            }
        }
    }
    return 1;
}



int merge_seqlist(Seqlist *list_a, Seqlist *list_b)//合并两个表，重复的数据删除
{
    if(list_a==NULL || list_b==NULL){ printf("merge list is null
");return -1; }
    int i=0;
    //把表b中的数据，在表a中获取位置，没有位置，
    //说明没有这个元素，获取到位置说明存在这个元素，
    //把表b中这个元素删除
    for(i=0;i<=list_b->last;i++)
    {
        if(getpos_seqlist(list_a,list_b->data[i]) == -1)//表a中，无表b中这个元素
        {
            if(inster_seqlist(list_a,0,list_b->data[i]) == -1)//在表a中，插入这个表b中的元素
            {
                printf("merge inster error
");
                return -1;
            }
        }
    }
    return 1;
}

seqlist.h文件:

#ifndef __SEQLIST_H
#define __SEQLIST_H

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10

typedef struct list{
    int  data[MAXSIZE]; //存放表的内容
    int last; // 表的实际用的内容大小
}Seqlist;

Seqlist *creat_seqlist(void);//建一个空表
void clear_seqlist(Seqlist *list);//清空表
int is_empty_seqlist(Seqlist *list);//判断表是否为空
int is_full_seqlist(Seqlist *list);//判断表满
int inster_seqlist(Seqlist *list, int pos, int value);//插入数据
void show_seqlist(Seqlist *list);//显示内容
int del_seqlist(Seqlist *list, int pos, int *value);//删除表中一个元素
int length_seqlist(Seqlist *list);//求表长
int getdata_seqlist(Seqlist *list, int pos);//获取数据
int getpos_seqlist(Seqlist *list, int data);//给元素获取位置
void free_seqlist(Seqlist **list);//销毁表
int change_seqlist(Seqlist *list, int pos, int value);//修改表中的某个值
int del_repeat_seqlist(Seqlist *list);//删除表中重复的内容
int merge_seqlist(Seqlist *list_a, Seqlist *list_b);//合并两个表，重复的数据删除

#endif

 测试main.c文件

#include <stdio.h>
#include "seqlist.h"

int main(int argc, const char *argv[])
{
    int i=0;
    //插入数据 表1
    printf("create s1 
");
    Seqlist *s1=creat_seqlist();
    if(NULL == s1)//建表失败
    {    printf("s1 create error
");    return -1;    }
    for(i=0;i<4;i++)  inster_seqlist(s1,0,i);
    inster_seqlist(s1,0,1);
    printf("show s1 data
");
    show_seqlist(s1);
    del_repeat_seqlist(s1);
    show_seqlist(s1);

    //操作表 2
    printf("create s2
");
    Seqlist *s2=creat_seqlist();
    if(NULL == s2)//建表失败
    {    printf("s1 create error
");    return -1;    }
    for(i=0;i<4;i++)  inster_seqlist(s2,0,i+1);
    printf("show s2 data
");
    show_seqlist(s2);
    printf("merge_seqlist
");
    merge_seqlist(s1,s2);
    printf("

 show s1 
");
    show_seqlist(s1);
    
//释放内存
    free_seqlist(&s1);
    if(s1==NULL)    {    printf("	s is null
");  }
    free_seqlist(&s2);
    if(s2==NULL)    {    printf("	s is null
");  }

    return 0;
}

 结果: