顺序表的基本操作——静态实现

最新推荐文章于 2022-07-18 16:53:03 发布
最新推荐文章于 2022-07-18 16:53:03 发布
阅读量613 收藏 1
点赞数 1
分类专栏： C语言 数据结构 线性表——链表、顺序表 C++基础（1）——指针，字符函数，模板 数据结构 文章标签： 顺序表 增删查改 静态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/poison_biti/article/details/51525160
版权

"SeqList.h"

<strong><span style="font-size:18px;">#ifndef __SEQLIST_H__//防止重定义
#define __SEQLIST_H__
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

#define  MAX 5
typedef int DataType;//typedef语句后面要有一个分号；

typedef struct SeqList
{
	DataType Data[MAX];
	int size;
}SeqList,*pSeqList;

//初始化
void InitSeqList(pSeqList pSeq);
//打印
void PrintSeqList(pSeqList pSeq);
//尾插法
void PushBack(pSeqList pSeq,DataType x);
//尾删法
void PopBack(pSeqList pSeq);
//头插法
void PushFront(pSeqList pSeq,DataType x);
//头删法
void PopFront(pSeqList pSeq);
//查找某个数据在顺序表中的位置
int Find(pSeqList pSeq,DataType x);
//在某个下标中插入一个数据
void Insert(pSeqList pSeq,int pos,DataType x);
//删除x的数据
void Remove(pSeqList pSeq,DataType x);
//删除所有x的数据
void RemoveAll(pSeqList pSeq,DataType x);
//升序排序顺序表
void Sort(pSeqList pSeq);
//二分查找
int BinarySearch(pSeqList pSeq,DataType x);
//删除下标为pos的数据
void Erase(pSeqList pSeq,size_t pos);
//选择排序
void SelectSort(pSeqList pSeq);
#endif  //__SEQLIST_H__</span></strong>


 

"SeqList.c"

