数据结构day4

#ifndef _SEQLIST_H_
#define _SEQLIST_H_
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX 40            //定义顺序表的最大容量
typedef int datatype;          //数据元素的类型,以整形为例

//定义顺序表类型
typedef struct
{
    datatype data[MAX];            //存储数据元素的数组
    int len;                      //存储当前顺序表的长度
}seqList, *seqListPtr;    //重命名为一个结构体变量，和一个指针类型

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

//判满
int list_full(seqListPtr S);

//判空
int list_empty(seqListPtr S);

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

//遍历顺序表
void list_show(seqListPtr S);

//任意位置插入元素
int list_insert_pos(seqListPtr S,int pos, datatype e);

//任意位置删除元素
int list_delete_pos(seqListPtr S, int pos);

//按位置进行修改

//按值进行修改

//查找指定位置的元素

//按值进行查找元素
int list_search_value(seqListPtr S, datatype e);

//将顺序表排序,选择排序
void list_sort(seqListPtr S, int flag);


//顺序表去重
void list_unique(seqListPtr S);

//扩容

//求最值操作
datatype list_mvalue(seqListPtr S, int flag);

//顺序表反转
void list_reverse(seqListPtr S);

//释放顺序表


#endif

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

seqListPtr list_create()
{
    //在堆区申请一个顺序表的空间大小
    seqListPtr S = (seqListPtr)malloc(sizeof(seqList));
    //判断是否申请成功
    if(NULL == S)
    {
        printf("顺序表创建失败\n");
        return NULL;
    }

    //此时顺序表已经创建成功
    memset(S->data, 0, sizeof(S->data));   //清空数组
    S->len = 0;                  //数组长度清零

    printf("顺序表创建成功\n");
    return S;
}
int list_full(seqListPtr S)
{
    //判断逻辑
    if(NULL == S)
    {
        printf("所给顺序表不合法\n");
        return 0;
    }

    //合法，则返回是否已经满了
    return S->len == MAX;
}

int list_empty(seqListPtr S)
{
    //判断逻辑
    if(NULL == S)
    {
        printf("所给顺序表不合法\n");
        return 0;
    }

    //合法返回是否空
    return S->len == 0;
}
int list_add(seqListPtr S, datatype e)
{
    //判断逻辑
    if(NULL==S || list_full(S))
    {
        printf("添加失败\n");
        return 0;
    }

    //添加逻辑
    S->data[S->len] = e;     //将新元素放入最后一个位置

    //表的变化
    S->len++;

    printf("添加成功\n");
    return 1;
}
void list_show(seqListPtr S)
{
    //判断逻辑
    if(NULL==S || list_empty(S))
    {
        printf("遍历失败\n");
        return ;
    }

    //遍历逻辑
    printf("当前顺序表的元素分别是：");
    for(int i=0; i<S->len; i++)
    {
        printf("%d\t", S->data[i]);
    }
    printf("\n");

}
int list_insert_pos(seqListPtr S,int pos, datatype e)
{
    //判断逻辑
    if(NULL==S || list_full(S) || pos<0 || pos>S->len)
    {
        printf("插入失败\n");
        return 0;
    }

    //腾空过程
    for(int i=S->len-1; i>=pos; i--)
    {
        S->data[i+1] = S->data[i];  //将当前元素后移
    }

    //插入逻辑
    S->data[pos] = e;    //将新元素放入要插入的位置

    //表的变化
    S->len++;

    printf("插入成功\n");
    return 1;
}





//代码有问题没考虑重复的数据

int list_search_value(seqListPtr S, datatype e)
{
	int flag =0;
	for(int i = 0; i < S->len-1; i++)
	{
		if(e == S->data[i])
		{
			flag =1;
		}
	}
	if(1 == flag)
	{
			printf("顺序表查中有找有此元素\n");
		
	}
	else if(0 == flag)
	{
		printf("顺序表中无此元素\n");
	}
	return 0;
}






