数据结构之顺序表

最新推荐文章于 2022-03-15 10:46:00 发布

超耐磨得

最新推荐文章于 2022-03-15 10:46:00 发布

阅读量126

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/weixin_42324404/article/details/84885363

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Seq.h

#ifndef _SEQ_H_
#define _SEQ_H_

#define INIT_SIZE 1
#define ADD_SIZE 5

typedef enum {TRUE, FALSE, ERROR} BOOL;

typedef int Data;
typedef struct _seq
{
	Data *pData;		//顺序表的最大存储空间
	int maxSize;		//最大存储空间
	int size;			//当前使用的空间
}Seq;

//创建顺序表
Seq* Create();

//为顺序表重新分配空间
BOOL AgainMalloc(Seq* s);

//插入数据：尾插
//s:要插入的顺序表
//data：要插入的数据
//返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Insert_Last(Seq* s, Data data);

//插入数据：头插
//s：要插入的顺序表
//data：要插入的数据
//返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Insert_Head(Seq* s, Data data);

//插入数据：根据位置插入数据
//s：要插入的顺序表
//index：要插入位置的下标
//data：要插入的数据
//返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Insert_Pos(Seq* s, int index, Data data);

//删除数据：根据位置删除数据
//s：要删除的顺序表
//index：要删除位置的下标
//返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Delete_Pos(Seq* s, int index);

//删除数据：删除某个特定数据
//s：要删除的顺序表
//index：要删除的数据
//返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Delete_Data(Seq* s, Data data);

//查找数据：查找某个特定数据
//[in]s：要查找的顺序表
//[in]data：要查找的数据
//[out]pindex：查找到的元素下标
//返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Find_Pos(Seq* s, Data data, int *pIndex);

//修改数据：修改某个特定数据
//[in]s：要修改的顺序表
//[in]data：要修改的数据
//[in]pindex ：要修改的元素下标
//返回值：成功返回 TRUE，失败返回FALSE，
BOOL Modify_Data(Seq* s, int index, Data data);

//合并两张有序表
//[in]s1：第一张顺序表
//[in]s2：第二张顺序表
//返回值：成功返回 第三张表，失败返回NULL
Seq *Merge_List(Seq *s1, Seq *s2);

//打印
void Display(Seq* s);

//销毁顺序表
void Destroy(Seq* s);



#endif //_SEQ_H_

Seq.c

#include <stdlib.h>
#include "Seq.h"
#include <stdio.h>

Seq* Create()
{
	Seq *s = (Seq*)malloc(sizeof (Seq)/sizeof (char));
	if (NULL == s)
		return NULL;
	
	//给顺序表分配空间
	s->pData = (Data*)malloc(sizeof (Data)/sizeof (char) * INIT_SIZE);
	if (NULL == s->pData)
	{
		free(s);
		
		return NULL;
	}
	
	s->maxSize = INIT_SIZE;
	s->size		  = 0;
	
	return s;	
}

BOOL AgainMalloc(Seq* s)
{
	if (NULL ==s)
		return ERROR;
	
	int newSize = sizeof(Data)/sizeof(char)*(s->maxSize+ADD_SIZE);//重新分配空间的大小
	
	Data* p = (Data*)realloc(s->pData, newSize);//重新分配空间
	if (NULL == p)
		return FALSE;
	
	s->pData		  = p;
	s->maxSize += ADD_SIZE;

	return TRUE;
	
}

BOOL Insert_Last(Seq* s, Data data)
{
	if (NULL ==s)
		return ERROR;
	
	if (s->size == s->maxSize)//如果当前使用空间与最大存储空间相等，
	{										//且没有重新分配空间，则返回FALSE
		if (AgainMalloc(s) != TRUE)
			return FALSE;
	}
	
	s->pData[s->size++] = data;//在第size位插入data
	
	return TRUE;
}

BOOL Insert_Head(Seq* s, Data data)
{
	if (NULL ==s)
		return ERROR;
	
	if (s->size == s->maxSize)
	{
		if (AgainMalloc(s) != TRUE)
			return FALSE;
	}
	
	int i = 0;
	for (i = s->size-1; i >= 0; i--)
		s->pData[i+1] = s->pData[i];//从右往左，将表内元素右移一位
	
	s->pData[0] = data;//在第0位插入data
	s->size++;//当前使用空间+1
	
	return TRUE;
}

BOOL Insert_Pos(Seq* s, int index, Data data)
{
	if (NULL ==s || index < 0 || index > s->size)//插入位置下标不能为负，且不能超出当前使用空间大小
		return ERROR;
	
	if (s->size == s->maxSize)
	{
		if (AgainMalloc(s) != TRUE)
			return FALSE;
	}
	
	int i = 0;
	for (i = s->size-1; i >= index; i--)
		s->pData[i+1] = s->pData[i];//自插入位，从右往左，将表内元素右移一位
	
	s->pData[index] = data;//在第index位插入data
	s->size++;//当前使用空间+1
	
	return TRUE;
}

BOOL Delete_Pos(Seq* s, int index)
{
	if (NULL ==s || index < 0 || index > s->size)
		return ERROR;
	
	int i;
	for (i = index; i < s->size-1; i++)
		s->pData[i] = s->pData[i+1];//自删除位，从右往左，将表内元素左移一位
	
	s->size--;//当前使用空间-1
	
	return TRUE;
}

