忙忙碌碌，碌碌无为

一、思维导图

二、将没有完成的功能，全部完成

2.10 顺序表按位置查找返回元素值

1> 功能：用位置查找元素

参数：顺序表的起始地址，要查找的位置

返回值：成功返回元素值，失败返回-1

2> 逻辑：通过下标找到顺序表要查找元素的位置，然后直接返回该元素

//顺序表按位置查找元素值（作业）

int list_search_pos(Seqlist_ptr S,int pos)
{

    //逻辑判断
    if(list_empty(S)||pos<0||pos>=S->len)
    {   
        printf("查找失败\n");
        return -1; 
    }   
    //处理逻辑
    return S->data[pos];
        

}   

2.11顺序表按位置进行修改元素

1> 功能：判断位置是否处于顺序表中，如果存在就修改成新值

参数：顺序表的起始地址，要查找的位置，修改的新值

返回值：成功返回0，失败返回-1

2> 逻辑：通通过下标找到顺序表要查找元素的位置，通过下标修改数据为新值

//顺序表按位置进行修改
int list_update_pos(Seqlist_ptr S,int pos,datatype new_e)
{
    if(list_empty(S)||pos<0||pos>=S->len)
    {   
        printf("修改失败\n");
        return -1; 
    }   
    S->data[pos]=new_e;
    return S->data[pos];
}

2.13顺序表排序

1> 功能：判断顺序表是否为空，如果不为则将顺序表中的数排序

参数：顺序表的起始地址

返回值：成功返回0，失败返回-1

2> 逻辑：运用冒泡排序将顺序表中的数排序

//顺序表的排序（作业）
int list_sort(Seqlist_ptr S)
{
    if(list_empty(S))
    {
        printf("排序失败\n");
        return -1;
    }
    for(int i=1;ilen;i++)
    {
        for(int j=0;jlen-i;j++)
        {
            if(S->data[j]>=S->data[j+1])
            {
                datatype m=S->data[j];
                S->data[j]=S->data[j+1];
                S->data[j+1]=m;
            }
        }
    }
    printf("排序成功\n");
}  

2.15顺序表翻转

1> 功能：判断顺序表是否为空，如果不为则将顺序表中的数据翻转

参数：顺序表的起始地址

返回值：成功返回0，失败返回-1

//顺序表翻转（作业）                                                         
int list_turn(Seqlist_ptr S)
{
    if(list_empty(S))
    {
        printf("翻转失败\n");
        return -1;
    }
    for(int i=0;i<(S->len)/2;i++)
    {
        datatype m=S->data[i];
        S->data[i]=S->data[S->len-i-1];
        S->data[S->len-i-1]=m;
    }
    printf("翻转成功\n");
}

2.16顺序表的长度

1> 功能：判断顺序表是否为空，如果不为则将顺序表的长度计算出来

参数：顺序表的起始地址

返回值：成功返回0，失败返回-1

//获取顺序表的长度(作业)
int list_len(Seqlist_ptr S)
{
    if(list_empty(S))
    {
        return 0;
    }else
    {
        return S->len;
    }
}

2.17清空数组

1> 功能：判断顺序表是否为空，如果不为则将清空数组

参数：顺序表的起始地址

返回值：成功返回0，失败返回-1

逻辑：将数组长度变为0

//清空数组
int list_clear(Seqlist_ptr S)
{
    if(list_empty(S))
    {
        printf("无需清空\n");
    }
        S->len=0;
    printf("清空完成\n");
}

三、将顺序表的源代码重新写一遍，可以参照着头文件写，测试文件自己写

seqlist.h:

#ifndef SEQLIST_H
#define SEQLIST_H

#define MAX 100      //宏定义顺序表最大长度
typedef int datatype;   //数据元素类型
//定义顺序表类型
typedef struct
{
    datatype data[MAX];//存储顺序表的数组
    int len;//存储顺序表的长度
}Seqlist,*Seqlist_ptr;

//创建顺序表
Seqlist_ptr list_create();

//判断顺序表是否为空
int list_empty(Seqlist_ptr S);

//判断顺序表是否为满
int list_full(Seqlist_ptr S);

//向顺序表中添加元素
int list_add(Seqlist_ptr S,datatype e);