void list_sort(seqListPtr S, int flag)
{
	int i = 0;
	int j = 0;
	int  index = 0;
	datatype temp;
	printf("将输入的数据进行排序\n");
switch (flag)
{
case 1:
		 for(int i = 1; i < S->len; i++)
		 {
			  index = i - 1;
	 		for( j = i-1; j < S -> len; j++ )
			{
				if(S -> data[index] > S->data[j])
				{
					index = j;
				}
			}
			if(index != i-1 )
			{
				temp = S->data[index];
				S-> data[index] = S->data[i-1];
				S->data[i-1] = temp;
			}
		 }
		 break;
case 0:
		 for(int i = 1; i < S->len; i++)
		 {
			  index = i - 1;
	 		for( j = i-1; j < S -> len; j++ )
			{
				if(S -> data[index] < S->data[j])
				{
					index = j;
				}
			}
			if(index != i-1 )
			{
				temp = S->data[index];
				S-> data[index] = S->data[i-1];
				S->data[i-1] = temp;
			}
		 }
}
}
datatype list_mvalue(seqListPtr S, int flag)
{
	int i = 0;
	datatype Max = S->data[0];
	datatype MIN = S ->data[0];
	switch (flag)
	{
	case 1:
		for(i = 0; i < S->len; i++)
		{
			if(Max < S->data[i])
			{
				Max = S ->data[i];	
			}
		}
		printf("最大值为：%d\n", Max);
		break;
	case 0:
		for(i = 0; i < S->len; i++)
		{
			if(MIN > S -> data[i])
			{
				MIN = S -> data[i];
			}
		}
		printf("最小值为：%d\n", MIN);
	}
}
void list_reverse(seqListPtr S)
{
	int i = 0;
	int j = 0;
	datatype temp;
	for(i = 0, j = S->len-1; S ->data[j] > S->data[i]; j--,i++)
	{
		temp = S->data[i];
		S->data[i] = S->data[j];
		S->data[j] = temp;
	}
	list_show(S);
}

int list_delete_pos(seqListPtr S, int pos)
{
	if(NULL == S || list_full(S) )
	{
		printf("遍历表失败\n");
		return 0;
	}
	int i = 0;
	for(i = pos+1; i<S->len; i++)
	{
		S->data[i-1] = S->data[i];
	}
	S->len--;
	list_show(S);
	printf("指定位置删除成功\n");
	return 1;
}
//顺序表去重
void list_unique(seqListPtr S)
{
	int i = 0;
	int j = 0;
	int count = 0;
	int k = 0;
	for(i = 0; i < S-> len-count; i++)
	{
		for(j = i+1; j < S -> len-count;j++)
		{
			if(S->data[i] == S->data[j])
			{
				for(k = j; k<S -> len-count; k++)
				{
					S->data[k] = S->data[k+1];
				}
				count++;
				j--;
			}
		}
	}
	return ;
}



#include "seqlist.h"

int main(int argc, const char *argv[])
{
    //申请一个顺序表
    seqListPtr S = list_create();
    if(NULL == S)
    {
        return -1;
    }

    //调用添加函数
    list_add(S,3);
    list_add(S,8);
    list_add(S,2);
    list_add(S,4);

    //调用遍历函数
    list_show(S);

    //调用插入函数
    list_insert_pos(S, 1, 100);
    list_show(S);
	//按值进行查找元素
	list_search_value(S,8);
	//调用函数进行数据排序
	list_sort(S,1);
	//调用函数求最大值和最小值
	list_show(S);
	list_mvalue(S,1);
	//顺序表反转
	list_show(S);//逆值前
	list_reverse(S);
	//调用函数删除yuansu
	list_delete_pos(S,2); 
	//添加元素
	list_add(S,999);
	list_add(S,999);
	list_add(S,999);
	list_add(S,999);
	list_add(S,999);
	//删除重复的元素
	list_unique(S);
	list_show(S);
	
    return 0;
}