数据结构-顺序表

φ冰霰ξ

已于 2023-07-31 18:15:47 修改

阅读量570

点赞数 9

文章标签： c语言学习数据结构

于 2023-02-26 14:22:11 首次发布

本文链接：https://blog.csdn.net/weixin_72501602/article/details/129224539

版权

目录

前言

一、函数表与参数表

二、代码分享

三、运行截图

总结

作者还在尽量优化上述代码，希望看到这篇博客的大佬能够给出一些建议，非常感谢！

前言

本篇博客将会分享解决下列问题的代码

1.输入-组整型元素序列，建立顺序表(本文用for循环控制输入元素个数，可以使用while循环更加自由的输入)
2.实现线性表的增删查改
3.在该顺序表中进行顺序查找某一元素 ,查找成功返回1,否则返回0
4.实现把该表中所有奇数排在偶数之前,即表的前面为奇数，后面为偶数
5.判断该顺序表中元素是否对称,对称返回1,否则返回0
6.输入整型元素序列利用有序表插入算法把它们排序成一个有序表
7.利用实验内容6建立两个递增有序表并把它们合并成一个递增有序表

一、函数表与参数表

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

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 40

typedef int ElemType;
typedef int Status;

初始化
//功能：构造一个空的顺序表L
//参数：线性表的地址L
Status InitList(SqList* L);

插入
//功能：插入一个元素e到线性表L中位置为i的空间上
//参数：线性表的地址L，位置i，插入的元素e
Status ListInsert(SqList* L, int i, ElemType e);

取值
//功能：取出线性表L中位置为i的数据，存放在e中
//参数：线性表的地址L，位置i，取出的元素e
Status GetElem(SqList* L, int i, ElemType* e);

查找
//功能：查找线性表L中是否存在元素e，存在则返回元素e的位置
//参数：线性表L，被查找的元素e
Status LocateElem(SqList L, ElemType e);

删除
//功能：删除线性表L中位置为i的元素，并存放在e中以备使用
//参数：线性表地址L，位置i，存放被删除元素的e
Status ListDelete(SqList* L, int i, ElemType* e) 

判断
//功能：判断线性表的元素是否对称，对称则返回1，不对称则返回0
//参数：线性表地址L
Status IsSymmetry(SqList* L);

排序
//功能：把线性表L中所有为奇数的元素调整到所有为偶数元素的前面
//参数：线性表地址L
void SortOddEven(SqList* L);

排序
//功能：有序排列顺序表(递增 / 递减)
//参数：线性表地址L
void SortElem(SqList* L);

合并
//功能：有序合并L1与L2，形成一个递增的线性表L3
//参数：线性表地址L1、L2、L3
void MergeElem(SqList* L1, SqList* L2, SqList* L3);

打印输出
void print(SqList L);



//自定义bubble_sort冒泡排序(我们也可以直接使用快速排序qsort)

//比较两个数据 p1 和 p2 的大小，返回int类型的结果
int cmp(const void* p1, const void* p2);
//交换两个数据 buf1 和 buf2 的内容
void swap(char* buf1, char* buf2, int width);
//自定义冒泡排序
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2));

二、代码分享

头文件 list.h

#pragma once

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

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 40

typedef int ElemType;
typedef int Status;

typedef struct
{
	ElemType* elem;//数据
	int length;//长度
}SqList;

//初始化
Status InitList(SqList* L);

//插入
Status ListInsert(SqList* L, int i, ElemType e);

//取值
Status GetElem(SqList* L, int i, ElemType* e);

//查找
Status LocateElem(SqList L, ElemType e);

//删除
Status ListDelete(SqList* L, int i, ElemType* e);

//判断线性表的元素是否对称
int IsSymmetry(SqList L);

//排序，奇数在前面，偶数在后面
void SortOddEven(SqList* L);

//自定义bubble_sort↓↓↓
//比较
int cmp(const void* p1, const void* p2);
//交换
void swap(char* buf1, char* buf2, int width);
//调用
void bubble_sort(void* base, size_t num, size_t width,
	int (*cmp)(const void* p1, const void* p2));
//自定义bubble_sort↑↑↑

//有序排列(递增 / 递减)
void SortElem(SqList* L);

//有序合并L1与L2，形成一个递增的线性表L3
void MergeList(SqList* L1, SqList* L2, SqList* L3);

//打印输出
void print(SqList L);

源文件 list.c

#include "list.h"

//初始化
Status InitList(SqList* L)
{
	assert(L != NULL);
	//为(ElemType*)类型的elem开辟一段内存空间，大小为 elem的最大元素个数 * 每个元素的大小
	L->elem = (ElemType*)malloc(MAXSIZE * sizeof(ElemType));
	if (!L->elem)//内存分配失败
	{
		return OVERFLOW;
	}
	L->length = 0;//线性表初始长度为0
	return OK;
}

//插入
Status ListInsert(SqList* L, int i, ElemType e)
{
	assert(L != NULL);
	if (i<1 || i>(L->length + 1) || L->length == MAXSIZE)//判断插入的位置是否合法
		return ERROR;
	for (int j = L->length - 1; j >= i - 1; j--)//被插入的位置后面的所有元素后移一位
		L->elem[j + 1] = L->elem[j];
	L->elem[i - 1] = e;
	L->length++;
	return OK;
}

