顺序表（静态）

最新推荐文章于 2024-08-18 12:51:45 发布
最新推荐文章于 2024-08-18 12:51:45 发布
阅读量112 收藏
点赞数
分类专栏： 数据结构 文章标签： 顺序表 选择排序 冒泡排序 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yulong__li/article/details/82631908
版权

直接上代码：

text.c

#define _CRT_SECURE_NO_DEPRECATE 1

#include "SeqList.h"
#include "stdio.h"

SeqList seq;

//增
void TestPushSeqList()
{
	//尾插
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq);
	Insert(&seq, 2, 10);
	PrintSeqList(&seq);

	//头插
	InitSeqList(&seq);
	PushFront(&seq, 1);
	PushFront(&seq, 2);
	PushFront(&seq, 3);
	PushFront(&seq, 4);
	PrintSeqList(&seq);
	Insert(&seq, 2, 10);
	PrintSeqList(&seq);
}



//删
void TestPopSeqList()
{
	//尾插
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq);

	PopBack(&seq);//尾删
	PrintSeqList(&seq);
	PopFront(&seq);//头删
	PrintSeqList(&seq);

	//尾插
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PrintSeqList(&seq);
	Erase(&seq, 2);
	PrintSeqList(&seq);
}


//查
void TestFind()
{
	int ret = 0;

	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	
	ret = Find(&seq, 2);

	if (ret == -1)
		printf("数据不存在\n");

	else
		printf("%d\n", ret);
}


void TestRemove()
{
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);

	Remove(&seq, 3);
	PrintSeqList(&seq);
}


void TestRemoveAll()
{
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 1);
	PushBack(&seq, 4);

	RemoveAll(&seq, 1);
	PrintSeqList(&seq);
}


void TestEmpty()
{
	InitSeqList(&seq);
	PushFront(&seq, 1);
	PushFront(&seq, 2);
	PushFront(&seq, 3);
	PushFront(&seq, 4);
	PrintSeqList(&seq);

	Empty(&seq);
	PrintSeqList(&seq);
}


void TestSize()
{
	InitSeqList(&seq);
	PushFront(&seq, 1);
	PushFront(&seq, 2);
	PushFront(&seq, 3);
	PushFront(&seq, 4);

	printf("%d\n", Size(&seq));
}


void TestBubbleSort()
{
	InitSeqList(&seq);
	PushFront(&seq, 1);
	PushFront(&seq, 5);
	PushFront(&seq, 4);
	PushFront(&seq, 2);
	PushFront(&seq, 3);
	PrintSeqList(&seq);
	BubbleSort(&seq);
	PrintSeqList(&seq);
}


void TestBinarySearch()
{
	int ret = 0;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 5);
	PushBack(&seq, 6);

	ret=BinarySearch(&seq, 1);
	if (ret==-1)
	{
		printf("数据不存在\n");
	}
	else
	{
		printf("%d\n", ret);
	}
}


void TestBinarySearch_R()
{
	int ret = 0;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 5);
	PushBack(&seq, 6);
	int left = 0;
	int right =(&seq)->sz - 1;
	ret = BinarySearch_R(&seq,left,right, 1);
	if (ret == -1)
	{
		printf("数据不存在\n");
	}
	else
	{
		printf("%d\n", ret);
	}
}

void TestSelectSort()
{
	InitSeqList(&seq);
	PushFront(&seq, 3);
	PushFront(&seq, 1);
	PushFront(&seq, 4);
	PushFront(&seq, 2);
	PushFront(&seq, 5);
	PrintSeqList(&seq);
	SelectSort(&seq);
	PrintSeqList(&seq);
}


int main()
{

	TestPushSeqList();
	TestPopSeqList();
	TestFind();
	TestRemove();
	TestRemoveAll();
	TestEmpty();
	TestSize();
	TestBubbleSort();
	TestBinarySearch();
	TestBinarySearch_R();
	TestSelectSort();
	return 0;
}

SeqList.h

#pragma once 

#define MAX 10

typedef int DataType;

typedef struct SeqList
{
	DataType data[MAX];
	int sz;
}SeqList, *pSeqList;


//初始化顺序表
void InitSeqList(pSeqList ps);

//添加
//尾插、头插
void PushBack(pSeqList ps, DataType d);
void PushFront(pSeqList ps, DataType d);

//删除
//尾删、头删
void PopFront(pSeqList ps);
void PopBack(pSeqList ps);