//查看顺序表内容的函数
void list_show(Seqlist_ptr S);
//顺序表按任意位置插入操作
int list_insert_pos(Seqlist_ptr S,int pos,datatype e);
//顺序表进行任意位置的删除操作
int list_delete_pos(Seqlist_ptr S,int pos);
//顺序表按值查找返回位置
int list_search_value(Seqlist_ptr S,datatype e);
//顺序表按位置查找元素值（作业）
int list_search_pos(Seqlist_ptr S,int pos);
//顺序表按位置进行修改
int list_update_pos(Seqlist_ptr S,int pos,datatype new_e);
//顺序表按值进行修改
int list_update_value(Seqlist_ptr S,datatype old_e,datatype new_e);
//顺序表的排序（作业）
int list_sort(Seqlist_ptr S);
//顺序表的去重
int  list_unique(Seqlist_ptr S);
//顺序表翻转（作业）
int list_turn(Seqlist_ptr S);
//获取顺序表的长度(作业)
int list_len(Seqlist_ptr S);
//清空数组
int list_clear(Seqlist_ptr S);
//顺序表的销毁
void list_destroy(Seqlist_ptr S);
#endif   

seqlist.c:

#include
#include"seqlist.h"

//创建顺序表的定义
Seqlist_ptr list_create()
{

    Seqlist_ptr S = (Seqlist_ptr)malloc(sizeof(Seqlist));
    if(NULL == S)
    {   
        printf("创建顺序表失败\n");
        return NULL;
    }

    //程序执行至此，表示创建成功
    //给顺序表进行初始化
    bzero(S->data,sizeof(datatype)*MAX);//初始化数组
    S->len = 0;

    printf("顺序表创建成功\n");
    return S;
}
 //判断顺序表是否为空                                                             
int list_empty(Seqlist_ptr S)
{
	//判断传入的顺序表是否合法
	if(NULL==S)
	{
		printf("非法顺序表\n");
		return 0;//后续不进行操作
	}
	//判断顺序表长度
	return 0==S->len ? 1:0;
}
//判断顺序表是否满了
int list_full(Seqlist_ptr S)  
{
	
	//判断传入的顺序表是否合法
	if(NULL==S)
	{
		printf("非法顺序表\n");
		return 1;//后续不进行操作
	}

	//判断顺序表长度是否为最大长度
	return S->len ==MAX? 1:0;
}
//向顺序表中添加元素
int list_add(Seqlist_ptr S,datatype e)
{
	if(list_full(S))
	{
		printf("顺序表已满，添加失败\n");
		return -1;
	}
	//添加逻辑
	S->data[S->len]=e;

	//表长变化
	S->len++;
	printf("添加成功\n");
	return 0;
}

//查看顺序表内容的函数
void list_show(Seqlist_ptr S)
{
	//判空
	if(list_empty(S)||NULL==S)
	{
		printf("查看失败\n");
		return ;
	}

	printf("数据:\t");
	for(int i=0;ilen;i++)
	{
		printf("%d\t",S->data[i]);
	}
	printf("\n");
}

//顺序表按任意位置插入操作
int list_insert_pos(Seqlist_ptr S,int pos,datatype e)
{
	if(pos<0||list_full(S)||pos>S->len)
	{
		printf("无法进行插入操作\n");
		return -1;
	}
	for(int i= S->len-1;i>=pos;i--)
	{
		S->data[i+1] = S->data[i];
	}
	S->data[pos]=e;
	(S->len)++;
	printf("插入成功\n");

}
//顺序表进行任意位置的删除操作
int list_delete_pos(Seqlist_ptr S,int pos)
{
	if(list_empty(S)||pos>=S->len||pos<0)
	{
		printf("无法删除\n");
		return -1;
	}
	for(int i=pos+1;ilen;i++)
	{
		S->data[i-1]=S->data[i];
	}
	printf("删除成功\n");
	S->len--;
}

//顺序表按值查找返回位置
int list_search_value(Seqlist_ptr S,datatype e)
{
	//逻辑判断
	if(list_empty(S))
	{
		printf("查找失败\n");
		return -1;
	}
	//处理逻辑
	for(int i=0;ilen;i++)
	{
		//判断是否跟任意一个元素相等
		if(S->data[i]==e)
		{
			return i;
		}
	}
	return -1;//表示没找到
	printf("查找失败\n");
	//表长变化
}

