顺序表一系列操作

最新推荐文章于 2021-03-13 21:18:36 发布
最新推荐文章于 2021-03-13 21:18:36 发布
阅读量290 收藏 1
点赞数 1
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Scenlyf/article/details/51637538

    在顺序表中，每个结点的存储地址是该结点在表中的位置的线性函数，是一种随机存取结构。顺序表是用向量实现的线性表，向量的下标可以看作结点的相对地址。因此顺序表的的特点是逻辑上相邻的结点其物理位置亦相邻。下面对顺序表进行头插、头删、尾插、尾删、指定位置插入数据、查找数据位置、删除某一个数、折半查找、冒泡排序和选择排序等操作并进行测试。

头函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

#define MAX_SIZE 100
typedef int DataType;

typedef struct SeqList
{
	DataType arry[MAX_SIZE];
	size_t size;
}SeqList;

各函数的编写：

#include"SeqList.h"

void PrintSeqList(SeqList* pSeq)
{
	assert(pSeq);
	if (pSeq->size > 0 && pSeq->size <= MAX_SIZE)
	{
		for (int begin = 0; begin < (int)pSeq->size; begin++)
		{
			printf("%d ", pSeq->arry[begin]);
		}
	}
	else
	{
		printf("SeqList is Empty!");
		return;
	}
}
void InitSeqList(SeqList* pSeq)
{
	assert(pSeq);
	pSeq->size = 0;
	for (int begin = 0; begin < (int)pSeq->size; begin++)
	{
		pSeq->arry[begin] = 0;
	}
}
void PushBack(SeqList* pSeq, DataType x)//尾插
{
	assert(pSeq);
	if (pSeq->size >= MAX_SIZE)
	{
		printf("SeqList is Full!");
		return;
	}
	else
	{
		pSeq->arry[pSeq->size] = x;
        ++pSeq->size;
	}	
}
void PopBack(SeqList* pSeq)//尾删
{
	assert(pSeq);
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	else
	{
		pSeq->arry[pSeq->size] = 0;
		--pSeq->size;
	}
}
void PushFront(SeqList* pSeq, DataType x)//头插
{
	assert(pSeq);
	if (pSeq->size >= MAX_SIZE)
	{
		printf("SeqList is Full!");
		return;
	}
	else
	{
		for (int i = pSeq->size; i > 0; i--)
		{//第一位数以后的数从后往前依次后移一位
			pSeq->arry[i] = pSeq->arry[i - 1];
		}
		pSeq->arry[0] = x;//第一位插入x
		++pSeq->size;
	}
}
void PopFront(SeqList* pSeq)//头删
{
	assert(pSeq);
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	else
	{
		for (int i = 0; i < (int)pSeq->size - 1; i++)
		{//第一位以后的数从前向后依次前移一位
			pSeq->arry[i] = pSeq->arry[i + 1];
		}
		--pSeq->size;
	}
}

void Insert(SeqList* pSeq, size_t pos, DataType x)//在指定位置处插入一个数
{
	assert(pSeq);
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	else if (pSeq->size < pos || pos<0)
	{
		printf("Position is not exist!");
		return;
	}
	else
	{
		for (int i = (int)pSeq->size; i > (int)pos - 1; i--)
		{//第pos-1位以后的数从后往前依次后移一位
			pSeq->arry[i] = pSeq->arry[i - 1];
		}
		pSeq->arry[pos - 1] = x;//第pos位插入x
		++pSeq->size;
	}
}
int Find(SeqList* pSeq, DataType x)//查找指定数的位置
{
	assert(pSeq);
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return -1;
	}
	else
	{
		for (int i = 0; i < (int)pSeq->size; i++)
		{
			if (pSeq->arry[i] == x)
				return i + 1;
		}
		printf("x is not exist!");
		return -1;
	}
}
void Erase(SeqList* pSeq, size_t pos)//删除某位的值
{
	assert(pSeq);
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	else if (pSeq->size < pos || pos<0)
	{
		printf("Position is not exist!");
		return;
	}
	else
	{
		for (int i = (int)pos - 1; i < (int)pSeq->size - 1; i++)
		{//第pos位以后的数从前向后依次前移一位
			pSeq->arry[i] = pSeq->arry[i + 1];
		}
		--pSeq->size;
	}
}
void Remove(SeqList* pSeq, DataType x)//删除某数
{
	assert(pSeq);
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	int pos = Find(pSeq, x);
	Erase(pSeq, pos);
}
void RemoveAll(SeqList* pSeq, DataType x)//删除所有x
{
	assert(pSeq);
	int count = 0;
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	for (int i = 0; i < (int)pSeq->size; i++)
	{
		//1 2 3 4 3 5 3
		//如果删除所有3，当遇到一个3时，count++;其后面的数依次前移count位
		if (pSeq->arry[i] == x)
			count++;
		else
			pSeq->arry[i - count] = pSeq->arry[i];
	}
	pSeq->size -= count;
}