<strong><span style="font-size:18px;">#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void InitSeqList(pSeqList pSeq)
{
	pSeq->size = 0;
	//memset(pSeq->Data,0,sizeof(DataType)*MAX);   //初始化结构体中Data的值
	memset(pSeq, 0, sizeof(pSeq)*MAX);             //初始化整个结构体
	
}
// 1、参数合法性检测
// 边界条件
// 实现逻辑
void PrintSeqList(pSeqList pSeq)
{
	int i = 0;
	for (i = 0; i < pSeq->size;i++)
	{
		printf("%d  ",pSeq->Data[i]);
	}
	printf("\n");
}
void PushBack(pSeqList pSeq,DataType x)//尾插法
{
	assert(pSeq);
	if (pSeq->size >= MAX)
	{
		printf("SeqList is full\n");
		return;
	}
	pSeq->Data[pSeq->size] = x;
	pSeq->size++;
}
void PopBack(pSeqList pSeq)//尾删法
{
	assert(pSeq);
	if (pSeq->size == 0)
	{
		printf("SeqList is empty\n");
		return;
	}
	pSeq->size--;
}
void PushFront(pSeqList pSeq,DataType x)
{
	int i = 0;
	assert(pSeq);
	if (pSeq->size >= MAX)
	{
		printf("SeqList is full\n");
		return;
	}
	else if(pSeq->size == 0)
	{
		pSeq->Data[0] = x;
		pSeq->size++;
	} 
	else
	{
		//for (i = 0;i<pSeq->size;i++)    //这是一个严重的错误，会把原来的值覆盖掉
		//{
		//	pSeq->Data[i+1] = pSeq->Data[i];
		//}

		//搬移元素
		for (i = pSeq->size;i>=0;i--)
		{
			pSeq->Data[i] = pSeq->Data[i - 1];
		}

		pSeq->Data[0] = x;
		pSeq->size++;
	}
}
void PopFront(pSeqList pSeq)
{
	int i = 0;
	assert(pSeq);
	if (pSeq->size == 0)
	{
		printf("SeqList is empty\n");
	}

	for (i = 0;i < pSeq->size;i++)
	{
		pSeq->Data[i] = pSeq->Data[i+1];
	}
	pSeq->size--;
}
int Find(pSeqList pSeq,DataType x)
{
	int i = 0;
	assert(pSeq);

	if (pSeq->size == 0)
	{
		printf("SeqList is empty\n");
		return;
	}

	for (i = 0;i < pSeq->size; i++)
	{
		if (x == pSeq->Data[i])
		{
			return i;//如果找得到x，则返回x所在下标的值
		}
	}

	return -1;//如果没有找到x，则返回一个负数
}
void Insert(pSeqList pSeq,int pos,DataType x)
{
	int i = 0;
	assert(pSeq);
	if (pSeq->size >= MAX)
	{
		printf("SeqList is full\n");
		return;
	}

	if (pos <= pSeq->size)
	{
		for (i = pSeq->size;i>pos;i--)
		{
			pSeq->Data[i] = pSeq->Data[i - 1];
		}

		pSeq->Data[pos] = x;
		pSeq->size++;
	} 
	else
	{
		printf("pos is error\n");
	}
}
void Erase(pSeqList pSeq,size_t pos)
{
	int i = 0;
	if (pSeq->size == 0 || pos > pSeq->size - 1)
	{
		return;
	}

	for (i = pos;i<pSeq->size;i++)
	{
		pSeq->Data[i] = pSeq->Data[i + 1];
	}
	pSeq->size--;
}
void Remove(pSeqList pSeq,DataType x)
{
	//调用函数方法
	int pos = 0;
	assert(pSeq);

	if (pSeq->size == 0)
	{
		printf("Seqlist is empty\n");
		return;
	}

	pos = Find(pSeq,x);
	if (pos <0)
	{
		printf("no find x\n");
		return;
	} 
	else
	{
		Erase(pSeq,pos);
	}

	//非函数调用方法
	//int i = 0;
	//assert(pSeq);
	//if (pSeq->size == 0)
	//{
	//	printf("SeqList is empty\n");
	//}

	//for (i = 0;i < pSeq->size;i++)
	//{
	//	if (pSeq->Data[i] == x)
	//	{
	//		for (;i<pSeq->size;i++)
	//		{
	//			pSeq->Data[i] = pSeq->Data[i+1];
	//		}
	//		pSeq->size--;
	//		return;
	//	}
	//} 

	//if (i == pSeq->size)
	//{
	//	printf("no find x\n");
	//	return;
	//}
}
void RemoveAll(pSeqList pSeq,DataType x)
{
	int i = 0;
	//int j = 0;
	int count = 0;
	assert(pSeq);
	if (pSeq->size == 0)
	{
		printf("SeqList is empty\n");
	}

	//方法一
	//do 
	//{
	//	j = i;
	//	if (pSeq->Data[j] == x)
	//	{
	//		for (;j<pSeq->size;j++)
	//		{
	//			pSeq->Data[j] = pSeq->Data[j+1];
	//		}
	//		pSeq->size--;
	//	} 
	//	else
	//	{
	//		i++;
	//	}
	//} while (i<pSeq->size);

	//方法二
	for (i = 0;i < pSeq->size;i++)
	{
		if (x == pSeq->Data[i])
		{
			count++;
		} 
		else
		{
			pSeq->Data[i-count] = pSeq->Data[i];
		}
	}
	pSeq->size -= count;  //有效size随着count的增加而减少
}

void SelectSort(pSeqList pSeq)   //选择排序
{
	int i = 0, j = 0;
	int iMaxPos = 0;
	int iMinPos = 0;

	DataType temp;
	for (; i < pSeq->size/2; ++i)
	{
		iMaxPos = i;
		iMinPos = i;
		for (j = 1; j < pSeq->size - i; j++)
		{
			if (pSeq->Data[iMaxPos] < pSeq->Data[j])
			{
				iMaxPos = j;
			}

			if (pSeq->Data[iMinPos] > pSeq->Data[j])
			{
				iMinPos = j;
			}
		}

		if (iMaxPos != i)
		{
			temp = pSeq->Data[iMaxPos];
			pSeq->Data[iMaxPos] = pSeq->Data[pSeq->size - i - 1];
			pSeq->Data[pSeq->size - i - 1] = temp;
		}

		if (iMinPos != i)
		{
			temp = pSeq->Data[iMinPos];
			pSeq->Data[iMinPos] = pSeq->Data[i];
			pSeq->Data[i] = temp;
		}
	}
}
void Sort(pSeqList pSeq)
{
	int tmp = 0; 
	int i = 0;
	int j = 0;
	assert(pSeq);

	for (i = 0;i < pSeq->size-1;i++)//做n-1趟排序
	{
		for (j = 0;j < pSeq->size - i -1;j++)//每次比较的个数越来越少
		{
			if (pSeq->Data[j]>pSeq->Data[j+1])
			{
				tmp = pSeq->Data[j];
				pSeq->Data[j] = pSeq->Data[j+1];
				pSeq->Data[j+1] = tmp;
			}
		}
	}
}
int BinarySearch(pSeqList pSeq,DataType x)    //二分查找
{
	int left = 0;
	int right = 0;
	int mid = 0;
	assert(pSeq);
	Sort(pSeq);

	left = 0;
	right = pSeq->size-1;

	while(left <= right)
	{
		//mid = (left+right)>>1;              //求中间值，用这两种方法写出来的代码会比较高端一些
		mid = left + (right - left)/2;    //如果mid=(left+right)/2的话，有些情况下会溢出

		if (pSeq->Data[mid] < x)
		{
			left = mid + 1;
		}
		else if (pSeq->Data[mid] > x)
		{
			right = mid - 1;
		} 
		else
		{
			return mid;
		}
	}

	return -1;
}</span></strong>


 