//取值
Status GetElem(SqList* L, int i, ElemType* e)
{
	assert(L != NULL);
	if (i < 1 || i > (L->length))//判断位置i是否合法
		return ERROR;
	*e = L->elem[i - 1];//把取出的数据保存下来，以备使用
	return OK;
}

//查找
Status LocateElem(SqList L, ElemType e)
{
	for (int i = 0; i < L.length; i++)//遍历
	{
		if (L.elem[i] == e)
			return i + 1;//返回被查找元素的位置
	}
	return 0;
}

//删除
Status ListDelete(SqList* L, int i, ElemType* e) 
{
	int k;
	if (L->length == 0) 
	{   //线性表为空
		return ERROR;
	}
	if (i < 1 || i > L->length) { //删除位置不正确
		return ERROR;
	}
	*e = L->elem[i - 1];
	//如果被删除元素不是最后一个，则需要把它后面的元素全部前移一位
	if (i < L->length)
	{  
		for (k = i; k < L->length; k++) 
		{
			L->elem[k - 1] = L->elem[k];
		}
	}
	L->length--;    //长度减1
	return OK;
}

//判断线性表的元素是否对称
int IsSymmetry(SqList L)
{
	int i = 0, j = L.length - 1;
	while (j > i)
	{
		if (L.elem[i] != L.elem[j])//不对称返回0
		{
			return 0;
		}
		i++, j--;
	}
	return 1;
}

//排序，奇数在前面，偶数在后面
void SortOddEven(SqList* L)
{
	assert(L != NULL);
	int i = 0, j = 0;
	for (i = 0; i < L->length; i++)//遍历线性表
	{
		if (L->elem[i] % 2 == 1)//找到第一个偶数
		{
			for (j = 0; j < L->length; j++)//寻找第一个奇数
			{
				if (L->elem[j] % 2 == 0)//交换它们
				{
					ElemType tmp = L->elem[i];
					L->elem[i] = L->elem[j];
					L->elem[j] = tmp;
					break;
				}
			}
		}
		if (j == L->length)//j为最后一个元素时，排序结束
			break;
	}
}

//自定义bubble_sort↓↓↓
//比较
int cmp(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

//交换
void swap(char* buf1, char* buf2, int width)//我们不知道ElemType的类型，所以逐字节交换
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++, buf2++;
	}
}

void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	for (size_t i = 0; i < num - 1; i++)
	{
		for (size_t j = 0; j < num - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)//升序
			{
				//交换
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
//自定义bubble_sort↑↑↑

//有序排列(递增 / 递减)
void SortElem(SqList* L)
{
	assert(L != NULL);
	bubble_sort(L->elem, L->length, sizeof(L->elem[0]), cmp);
}

//有序合并L1与L2，形成一个递增的线性表L3
void MergeList(SqList *L1, SqList *L2, SqList *L3) 
{
	assert(L1 && L2 && L3);
	int i = 0, j = 0, k = 0;
	L3->length = L1->length + L2->length;
	while (i < L1->length && j < L2->length)
	{
		if (L1->elem[i] < L2->elem[j])
		{
			L3->elem[k] = L1->elem[i++];
		}
		else 
		{
			L3->elem[k] = L2->elem[j++];
		}
		k++;
	}
	while (k < L3->length)
	{
		if (i == L1->length)
		{
			L3->elem[k] = L2->elem[j++];
		}
		else {
			L3->elem[k] = L1->elem[i++];
		}
		k++;
	}
}

//打印输出
void print(SqList L)
{
	printf("当前顺序表的长度为:%d\n", L.length);
	for (int i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

源文件 test.c

测试代码，大家可以自由发挥

#include "list.h"

int main()
{
	//初始化
	SqList L1;//构造一个空的线性表
	InitList(&L1);//线性表初始化
	print(L1);//打印空的线性表
	//插入10个数进行初始化
	for (int i = 1; i <= 10; i++)
	{
		int input1 = 0;
		scanf("%d", &input1);
		ListInsert(&L1, i, input1);
	}
	print(L1);

	//查找
	int input = 0;
	printf("请输入要查找的数:>");
	scanf("%d", &input);
	if (LocateElem(L1, input))
		printf("找到了，位置在第%d位\n", LocateElem(L1, input));
	else
		printf("找不到\n");

	//判断线性表的元素是否对称
	printf("判断线性表的元素是否对称\n");
	printf("%d\n", IsSymmetry(L1));
	//print(L);

	//排序，奇数在前面，偶数在后面
	printf("重新排序，使奇数在前面，偶数在后面\n");
	SortOddEven(&L1);
	print(L1);

	//递增排序线性表
	printf("递增排序线性表\n");
	SortElem(&L1);
	print(L1);

	//利用SortElem建立两个递增有序表，并把它们合成一个递增有序表
	//构造第二个线性表L2
	SqList L2;
	InitList(&L2);
	printf("请输入10个数构造第二个线性表\n");
	for (int i = 1; i <= 10; i++)
	{
		int input2 = 0;
		scanf("%d", &input2);
		ListInsert(&L2, i, input2);
	}
	SortElem(&L2);
	print(L2);

	//构造一个线性表L3用于存放L1、L2的元素
	SqList L3;
	InitList(&L3);

	//有序合并
	MergeList(&L1, &L2, &L3);
	print(L3);

	return 0;
}