void swap(int* num1, int* num2)
{
	assert(num1);
	assert(num2);
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}
void BubbleSort(SeqList* pSeq)//冒泡排序
{
	assert(pSeq);
	int flag;//冒泡排序的优化:定义一个标志位flag，接近有序时停止冒泡
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	for (int j = 0; j < (int)pSeq->size - 1; j++)//排序pSeq->size - 1趟
	{
		for (int i = 0; i < (int)pSeq->size - j - 1; i++)//每一趟冒泡出一个最大数
		{
			flag = 0;
			if (pSeq->arry[i] > pSeq->arry[i + 1])
			{
				flag = 1;
				swap(&pSeq->arry[i], &pSeq->arry[i + 1]);
			}
			if (flag = 0)
				return;
		}
	}
}
//选择排序的优化：一次选出最大最小的数据分别放在序列的两端
void SeclectSort(SeqList* pSeq)
{
	assert(pSeq);
	int i, j, min, max;
	int len = pSeq->size - 1;
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return;
	}
	for (i = 0; i < (int)pSeq->size - 1; i++, len--)
	{
		min = 0;
		max = len;
		for (j = i; j <= max; j++)
		{//比较第i个元素和其后的元素找到最小的和最大的
			if (pSeq->arry[j] < pSeq->arry[min])
				swap(&pSeq->arry[j], &pSeq->arry[min]);
			if (pSeq->arry[j] > pSeq->arry[max])
				swap(&pSeq->arry[j], &pSeq->arry[max]);
		}
	}

}

int BinarySearch(SeqList* pSeq, DataType x)//折半查找
{
	assert(pSeq);
	int left = 0;
	int right = pSeq->size;//此法为左闭右开区间
	//int right = pSeq->size - 1;此法为左闭右闭区间
	if (pSeq->size <= 0)
	{
		printf("SeqList is Empty!");
		return -1;
	}
	while (left < right)
	//while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (pSeq->arry[mid] < x)
			left = mid + 1;
		else if (pSeq->arry[mid] > x)
			right = mid;
		//right = mid - 1;
		else
			return mid + 1;
	}
	return -1;
}

主函数中对各函数进行测试用例：

#include"SeqList.h"

void PrintSeqList(SeqList* pSeq);
void InitSeqList(SeqList* pSeq);
void PushBack(SeqList* pSeq, DataType x);
void PopBack(SeqList* pSeq);
void PushFront(SeqList* pSeq, DataType x);
void PopFront(SeqList* pSeq);

void Insert(SeqList* pSeq, size_t pos, DataType x);
int Find(SeqList* pSeq,DataType x);
void Erase(SeqList* pSeq, size_t pos);//删除某位的值
void Remove(SeqList* pSeq, DataType x);//删除某数
void RemoveAll(SeqList* pSeq, DataType x);//删除所有x

void BubbleSort(SeqList* pSeq);
//冒泡排序的优化：一次选出最大最小的数据分别放在序列的两端
void SeclectSort(SeqList* pSeq);
int BinarySearch(SeqList* pSeq, DataType x);

void Test1()
{//尾插尾删
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq);
	PopBack(&seq);
	PopBack(&seq);
	printf("\n---------------\n");
	PrintSeqList(&seq);
	PopBack(&seq);
	PopBack(&seq);
	printf("\n---------------\n");
	PopBack(&seq);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test2()
{//头插头删
	SeqList seq;
	InitSeqList(&seq);
	PushFront(&seq, 1);
	PushFront(&seq, 2);
	PushFront(&seq, 3);
	PushFront(&seq, 4);
	PrintSeqList(&seq);
	PopFront(&seq);
	PopFront(&seq);
	printf("\n---------------\n");
	PrintSeqList(&seq);
	PopFront(&seq);
	PopFront(&seq);
	printf("\n---------------\n");
	PopFront(&seq);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test3()
{//在指定位置处插入一个数
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 5);
	PrintSeqList(&seq);
	Insert(&seq, 2, 2);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test4()
{//查找指定数的位置
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq); 
	printf("\n---------------\n");
	printf("%d\n",Find(&seq, 2));
}