BOOL Delete_Data(Seq* s, Data data)
{
	if (NULL ==s)
		return ERROR;
	
	int i;
	for (i = 0; i < s->size; i++)
	{
		if (s->pData[i] == data)//找到要删除的数据的下标
		{
			Delete_Pos(s, i);//删除该下标的数据
			
			return TRUE;
		}	
	}
	
	return FALSE;
}

BOOL Find_Pos(Seq* s, Data data, int *pIndex)
{
	if (NULL ==s)
		return ERROR;
	
	int i;
	for (i = 0; i < s->size; i++)
	{
		if (s->pData[i] == data)//找到数据的下标
		{
			*pIndex = i;//返回该下标
		
			return TRUE;
		}	
	}
	
	return FALSE;
}

BOOL Modify_Data(Seq* s, int index, Data data)
{
	if (NULL ==s || index < 0 || index > s->size)
			return ERROR;
	
	s->pData[index] = data;//将index位的数据修改为data
	
	return TRUE;
}

void Display(Seq* s)
{
	if (NULL == s)
		return;
	
	int i;
	for (i = 0; i < s->size; i++)
	{
		printf("%-4d", s->pData[i]);//输出顺序表，整型，输出宽度为4，左对齐
	}
	printf("\n");
}

Seq* Merge_List(Seq *s1, Seq *s2)
{
	if (NULL ==s1 || NULL ==s2)//s1或s2为空，返回NULL
		return NULL;
	
	//给顺序表s3分配空间
	Seq *s3 = (Seq*)malloc(sizeof (Seq)/sizeof (char));
	if (NULL == s3)
		return NULL;
	
	s3->pData = (Data*)malloc(sizeof (Data)/sizeof (char) * (s1->size+s2->size));
	if (NULL == s3->pData)
	{
		free(s3);
		
		return NULL;
	}
	
	s3->maxSize = s1->size+s2->size;
	s3->size		  = s1->size+s2->size;
	//end 给顺序表s3分配空间
	
	int i = 0;//s1下标
	int j = 0;//s2下标
	int k = 0;//s3下标
	
	while(i<s1->size && j<s2->size)//s1、s2都没用完
	{												  
		if (s1->pData[i] < s2->pData[j])//s1，s2元素比大小，如果元素相等，优先输出s2
		s3->pData[k++] = s1->pData[i++];//s1的元素更小，将s1赋给s3，并指向下一个元素
	else
		s3->pData[k++] = s2->pData[j++];//s2的元素更小，将s1赋给s3，并指向下一个元素
	}
	
	while(i<s1->size)//s1没用完
	{
		s3->pData[k++] = s1->pData[i++];//将s1剩余的元素全部赋给s3
	}
	
	while(j<s2->size)//s2没用完
	{
		s3->pData[k++] = s2->pData[j++];//将s2剩余的元素全部赋给s3
	}
	
	return s3;	
	
}

void Destroy(Seq* s)
{
	if (NULL == s)
		return;
	
	free(s->pData);//释放顺序表空间
	free(s);//释放结构体空间
}

main.c

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

int main()
{
	Seq* s = Create();
	
	if (NULL == s)
		printf("failed\n");
	else
		printf("succeed\n");
	
	int i;
	for (i = 0; i < 20; i++)
	{
		//Insert_Last(s,  i);
		Insert_Head(s, i);
	}

	Display(s);
	Insert_Pos(s, 0, 100);
	Display(s);
	
	Insert_Pos(s, s->size, 200);
	Display(s);
	
	Insert_Pos(s, 5, 123);
	Display(s);
	
	printf ("------------------------\n");
	Delete_Pos(s, 5);
	Display(s);
	
	Delete_Pos(s, s->size-1);
	Display(s);
	
	Delete_Pos(s, 0);
	Display(s);
	
	printf ("------------------------\n");
	Delete_Data(s, 6);
	Display(s);
	
	int index;
	Find_Pos(s, 7, &index);
	printf("查找元素7是第%d个元素\n", index+1);
	
	Modify_Data(s, 1, 65535);
	Display(s);
	
	printf ("------------------------\n");
	Seq *s1 = Create();
	Seq *s2 = Create();
	
	Insert_Last(s1,  1);
	Insert_Last(s1,  3);
	Insert_Last(s1,  5);
	Insert_Last(s1,  7);
	Insert_Last(s1,  9);
	Insert_Last(s1,  11);
	Insert_Last(s1,  13);
	Insert_Last(s1,  15);
	
	Insert_Last(s2, 1);
	Insert_Last(s2,  4);
	Insert_Last(s2,  6);
	Insert_Last(s2,  8);
	Insert_Last(s2,  10);
	Insert_Last(s2,  12);
	
	Seq *s3 = Merge_List(s1, s2);
	Display(s3);
	
	Destroy(s1);
	Destroy(s2);
	Destroy(s3);
	

	Destroy(s);
	
	return 0;
}

超耐磨得

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构之顺序表

Seq.h#ifndef _SEQ_H_#define _SEQ_H_#define INIT_SIZE 1#define ADD_SIZE 5typedef enum {TRUE, FALSE, ERROR} BOOL;typedef int Data;typedef struct _seq{ Data *pData; //顺序表的最大存储空间 int maxSi...
复制链接

扫一扫

专栏目录