"test.c"

<strong><span style="font-size:18px;">#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void Test1()//PushBack
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,5);
	PushBack(&seq,8);

	PrintSeqList(&seq);
}
void Test2()//PopBack	
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,5);

	PrintSeqList(&seq);

	PopBack(&seq);
	PopBack(&seq);
	PopBack(&seq);
	//PopBack(&seq);
	//PopBack(&seq);
	//PopBack(&seq);

	PrintSeqList(&seq);
}
void Test3()//PushFront
{
	SeqList seq;
	InitSeqList(&seq);
	PushFront(&seq,1);
	PushFront(&seq,2);
	PushFront(&seq,3);
	//PushFront(&seq,4);
	//PushFront(&seq,5);
	//PushFront(&seq,8);

	PrintSeqList(&seq);
}
void Test4()//PopFront
{
	SeqList seq;
	InitSeqList(&seq);
	PushFront(&seq,1);
	PushFront(&seq,2);
	PushFront(&seq,3);
	PushFront(&seq,4);
	//PushFront(&seq,5);
	//PushFront(&seq,5);


	PrintSeqList(&seq);

	PopFront(&seq);
	PopFront(&seq);
	PopFront(&seq);
	PopFront(&seq);
	PopFront(&seq);
	//PopFront(&seq);

	PrintSeqList(&seq);
}
void Test5()//Insert
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);

	PrintSeqList(&seq);

	Insert(&seq,2,5);

	PrintSeqList(&seq);
}
void Test6()//Remove
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,2);
	PushBack(&seq,4);

	PrintSeqList(&seq);

	Remove(&seq,2);

	PrintSeqList(&seq);
}
void Test7()//RemoveAll
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,2);
	PushBack(&seq,4);

	PrintSeqList(&seq);

	RemoveAll(&seq,2);

	PrintSeqList(&seq);
}
void Test8()//Sort
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,5);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,2);

	PrintSeqList(&seq);
	Sort(&seq);
	PrintSeqList(&seq);
}
void Test9()//BinarySearch
{
	int ret = 0;
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,5);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,2);

	PrintSeqList(&seq);

	ret = BinarySearch(&seq,2);
    PrintSeqList(&seq);
	
	if (ret < 0)
	{
		printf("sorry, no find x\n");
	} 
	else
	{
		printf("%d\n",ret);
	}
}
void Test10()//Find
{
	int ret = 0;
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,5);

	PrintSeqList(&seq);

	ret = Find(&seq,4);
	if (ret < 0)
	{
		printf("no find x\n");
		return;
	} 
	else
	{
		printf("find x\n");
		printf("%d\n",ret);
	}
}
void Test11()//Erase
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);

	PrintSeqList(&seq);
	Erase(&seq,2);
	PrintSeqList(&seq);
}

int main()
{
	//Test1();
	//Test2();
	//Test3();
	//Test4();
	//Test5();
	//Test6();
	//Test7();
	//Test8();
	//Test9();
	//Test10();
	//Test11();
	system("pause");
	return 0;
}</span></strong>


 