void Test5()
{//删除某位的值
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq);
	Erase(&seq, 3);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test6()
{//删除某数
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq);
	Remove(&seq, 2);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test7()
{//删除所有指定的数
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 3);
	PushBack(&seq, 5);
	PushBack(&seq, 3);
	PrintSeqList(&seq);
	RemoveAll(&seq, 3);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test8()
{//冒泡排序
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 8);
	PushBack(&seq, 7);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 6);
	PushBack(&seq, 5);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PrintSeqList(&seq);
	BubbleSort(&seq);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test9()
{//选择排序
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 8);
	PushBack(&seq, 7);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 6);
	PushBack(&seq, 5);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PrintSeqList(&seq);
	SeclectSort(&seq);
	printf("\n---------------\n");
	PrintSeqList(&seq);
}

void Test10()
{//折半查找
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 0);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq);
	printf("\n---------------\n");
	printf("%d is position %d\n", 3, BinarySearch(&seq, 3));
}

int main()
{
	Test1();
	printf("\n*********************\n");
	Test2();
	printf("\n*********************\n");
	Test3();
	printf("\n*********************\n");
	Test4();
	printf("\n*********************\n");
	Test5();
	printf("\n*********************\n");
	Test6();
	printf("\n*********************\n");
	Test7();
	printf("\n*********************\n");
	Test8();
	printf("\n*********************\n");
	Test9();
	printf("\n*********************\n");
	Test10();
	system("pause");
}

小知识：

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

可以采用两种方式（如上述程序中所示）：

方法一，采用[]闭区间的方式。

方法二，采用[ )左闭右开的方式。

本文出自 “Scen” 博客，请务必保留此出处http://10741357.blog.51cto.com/10731357/1731042

S-Lyf
关注
PTA数据结构 6-1 单链表逆转 6-2 顺序表操作集
qq_44494246的博客
03-21 1861
6-1 单链表逆转 题目要求： 本题要求实现一个函数，将给定的单链表逆转。 代码如下： List Reverse(List head){ List *p,*pre; p=NULL; while(head!=NULL){ pre=head->Next; head->Next=p; p=head; head=pre; } return p; } 本题思路： ...
顺序表操作集
swineherd的博客
07-27 533
  6-2 顺序表操作集（20 分） 本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结...
静态顺序表的一系列操作
shine_zyd_way的博客
09-10 634
自定义头文件部分：#define _CRT_SECURE_NO_WARNINGS 1 #ifndef __SEQLIST_H__ #define __SEQLIST_H__#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h>#define MAX_SIZE 1000//最大容量 typedef
【数据结构习题】顺序表操作集
qq_45628620的博客
03-13 1621
功能 本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef int Position; typedef struct LNode *List; struct LNode { El
数据结构上机_顺序表基本操作_数据结构基础_
09-29
在本课题中，我们将深入探讨"数据结构上机_顺序表基本操作_数据结构基础_"这一主题，这涉及到一系列在顺序表上的基本操作，包括初始化、输出、插入、删除、计算长度、逆置、排序以及合并有序顺序表等。 顺序表是一...
顺序表基本操作完整版代码
最新发布
05-17
顺序表是一种基本的数据结构，它由一系列元素按照一定的顺序进行排列组合，并且这些元素类型相同，通过数组进行存储。顺序表的结构相对简单，它提供了一种线性存储的方式，使得元素可以按顺序快速访问。对于顺序表的...
线性表--顺序表操作
12-12
1. **插入操作**：在顺序表中插入一个元素时，通常需要移动一系列元素来为新元素腾出位置。如果表已满，可能需要进行动态扩展，例如通过创建一个更大的数组并复制现有元素。 2. **删除操作**：删除元素时，同样需要...
线性表之顺序表
03-28
建立顺序表通常是从空表开始，通过一系列插入操作将元素添加到表中。例如，可以初始化一个足够大的数组，然后逐个将元素加入数组的末尾。这种方法简单直接，但需要注意动态调整数组大小的问题，以适应元素数量的变化...
C语言 使用自定义顺序表实现非递减顺序表合并
10-07
在本例中，程序的文件名“Data Structure SqeList”暗示了这是一个与数据结构相关的项目，可能包含了一系列关于顺序表操作的代码文件。这表明开发者可能需要处理多个与顺序表相关的功能，如创建、删除、排序、搜索等...
顺序表操作集合
07-03
功能： 1-建表 2-遍历表 3-插入元素 4-删除元素 5-排序元素 6-清屏(只显示菜单) 7-表长度 8-退出
顺序表的操作集
qq_45804132的博客
05-27 500
顺序表的操作集 数据结构我们接触的大多资料为伪代码，因此这里我建议大家去PTA，LEETCODE什么的去找一些考操作的题目会对这些学习帮助很大。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef int Pos
数据结构及算法——顺序表操作集（C语言）
aaa946231的博客
01-21 1192
本题要求实现顺序表的操作集。 函数接口定义List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P );其中List结构定义如下：typedef int Position; t
4-2 顺序表操作集
H_237785的博客
12-18 203
函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef int Position;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值