顺序表小练

2022.07.19数据结构小练

main.c文件

#include"seqlist.h"
#include<stdlib.h>
#include<stdio.h>
int main(int argc, const char *argv[])
{
    seqList *S = listCreate();
    if(NULL==S)
        return -1;
    //调用添加函数
    listAdd(S,7);
    listAdd(S,2);
    listAdd(S,5);
    listAdd(S,5);
    listAdd(S,5);
    listAdd(S,4);
    listAdd(S,3);
    listAdd(S,2);
    listAdd(S,7);//添加至最后一个数
    listShow(S);//遍历查看一遍已有内容
    listInsertPos(S,1,8);//在1的位置上插入一个数值8
    listShow(S);
    listDeletePos(S,2);//删除位置2上的数
    listShow(S);
    int SEX=listSearchValue(S,3);//寻找值为3的位置
    printf("%d\n",SEX);
    int back=listSearchPos(S,5);//寻找位置5上的值
    printf("%d\n",back);
    listUpdataValue(S,8,2);//将值为8的位置上的值更新为2
    listShow(S);
    listUpdataPos(S,0,9);//将0位置上的值更新为9
    listShow(S);
    listSort(S);//升序冒泡排序
    listShow(S);
    listSort2(S);//降序选择排序
    listShow(S);
    listDeleteRepeat(S);//删除重复数据

    listShow(S);
    listFree(S);//释放表
    S=NULL;//释放函数中的表不能改动主函数中的指针指向，需要手动指向空
    listShow(S);
    return 0;
}          

seqlist.c

//定义头文件
#include"seqlist.h"
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

创建顺序表

//创建顺序表                                       

seqList* listCreate()
{
    //在堆区申请一个顺序表的空间，将申请的地址给S
    seqList *S =(seqList*)malloc(sizeof(seqList));
        if(NULL == S)
        {
            printf("申请空间失败\n");
            return NULL;
        }

    memset(S,0,sizeof(S));
    S->len = 0;
    printf("创建成功\n");
    return S;
}

判空判满

//判空                           
int listEmpty(seqList *S)
{
    if(NULL==S)
    {
    printf("所给顺序表不合法\n");
    exit(0);
    }
    return S->len==0?1:0;
}

//判满
int listFull(seqList *S)
{
    return S->len==MAX ? 1:0;
}

添加元素

//添加元素
int listAdd(seqList *S,datatype e)
{
    //判断满
    if(listFull(S))
    {                               
        printf("表满，添加失败\n");
        return -1;
    }
    //添加逻辑
    S->data[S->len] = e;
    //表的变化
    S->len ++;
    printf("添加成功\n");
    return 0;
}

遍历函数

//遍历函数
void listShow(seqList *S)               
{
//判断逻辑
    if(listEmpty(S))
    {
        printf("空空如也，遍历失败\n");
        return;
    }
    int i=0;
    for(i=0;i< S->len;i++)
    {
        printf("%d\t",S->data[i]);
    }
    printf("遍历成功\n");
}

任意位置插入

//任意位置插入                                  
int listInsertPos(seqList *S,int pos,datatype e)
{
    if(listFull(S))//判满
    {
        printf("表满，插入失败\n");
        return -1;
    }
    if(pos<0 || pos>S->len)
    {
        printf("位置不合法，插入失败\n");
        return -2;
    }
    for (int i=S->len-1;i>=pos;i--)
    {
        S->data[i+1]=S->data[i];

    }
    S->data[pos]=e;
    S->len++;

    return 0;
}

任意位置删除

//任意位置删除
int listDeletePos(seqList *S,int pos)        
{
    //判断逻辑
    if(listEmpty(S) || pos<0 || pos>S->len-1)
        {

        printf("删除失败\n");
            return -1;
        }
//删除逻辑
    for(int i=pos+1;i<S->len;i++)
    {
        S->data[i-1]=S->data[i];

    }
    S->len--;
}

按值查找，返回对应的位置