//顺序表按位置查找元素值（作业）
int list_search_pos(Seqlist_ptr S,int pos)
{

	//逻辑判断
	if(list_empty(S)||pos<0||pos>=S->len)
	{
		printf("查找失败\n");
		return -1;
	}
	//处理逻辑
	return S->data[pos];
	

}
//顺序表按位置进行修改
int list_update_pos(Seqlist_ptr S,int pos,datatype new_e)
{
	if(list_empty(S)||pos<0||pos>=S->len)
	{
		printf("修改失败\n");
		return -1;
	}
	S->data[pos]=new_e;
	return S->data[pos];
}

//顺序表按值进行修改
int list_update_value(Seqlist_ptr S,datatype old_e,datatype new_e)
{
	//判断逻辑
	if(list_empty(S))
	{
		printf("修改失败\n");
		return -1;
	}
	//通过旧值查找旧值的位置
	int res = list_search_value(S,old_e);
	if(res==-1)
	{
		printf("修改失败\n");
		return -1;
	}
	S->data[res]=new_e;
	printf("修改成功\n");
	return 0;
}


//顺序表的排序（作业）
int list_sort(Seqlist_ptr S)
{
	if(list_empty(S))
	{
		printf("排序失败\n");
		return -1;
	}
	for(int i=1;ilen;i++)
	{
		for(int j=0;jlen-i;j++)
		{
			if(S->data[j]>=S->data[j+1])
			{
				datatype m=S->data[j];
				S->data[j]=S->data[j+1];
				S->data[j+1]=m;
			}
		}
	}
	printf("排序成功\n");
}


//顺序表的去重
int  list_unique(Seqlist_ptr S)
{
	//判断逻辑
	if(list_empty(S)||S->len==1)
	{
		printf("去重失败\n");
		return -1;
	}
	//重复逻辑
	for(int i=0;ilen;i++)
	{
		//找到任意元素 S->data[i]
		for(int j=i+1;jlen;j++)//遍历S-data[i]后面的元素
		{
			if(S->data[i]==S->data[j])
			{
				//说明有重复元素
				list_delete_pos(S,j);
				j--;
			}
		}
	}
	printf("去除成功\n");
}

//顺序表翻转（作业）
int list_turn(Seqlist_ptr S)
{
	if(list_empty(S))
	{
		printf("翻转失败\n");
		return -1;
	}
	for(int i=0;i<(S->len)/2;i++)
	{
		datatype m=S->data[i];
		S->data[i]=S->data[S->len-i-1];
		S->data[S->len-i-1]=m;
	}
	printf("翻转成功\n");
}
//获取顺序表的长度(作业)
int list_len(Seqlist_ptr S)
{
	if(list_empty(S))
	{
		return 0;
	}else
	{
		return S->len;
	}
}

//清空数组
int list_clear(Seqlist_ptr S)
{
	if(list_empty(S))
	{
		printf("无需清空\n");
	}
		S->len=0;
	printf("清空完成\n");
}
//顺序表的销毁
void list_destroy(Seqlist_ptr S)
{
	if(NULL!=S)
	{
		free(S);
		S=NULL;
	}
	printf("销毁成功\n");
}

main.c:

#include
#include"seqlist.h"

int main(int argc, const char *argv[])
{

    Seqlist_ptr S = list_create();
    if(NULL == S)
    {   
        return -1; 
    }   
     
	list_add(S,3);
	list_add(S,1);
	list_add(S,2);
	list_add(S,6);
	list_add(S,0);

	list_show(S);
	list_insert_pos(S,2,9);
	list_show(S);
	list_insert_pos(S,2,9);
	list_show(S);
	list_delete_pos(S,4);
	list_show(S);
int m =	list_search_value(S,1);
	printf("%d\n",m);
	list_update_value(S,9,2);
	list_show(S);
	list_unique(S);
	list_show(S);
int i=	list_search_pos(S,3);
	printf("%d\n",i);
	list_update_pos(S,1,99);
	list_show(S);
	list_sort(S);
	list_show(S);
	list_turn(S);
	list_show(S);
	int t=list_len(S);
	printf("%d\n",t);
	list_clear(S);
	list_show(S);
	list_destroy(S);
	S=NULL;
	list_show(S);
    return 0;
}                                                        
   

结果：