//打印
void PrintSeqList(pSeqList ps);

//查找
int  Find(pSeqList ps, DataType d);

//指定位置插入
void Insert(pSeqList ps, int pos, DataType d);

//删除指定位置元素
void Erase(pSeqList ps, int pos);

//删除指定元素
void Remove(pSeqList ps, DataType d);

//删除所有的指定元素
void RemoveAll(pSeqList ps, DataType d);

//清空顺序表
void Empty(pSeqList ps);

//返回顺序表的大小
int Size(pSeqList ps);

//冒泡排序
void BubbleSort(pSeqList ps);

//二分查找
int BinarySearch(pSeqList ps, DataType d);

//二分查找的递归写法
int BinarySearch_R(pSeqList ps,int left,int right,DataType d);

//选择排序
void SelectSort(pSeqList ps);

SeqList.c

#define _CRT_SECURE_NO_DEPRECATE 1
#include "SeqList.h"
#include "stdio.h"
#include "assert.h"
#include "string.h"


//初始化
void InitSeqList(pSeqList ps)
{
	assert(ps);
	ps->sz = 0;

}


//打印
void PrintSeqList(pSeqList ps)
{
	assert(ps);

	for (int i = 0; i < ps->sz; i++)
	{
		printf("%d ", ps->data[i]);
	}

	printf("\n");
}


//增
//尾插
void PushBack(pSeqList ps, DataType d)
{
	assert(ps);

	//顺序表已满
	if (ps->sz == MAX)
	{
		printf("顺序表满了\n");
		return;
	}

	//顺序表没满
	ps->data[ps->sz] = d;
	ps->sz++;

}