poison_biti
关注
专栏目录
【数据结构】顺序表的实现——动态分配
m0_74195174的博客
04-01 1587
本文旨在深入探讨顺序表的动态分配实现，帮助读者理解并掌握这一技术的核心概念和应用方法。通过动态分配内存，我们可以根据实际需求动态地调整顺序表的大小，从而更加高效地管理数据
【数据结构】顺序表的实现——静态分配
最新发布
m0_74195174的博客
03-28 1111
本文将重点探讨顺序表的静态分配实现方式，通过对其概念、实现方式以及优缺点的分析，帮助读者深入理解并掌握顺序表的相关知识
顺序表的基本操作
09-18
本资源是：线性表中的顺序表的一些操作，包括初始化顺序表、建立顺序表、删除顺序表、在顺序表中插入元素，在顺序表中删除元素、判断空的等一些基本操作。
静态顺序表顺序表的基本操作
Atalanta1的博客
02-13 594
顺序表：是用一段地址连续的存储单元一次存储数据元素的线性结构，是线性表的一种 一般采用数组表示顺序表，数组有静态数组和动态数组之分，在此我们采用静态数组表示静态顺序表， 如图为线性表的结构： 下面实现顺序表的基本操作： 初始化； 销毁； 尾插、头插； 尾删、头删； 根据指定元素删除 指定位置插入和删除； 查找； 静态顺序表的结构定义： #define MAXSIZE ...
静态顺序表的基本操作
xy的博客
12-17 327
静态顺序表的基本操作包括： （1）初始化操作：void InitSeqlist(pSeqlist seq); （2）打印操作：void Printf(pSeqlist seq); （3）尾插操作：void PushBack(pSeqlist seq, DataType data); （4）尾删操作：void PushBack(pSeqlist seq, DataType data); （5）头插操作：void PushFront(pSeqlist seq, DataType data); （6）头删操作：v
静态顺序表基本操作
summer初夏的博客
04-21 309
测试环境VS2013 seqlist.h #pragma once #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;assert.h&gt; #include &lt;malloc.h&gt; typedef int DataType; typedef struct ListNode { struct...
数据结构C语言——静态顺序表的实现
m0_59086544的博客
06-17 534
本文章主要是介绍关于数据结构中用C语言来实现顺序表的一些基本操作。
顺序表——静态分配的实现
大块儿肉的博客
07-18 337
顺序表的静态分配实现
数据结构实战——线性表（顺序表、链表——单链表、双链表、循环链表、静态链表）
wypds的博客
04-09 1077
数据结构线性表实战 顺序表、单链表（头插法、尾插法、双链表、循环链表、静态链表） 一、什么是线性表 二、顺序表 三、链表 一、单链表 1、头插法 2、尾插法 二、双链表 三、循环链表 四、静态链表 前言 提示：这里可以添加本文要记录的大概内容： 数据结构——线性表 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是线性表 线性表是具有相同数据类型的n(>=0)个数据元素的有限序列，n为表长，n=0时线性表是一个空表。若用L命名线性表，一般表示为：L=(a[1]，a[2]，a[3]，.
顺序表的实现：静态和动态
Liaiblog
02-28 237
顺序表的实现 1.静态实现 #include<stdio.h> #define MaxSize 10 typedef struct { int data[MaxSize]; int lenght; }SqList; //顺序表的初始化 void InitList(SqList &L){ for (int i = 0; i < MaxSize; i++) { L.data[i]=0; } L.lenght=0; }
静态顺序表的实现（C）
erwuhuoche的博客
03-29 504
引言 要实现静态顺序表，我们首先需要知道什么是顺序表。 顺序表是指用一段地址连续的存储单元依次存取数据元素的线性结构。 顺序表采用的是连续的地址空间，这是与链表的本质区别。对于连续的地址空间，我们一般采用数组，而数组又分为静态数组和动态数组。我们本次要实现的就是采用静态数组的顺序表。 实现静态顺序表的操作 静态顺序表的结构体 typedef char SeqListType; ...
顺序表静态分配的基本操作
a1369760658的博客
02-15 602
#include <stdio.h> #include <stdlib.h> #define Maxsize 10 //声明一个顺序表 typedef struct{ //应该写Elemtype data[Maxsize]; int data[Maxsize]; int length; }SqList; //初始化顺序表 void InitList(SqList &...
顺序表的静态实现
weixin_46059682的博客
09-01 156
1.相关头文件 #pragma once #define _CRT_SECURE_NO_WARNINGS //*************************顺序表的实现---静态分配******************************* //*************************相关头文件的声明************************************* #include <stdio.h> //*************************相关
【数据结构】顺序表的静态实现
某薛的黑猫
09-26 268
头文件 #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;assert.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #include&amp;amp;amp
顺序表查找算法详解：实现与操作分析
顺序表查找算法是数据结构课程中的一个重要概念，它主要针对静态查找表和动态查找表进行操作，尤其是在线性表的实现中。顺序查找算法的核心思想是通过遍历表中的每个元素，逐个与目标值进行比较，直到找到匹配的元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值