数据结构day3作业

一、完整功能【顺序表】的创建

【seqList.h】

cpp 复制代码

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//宏定义，线性表的最大容量
#define MAX 30

//类型重定义，表示要存放数据的类型
typedef int DataType;

//定义顺序表的结构体类型
typedef struct sequence
{
        //定义一个数组，存放连续的数据
        DataType data[MAX];
        //顺序表长度，已存放的元素个数
        int len;
}seqList, *seqListPtr;


//创建一个顺序表
seqListPtr seq_create();

//判空
int empty(seqListPtr S);

//判满
int fill(seqListPtr S);

//顺序表增加
int seq_add(seqListPtr S, DataType e);

//顺序的遍历
void show(seqListPtr S);

//任意位置插入数据
int index_add(seqListPtr S, int index, DataType e);

//任意位置删除数据
int index_del(seqListPtr S, int index);

//通过位置修改数据
void index_change(seqListPtr S, int index, DataType e);

//按值查找，返回下标
int value_index(seqListPtr S, DataType e);

//去重
void repeat(seqListPtr S);

//销毁
void my_free(seqListPtr *S);

#endif

【seqList.c】

cpp 复制代码

#include "seqList.h"

//创建一个顺序表
seqListPtr seq_create()
{
        //在堆区申请顺序表的大小空间，返回主程序使用
        seqListPtr S = (seqListPtr)malloc(sizeof(seqList));
        //判断申请空间是否合法
        if(NULL== S)
        {
                printf("创建失败！\n");
                return NULL;
        }
        printf("创建成功！\n");

        //顺序表的长度置为0
        S->len = 0;
        //数组清空
        memset(S->data, 0, sizeof(S->data));
        return S;
}

int empty(seqListPtr S)
{
        //判断所接受的顺序表是否合法
        if(NULL == S)
        {
                printf("判空失败！\n");
                return -1;
        }
        return S->len==0;
}

int fill(seqListPtr S)
{
        //判断所接受的顺序表是否合法
        if(NULL == S)
        {
                printf("判满失败！\n");
                return -1;
        }
        return S->len == MAX;
}

int seq_add(seqListPtr S, DataType e)
{
        //判断所接受的顺序表是否合法
        //判满
        if(NULL == S || fill(S))
        {
                printf("增加失败！\n");
                return 0;
        }
        //放入数据
        S->data[S->len] = e;
        //增加成功 顺序表长度自增
        S->len++;

        return 1;
}

void show(seqListPtr S)
{
        //判读所接受的顺序表是否合法
        //判空
        if(NULL == S || empty(S))
        {
                printf("遍历失败！\n");
                return;
        }
        for(int i=0; i<S->len; i++)
        {
                printf("%d ", S->data[i]);
        }
        printf("\n");
}

//任意位置插入数据
int index_add(seqListPtr S, int index, DataType e)
{
        //判断所接受的顺序表是否合法
        //判满
        //判断插入的位置是否合理
        if(NULL == S || fill(S) || index<=0 || index > S->len+1)
        {
                printf("插入失败！\n");
                return 0;
        }

        //插入位置对应下标
        index = index - 1;

        //腾位
        for(int i=0; i<S->len-index; i++)
        {
                S->data[S->len-i] = S->data[S->len-1-i];
        }

        //插入数据
        S->data[index] = e;
        //顺序表长度自增
        S->len++;
        return 1;
}

//任意位置删除数据
int index_del(seqListPtr S, int index)
{
        //判断所接受的顺序表是否合法
        //判空
        //判断删除的位置是否合理
        if(NULL == S || empty(S) || index<=0 || index>S->len)
        {
                printf("删除失败！\n");
                return 0;
        }

        //删除：从前往后
        //位置对应的下标
        index = index -1;
        for(int i=index; i<S->len; i++)
        {
                S->data[i] = S->data[i+1];
        }

        //顺序表长度自减
        S->len--;
        return 1;
}

//通过位置修改数据
void index_change(seqListPtr S, int index, DataType e)
{
        //判断所接受的顺序表是否合法
        //判空
        //判断要修改的位置是否合理
        //判断新值和旧值是否相等
        if(NULL==S || empty(S) || index<=0 || index>S->len || S->data[index-1]==e)
        {
                printf("修改失败！\n");
                return;
        }

        //修改(index是用户指定的位置，但计算机下标是从0开始)
        S->data[index-1]=e;
}

//按值查找，返回下标
int value_index(seqListPtr S, DataType e)
{
        //判断所接受的顺序表是否合法
        //判空
        if(NULL==S || empty(S))
        {
                printf("查找失败！\n");
                return -1;
        }

        for(int i=0; i<S->len; i++)
        {
                if(S->data[i]==e)
                {
                        return i;
                }
        }
        printf("查无此数据！\n");

        return -1;
}

//去重
void repeat(seqListPtr S)
{
        if(NULL==S || S->len<=1)
        {
                printf("去重失败！\n");
                return;
        }
        //顺序表中的每个元素
        for(int i=0; i<S->len; i++)
        {
                //遍历i元素下面所有的元素
                for(int j=i+1; j<S->len; j++)
                {
                        if(S->data[i]==S->data[j])
                        {
                                index_del(S, j+1); //按位置删除（需要注意完全删除）
                                j--;
                        }
                }
        }
}

//销毁
void my_free(seqListPtr *S)
{
        //判断所接受的顺序表是否合法
        if(NULL==*S)
        {
                printf("销毁失败！\n");
                return;
        }

        free(*S);
        S=NULL;
        printf("销毁成功！\n");
}

【main.c】

cpp 复制代码

#include "seqList.h"

int main()
{
        //创建一个顺序表
        seqListPtr S = seq_create();
        //顺序表的增加
        seq_add(S, 10);
        seq_add(S, 20);
        seq_add(S, 30);
        seq_add(S, 40);
        seq_add(S, 50);

        //顺序表的遍历
        show(S);

        //任意位置插入数据
        index_add(S, 3, 3344);
        show(S);
        //非法插入测试
        index_add(S, 0, 3300);

        //任意位置删除数据
        index_del(S, 2);
        show(S);
        //非法删除测试
        index_del(S, 8);

        //通过位置修改数据
        index_change(S, 4, 9988);
        show(S);

        //按值查找，返回下标
        int index = value_index(S, 9988);
        index_change(S, index+1, 88099);
        show(S);

        //去重
        //先添加一些测试数据
        seq_add(S, 10);
        seq_add(S, 20);
        seq_add(S, 10);
        seq_add(S, 10);
        seq_add(S, 30);
        seq_add(S, 20);
        seq_add(S, 20);
        seq_add(S, 50);
        seq_add(S, 40);
        seq_add(S, 50);
        show(S);
        repeat(S);
        show(S);

        //销毁
        my_free(&S);

        S=NULL;

        return 0;
}

【执行结果】