//头插
void PushFront(pSeqList ps, DataType d)
{
	assert(ps);

	//顺序表已满
	if (ps->sz == MAX)
	{
		printf("顺序表满了\n");
		return;
	}

	//顺序表没满
	for (int i = ps->sz-1; i >= 0;i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	
	ps->data[0] = d;
	ps->sz++;
}


//指定位置插入
void Insert(pSeqList ps, int pos, DataType d)
{
	assert(ps);
	assert(ps->sz < MAX);
	assert(pos >= 0 && pos <= ps->sz);

	for (int i = ps->sz - 1; i >= pos;i--)
	{
		ps->data[i + 1] = ps->data[i];
	}

	ps->data[pos] = d;
	ps->sz++;
}

//删
//尾删
void PopBack(pSeqList ps)
{
	assert(ps);
	assert(ps->sz > 0);

	ps->sz--;
}


//头删
void PopFront(pSeqList ps)
{
	assert(ps);
	assert(ps->sz > 0);

	for (int i = 0; i < ps->sz-1;i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->sz--;
}


//删除指定位置元素
void Erase(pSeqList ps, int pos)
{
	assert(ps);
	assert(ps->sz > 0);
	assert(pos >= 0 && pos < ps->sz);

	for (int i = pos; i < ps->sz - 1;i++)
	{
		ps->data[i] = ps->data[i + 1];
	}

	ps->sz--;
}


//查
int  Find(pSeqList ps, DataType d)
{
	assert(ps);

	for (int i = 0; i < ps->sz;i++)
	{
		if (ps->data[i]==d)
		{
			return i;
		}
	}
	return -1;
}


//删除指定元素
void Remove(pSeqList ps, DataType d)
{
	assert(ps);

	int pos = Find(ps, d);
	if (pos == -1)
	{
		return;
	}
	Erase(ps, pos);
}


//删除所有的指定元素
void RemoveAll(pSeqList ps, DataType d)
{
	
	assert(ps);
#if 0

	//创建个数组，把不等于d的数据copy到extra
	DataType *extra = (DataType *)malloc(sizeof(DataType)*ps->sz);
	int i = 0; int j = 0;
	for (int i = 0; i < ps->sz;i++)
	{
		if (ps->data[i]!=d)
		{
			extra[j++] = ps->data[i];
		}
	}
	//把extra的数据copy回来
	for (int k = 0; k < j;k++)
	{
		ps->data[k] = extra[k];
	}
	ps->sz = j;
	free(extra);
#endif
	int i = 0; int j = 0;
	for (; i < ps->sz;i++)
	{
		if (ps->data[i]!=d)
		{
			ps->data[j++] = ps->data[i];
		}
	}
	ps->sz = j;
}


//清空顺序表
void Empty(pSeqList ps)
{
	assert(ps);
	ps->sz = 0;
}


//返回顺序表的大小
int Size(pSeqList ps)
{
	assert(ps);
	return ps->sz;
}


void Swap(DataType * x, DataType* y)
{
	DataType tmp = *x;
	*x = *y;
	*y = tmp;
}


//冒泡排序
void BubbleSort(pSeqList ps)
{
	int i, j;
	int  flag = 1;
	for (i = 0; i < ps->sz - 1; i++) 
	{
		flag = 1;	// 假设有序
		for (j = 0; j < ps->sz - 1 - i; j++) 
		{
			if (ps->data[j] > ps->data[j + 1]) 
			{
				Swap(ps->data+j, ps->data+j + 1);
				flag = 0;
			}
		}

		// 一次冒泡过程中，一次交换都没有，所以已经有序了
		if (1==flag) 
		{
			break;
		}
	}
}


//二分查找
int BinarySearch(pSeqList ps, DataType d)
{
	assert(ps);
	int left = 0;
	int right = ps->sz - 1;
	while (left <= right)
	{
		int mid = left + (right - left)/2;
		if (d<ps->data[mid])
		{
			right = mid - 1;
		}
		else if (d>ps->data[mid])
		{
			left = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}


//二分查找的递归写法
int BinarySearch_R(pSeqList ps, int left, int right, DataType d)
{
	int mid = left + (right - left) / 2;
	if (left>right)
	{
		return -1;
	}
	if (ps->data[mid]==d)
	{
		return mid;
	}
	else if (d<ps->data[mid])
	{
		return BinarySearch_R(ps, left, mid - 1, d);
	}
	else
	{
		return BinarySearch_R(ps, mid+1, right, d);
	}
}


//选择排序
void SelectSort(pSeqList ps)
{
	int minSpace = 0;
	int maxSpace = ps->sz - 1;
	while (minSpace<maxSpace)
	{
		int minPos = minSpace;
		int maxPos = minSpace;
		for (int i = minSpace; i <= maxSpace;i++)
		{
			if (ps->data[i]<ps->data[minPos])
			{
				minPos = i;
			}
			if (ps->data[i]>ps->data[maxPos])
			{
				maxPos = i;
			}
		}
		Swap(ps->data+minPos, ps->data+minSpace);
		if (maxPos==minSpace)
		{
			maxPos = minPos;
		}
		Swap(ps->data+maxPos, ps->data+maxSpace);
		minSpace++;
		maxSpace--;
	}
}

欢迎指正！！！！！！

顺序表（动态）

神化我
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现顺序表（静态实现）
近未来
09-22 2014
顺序表：用一段地址连续的存储地址单元一次存储数据元素的线性结构。 实现一个具有增、删、查、改、初始化、输入、打印等简单功能的顺序表。 实现代码如下： #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int DataType; #define MAX_SIZE (...
静态顺序表和动态顺序表区别
yy_1121的博客
03-12 1724
静态顺序表和动态顺序表区别
顺序表静态初始化
m0_53491319的博客
06-26 557
顺序表的初始化
顺序表静态分配
热门推荐
原来是肖哈哈的博客
01-29 1万+
//顺序表静态分配 #include<stdio.h> #include<stdlib.h> #include<time.h> /*使用随机函数时用到stdlib.h与time.h */ #define MaxSize 10 typedef struct{ int data[MaxSize]; //顺序表的元素 int length; //顺序表的当前长度 }SqList; //初始化顺序表全为0 void InitList(SqList &
数据结构-静态顺序表
m0_61433144的博客
07-04 1213
顺序表又分为静态顺序表和动态顺序表。对于静态顺序表，在静态分配时，由于数组的大小和空间事先已经固定好了，一旦空间占满，再加入新的数据就会产生溢出，进而导致程序崩溃。
顺序表静态结构结构
To be a better man
08-10 814
//顺序映像的C语言描述 #define LIST_SIZE 100 //存储 //线性表静态分配顺序存储结构 typedef struct{ ElemType elem[LIST_SIZE]; int length; //当前长度 }Sqlist; /* 在线性表的静态分配存储结构中,线性表中的最多元素个数为LIST_SIZE, 元素数量不能随意增加,这是以数组方式描述线性表的缺点 ...
【数据结构】第二章线性表：顺序表静态、动态分配下的插入、删除、查找
weixin_37706349的博客
06-23 3500
2.1 线性表的定义和基本操作 先从线性表的定义（逻辑结构）与基本操作（运算）上讲。 *数据结构三要素：逻辑结构、数据的运算、存储结构（物理结构） 存储结构不同，运算的实现方式不同。 线性表定义（逻辑结构）： 数据类型相同代表每个数据元素所占空间一样大； 有限数据元素有限个数； 序列代表数据元素之间是有次序的； 线性表基本操作（运算）： Tips： 对数据的操作（记忆思路）：创销、增删改查； C语言函数的定义：<返回值类型> 函数名 (&lt
顺序表的静态分配和动态分配
woniuxyy的博客
01-18 865
顺序表的静态分配和动态分配
数据结构之静态顺序表和动态顺序表
Sock的博客
12-02 1291
@Sock对静态顺序表和动态顺序表的总结 简单概括他们的异同点 相同点:内存空间连续, 数据顺序存储 不同点:它们所占内存空间的位置不同, 静态定义一个顺序表, 顺序表所占的内存空间开辟在内存的静态区, 即所谓的函数栈上, 随着函数调用的结束, 这块内存区域会被系统自动回收; 而动态生成一个顺序表, 顺序表所占的内存空间开辟在内存的动态区, 即所谓的堆内存上, 这块区域不会随着函数调用的结束被...
顺序表
Outtch_的博客
11-07 3614
顺序表是什么呢？ 顾名思义，顺序表是物理地址连续的存储单元依次存储数据的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表和数组有什么区别呢? 顺序表比数组更约束，顺序表物理地址上必须连续存储，数组是顺序表在实际编程中的具体实现方式。 顺序表分为静态顺序表和静态顺序表（主要区别在于他们的容量是否可变） 静态顺序表 静态顺序表的概念： 顺序表的容量在静态时期（编译期间）确定，大...
C语言实现静态顺序表的实例详解
01-01
C语言实现静态顺序表的实例详解 线性表 定义一张顺序表也就是在内存中开辟一段连续的存储空间，并给它一个名字进行标识。只有定义了一个顺序表，才能利用该顺序表存放数据元素，也才能对该顺序表进行各种操作。 接...
C++实现基于静态数组的顺序表
08-19
C++实现基于静态数组的顺序表 本文将详细介绍基于静态数组的顺序表的实现，包括基本操作的实现和示例代码。 一、顺序表的基本概念 顺序表是一种常见的数据结构，用于存储和管理数据。它由一个静态数组和一个size...
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的数组，而动态顺序表则可以根据需要动态地调整其容量。 静态顺序表的优点在于...
线性结构及其应用，顺序表，链表，静态链表
03-30
本主题主要探讨线性结构的三个重要概念：顺序表、链表以及静态链表，这些都是数据结构与算法中的核心知识。 首先，顺序表是一种最基础的线性结构，它的特点是元素在内存中是连续存储的，可以通过数组的形式来实现。...
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
sjsjs11的博客
08-14 395
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
笔记分享: 香港中文大学CSCI5610高级数据结构——最邻近查询
最新发布
qq_64091900的博客
08-18 496
香港中文大学CSCI5610高级数据结构
链表 19.删除链表的倒数第N个节点 双指针
qq_64633597的博客
08-14 206
return head 和return dummy.next 的区别，若删除的是头节点，则头节点还需要更新，题目中给的头节点就不能用了。而dummy作为虚拟头节点，永远是头节点的上一位，即使head发生变化，仍然是dummy.next。fast走n+1步，是为了和slow保持n+1个位置，此时fast移动至空节点，slow与fast位置差n+1节点，那slow再往后移动一位，就是需要删除的倒数第n个节点，即目标节点。倒数第几个，翻过来看即正数第几个。
数据结构之排序（下）
qq_74336191的博客
08-15 641
​ 嗨！小伙伴们，咱们又见面啦，在上一篇数据结构之排序（上）中，我们学习了直接插入排序、冒泡排序和希尔排序，今天我们继续学习排序这一块，准备好了吗？Ready Go ! ! ! ​
数据结构——二叉树
2301_80373479的博客
08-16 1414
轻松学会二叉树
C语言静态存储顺序表
03-18
C语言中的静态存储顺序表是一种使用静态数组实现的线性表结构。它的特点是在编译时就确定了数组的大小，不支持动态扩容。静态存储顺序表的元素在内存中是连续存储的，可以通过下标直接访问元素。 静态存储顺序表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值