//按值查找，返回对应的位置
int listSearchValue(seqList *S,datatype e)
{
    if(listEmpty(S))
    {                                     
        printf("查找失败\n");   //表空
        return -1;
    }
    for(int i=0;i<S->len;i++)
    {
        if(e ==S->data[i])
        {
            return i;
        }

    }
            return -2; //没找到该值
}

按位置查找返回值

//按位置查找返回值
datatype listSearchPos(seqList *S,int pos)
{
    if(listEmpty(S) || pos<0 || pos>S->len)
    {
         printf("查找失败\n");   //表空+位置不合法
        return -1;
    }
        if(S->data[pos])
         return S->data[pos];


}

按值修改

//按值修改                                                    
int listUpdataValue(seqList *S,datatype old_e ,datatype new_e)
{
    int count=0;
    if(listEmpty(S))
    {
         printf("查找失败\n");   //表空+位置不合法
        return -1;
    }
    for(int i=0;i<S->len;i++)
    {
        if(S->data[i]==old_e)
        {
            S->data[i]=new_e;
            count++;
        }
    }
    if(count==0)
    {
        printf("没找到该值");
        return -2;
    }
    printf("成功修改%d次\n",count);
    return 0;
}

按位置修改

//按位置修改
int listUpdataPos(seqList *S,int pos,datatype new_e)
{
    //判断逻辑
    if(listEmpty(S) || pos<0 || pos>S->len)
 {
      printf("修改失败\n");   //表空+位置不合法
     return -1;
 }
    //修改逻辑
    S->data[pos] = new_e;
    printf("修改成功\n");
    return 0;
}

冒泡升序排序

//冒泡升序排序
void listSort(seqList*S)
{
    int i,j;
    datatype temp;

    for(i=1;i<S->len;i++)
    {
        for(j=0;j<S->len-i;j++)
        {
            if(S->data[j]>S->data[j+1])
            {
                temp=S->data[j]; S->data[j]=S->data[j+1];S->data[j+1]=temp;
            }
        }
    }
    printf("排序成功\n");
}                                                                           

选择降序排列

//选择降序排列
void listSort2(seqList *S)
{
    int i,j,temp;
    for(i=0;i<S->len;i++)
    {
        int max=i;
        for(j=i;j<S->len;j++)
        {
            if(S->data[max]<S->data[j])
            {
                max=j;
            }
        }
        temp=S->data[max];
        S->data[max]=S->data[i];
        S->data[i]=temp;

    }
}

清除重复元素

//清除重复元素                        
void listDeleteRepeat(seqList *S)
{
    //判断逻辑
    if( S->len<=1)
    {
        return;         //无需去重
    }
    for(int i=0;i<S->len;i++)
    {
        for(int j=i+1;j<S->len;j++)
        {
            if(S->data[i]==S->data[j])
            {
                listDeletePos(S,j);
                j--;

            }
        }
    }
                printf("删除成功\n");

}

释放表

//释放表                  
void listFree(seqList *S)
{
    if(NULL!=S)
    {
        free(S);
    }
    S = NULL;//防止野指针
    printf("释放成功\n");
}

seqlist.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#define MAX 20
typedef int datatype;

typedef struct
{
	datatype data[MAX];
	int len;
}seqList;


seqList* listCreate();
int listEmpty(seqList *S);
int listFull(seqList *S);
int listAdd(seqList *S,datatype e);
void listShow(seqList *S);
int listInsertPos(seqList *S,int pos,datatype e); 
//任意位置插入                                      
int listInsertPos(seqList *S,int pos,datatype e);
//任意位置删除
int listDeletePos(seqList *S,int pos);
//按值查找，返回对应的位置
int listSearchValue(seqList *S,datatype e);
//按位置查找返回值
datatype listSearchPos(seqList *S,int pos);
//按值修改
int listUpdataValue(seqList *S,datatype old_e ,datatype new_e);
//按位置修改
int listUpdataPos(seqList *S,int pos,datatype new_e);
//冒泡升序排序
void listSort(seqList*S);
//清除重复元素
void listDeleteRepeat(seqList *S);
//选择降序排列
void listSort2(seqList *S);
//释放表
void listFree(seqList *S);
#endif

编译后结果实现