用c语言实现顺序表

最新推荐文章于 2022-10-08 23:06:36 发布
原创 最新推荐文章于 2022-10-08 23:06:36 发布 · 1.1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #顺序表 #冒泡排序 #二分查找

该博客详细介绍了如何使用C语言实现顺序表结构，包括初始化、打印、尾插、尾删、头插、头删、插入、查找、删除、替换、移除指定值、冒泡排序、选择排序（优化版）以及二分查找等功能。同时提供了测试用例以展示这些操作的使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

用c语言实现顺序表

Seqlist.h

#pragma once
typedef int DataType;
#define N 100
typedef struct Seqlist
{
	DataType array[N];
	size_t size;
}Seqlist;

void InitSeqlist(Seqlist* s); //初始化
void PrintSeqlist(Seqlist* s); //打印
void PushBack(Seqlist* s, DataType x); //尾插
void PopBack(Seqlist* s); //尾删
void PushFront(Seqlist* s, DataType x); //头插
void PopFront(Seqlist* s); //头删
void Insert(Seqlist* s, size_t pos, DataType x); //将x插入任意位置
int Find(Seqlist* s, DataType x); //查找元素
void Erase(Seqlist* s, size_t pos); //删除任意位置元素
void Modify(Seqlist* s, size_t pos, DataType x); //替换，将pos位置值修改为x
int Remove(Seqlist* s, DataType x); //移除某值的第一项
int RemoveAll(Seqlist* s, DataType x); //移除某值得全部项
void Swap(DataType* left, DataType* right); //交换两元素
void BubbleSort(Seqlist* s); //冒泡排序
void SelectSort(Seqlist* s); //选择排序
void SelectSort_OP(Seqlist* s); //选择排序的优化
int BinarySearch(Seqlist* s, DataType x); //二分查找

void InitSeqlist(Seqlist* s) //初始化
{
	memset(s->array, 0, sizeof(DataType)*N);
	s->size = 0;
}

void PrintSeqlist(Seqlist* s) //打印
{
	for (size_t i = 0; i < s->size; i++)
	{
		printf("%d ", s->array[i]);
	}
	printf("\n");
}

void PushBack(Seqlist* s, DataType x) //尾插
{
	assert(s);
	if (s->size == N)
	{
		printf("Seqlist is full \n");
		return;
	}
	s->array[s->size++] = x;
}

void PopBack(Seqlist* s) //尾删
{
	assert(s);
	if (s->size == 0)
	{
		printf("Seqlist is empty \n");
		return;
	}
	s->array[s->size - 1] = 0;
	s->size--;
}

void PushFront(Seqlist* s, DataType x) //头插
{
	assert(s);
	int end = s->size - 1;
	if(s->size == N)
	{
		printf("Seqlist is full \n");
			return;
	}
	for (; end >= 0; --end)
	{
		s->array[end + 1] = s->array[end];
	}
	s->array[0] = x;
	s->size++;
}

void PopFront(Seqlist* s) //头删
{
	assert(s);
	if (s->size == 0)
	{
		printf("Seqlist is empty \n");
		return;
	}
	for (size_t i = 1; i < s->size; ++i)
	{
		s->array[i-1] = s->array[i];
	}
	s->size--;
}

void Insert(Seqlist* s, size_t pos, DataType x) //将x插入任意位置
{
	assert(s);
	assert(pos <= s->size);
	if (s->size == N)
	{
		printf("Seqlist is full \n");
		return ;
	}
	size_t end = s->size - 1;
	for (; end >= pos; --end)
	{
		s->array[end + 1] = s->array[end];
	}
	s->array[pos] = x;
	s->size++;
}

int Find(Seqlist* s, DataType x) //查找元素
{
	size_t i = 0;
	assert(s);
	for (; i <= s->size; ++i)
	{
		if (s->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void Erase(Seqlist* s, size_t pos) //删除任意位置元素
{
	assert(s);
	assert(pos < s->size);
	size_t i = 0;
	for (i = pos; i < s->size -1; ++i)
	{
		s->array[i] = s->array[i + 1];
	}
	s->size--;
}

void Modify(Seqlist* s, size_t pos, DataType x) //替换，将pos位置值修改为x
{
	assert(s);
	assert(pos < s->size);
	s->array[pos] = x;
}

int Remove(Seqlist* s, DataType x) //移除某值的第一项
{
	assert(&s);
	size_t pos;
	pos = Find(s, x);
	if (pos != -1)
	{
		Erase(s, pos);
		return 0;
	}
	else
	{
		return -1;
	}
}

int RemoveAll(Seqlist* s, DataType x) //移除某值得全部项
{
	size_t i=0, j = 0;
	assert(s);
	while (i < s->size)
	{
		if (s->array[i] != x)
		{
			s->array[j] = s->array[i];
			++j;
		}
		++i;
	}
	s->size = j;
	return i == j ? -1 : 0;
}

void Swap(DataType* left, DataType* right) //交换两元素
{
	DataType tmp = *left;
	*left = *right;
	*right = tmp;
}

void BubbleSort(Seqlist* s) //冒泡排序  处理有相同元素的数组时出错
{
	assert(s);
	size_t start = 0;
	size_t end;
	int exchange = 0;
	for (end = s->size; end > 0; --end)
	{
		while (start + 1 < s->size)
		{
			if (s->array[start] > s->array[start + 1])
			{
				Swap(s->array + start, s->array + start + 1);
				exchange = 1;
			}
			++start;
		}
	}
}

void SelectSort(Seqlist* s) //选择排序
{
	size_t start = 0;
	assert(s);
	for (; start < s->size; ++start)
	{
		size_t i = start;
		size_t min = start;
		for (; i < s->size; ++i)
		{
			if (s->array[min]>s->array[i])
			{
				min = i;
			}
		}
		Swap(s->array + start, s->array + min);
	}
}

void SelectSort_OP(Seqlist* s) //选择排序的优化
{
	size_t start = 0, finish = s->size - 1;
	assert(s);
	while (start < finish)
	{
		size_t i = start;
		size_t min = start, max = start;
		while (i <= finish)
		{
			if (s->array[i] < s->array[min])
			{
				min = i;
			}
			if (s->array[i]>s->array[max])
			{
				max = i;
			}
			++i;
		}
		Swap(s->array + start, s->array + min);
		if (start == max)
		{
			max = min;
		}
		Swap(s->array + finish, s->array + max);
		start++;
		finish--;
	}
}

int BinarySearch(Seqlist* s, DataType x) //二分查找
{
	int left = 0, right = s->size - 1;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (s->array[mid] < x)
		{
			left = mid + 1;
		}
		else if (s->array[mid]>x)
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

TestSeqlist1()
{
	Seqlist s;
	InitSeqlist(&s);
	PushBack(&s, 0);
	PushBack(&s, 2);
	PushBack(&s, 4);
	PushBack(&s, 6);
	PushFront(&s, 10);
	PushFront(&s, 11);
	PushFront(&s, 12);
	PushFront(&s, 13);
	PrintSeqlist(&s);
	//PopBack(&s);
	PopFront(&s);
	PopFront(&s);
	PrintSeqlist(&s);
	Insert(&s, 3, 1);
	PrintSeqlist(&s);
}

TestSeqlist2()
{
	Seqlist s;
	InitSeqlist(&s);
	PushBack(&s, 0);
	PushBack(&s, 2);
	PushBack(&s, 4);
	PushBack(&s, 6);
	PushFront(&s, 10);
	PushFront(&s, 11);
	PushFront(&s, 12);
	PushFront(&s, 13);
	PrintSeqlist(&s);
	printf("%d\n", Find(&s, 0));
	Erase(&s, Find(&s, 0));
	PrintSeqlist(&s);
	Modify(&s, 3, 0);
	PrintSeqlist(&s);
}

TestSeqlist3()
{
	Seqlist s;
	InitSeqlist(&s);
	PushBack(&s, 1);
	PushBack(&s, 2);
	PushBack(&s, 4);
	PushBack(&s, 6);
	PushFront(&s, 0);
	PushFront(&s, 1);
	PushFront(&s, 2);
	PushFront(&s, 3);
	PrintSeqlist(&s);
	//Remove(&s, 2);
	//PrintSeqlist(&s);
	RemoveAll(&s, 2);
	RemoveAll(&s, 1);
    PrintSeqlist(&s);
	BubbleSort(&s);
	PrintSeqlist(&s);
}

TestSeqlist4()
{
	Seqlist s;
	InitSeqlist(&s);
	PushBack(&s, 0);
	PushBack(&s, 2);
	PushBack(&s, 4);
	PushBack(&s, 6);
	PushFront(&s, 10);
	PushFront(&s, 11);
	PushFront(&s, 12);
	PushFront(&s, 13);
	PrintSeqlist(&s);
	/*SelectSort(&s);
	PrintSeqlist(&s);*/
	SelectSort_OP(&s);
	PrintSeqlist(&s);
	printf("6的下标是：%d\n",BinarySearch(&s, 6));
}



test.c

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

int main()
{
	TestSeqlist4();
	system("pause");
	return 0;
}

顺序表的实现（C语言）
03-11
C语言实现顺序表的操作，简单参考一下，相互交流学习。使用 C语言的顺序表的实现比较简单，是以前学习数据结构时专门记录的，有点帮助。
顺序表（C语言实现）
trqii_的博客
04-26 6148
顺序表 文章目录顺序表一、**顺序表的基本概念**二、动态顺序表的具体实现1. 顺序表初始化2. 顺序表尾插3. 顺序表头插4. 顺序表尾删5. 顺序表头删6. 顺序表任意位置插入7. 顺序表任意位置删除8. 顺序表查找9. 顺序表修改10. 顺序表打印11. 顺序表销毁三、完整代码 一、顺序表的基本概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表分为以下二类： 1.静态顺序表：使用定长数组存储元素。 #define N
c语言顺序表的建立
duan19840118的博客
05-01 1236
[code="java"]#include #include #define LIST_INIT_SIZE 10 /*存储空间初始分配量*/ #define LISTINCREMENT 10 /*存储空间分配增量*/ typedef struct { int *elem; /*首地址*/ int length; /*当前长度*/ int listsize...
C语言实现顺序表
热门推荐
qq_42204238的博客
03-31 4万+
c语言实现顺序表 线性表是最简单的数据结构，而顺序表又是最简单的线性表，其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素，比如我们常用的一位数组，下面代码实现了顺序表的定义以及基本操作。 编译环境：vs2017。 运行试例： 贴代码如下： #include "stdio.h" #include "windows.h" #include "stdlib.h" #define MAXSI...
c语言实现顺序表的基本操作
01-20
数据结构顺序表操作 代码如下:#include <stdio>#include <stdlib>#include <malloc>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ ElemType *elem...
C语言实现顺序表的合并
12-23
C语言数据结构实现顺序表的动态申请内存并且合并，代码可以直接使用。
C语言实现顺序表的顺序查找和折半查找
08-25
C语言实现顺序表的顺序查找和折半查找 在计算机科学中，查找是指在一组数据中找到特定元素的过程。顺序表是一种基本的数据结构，在实际应用中非常常见。因此，学习如何在顺序表中实现查找是非常重要的。下面，我们...
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
(C语言数据结构) 顺序表
09-16
C语言实现 顺序表 Init(初始化) Length(当前结点个数) Add(添加) Insert(插入) Delete(删除) FindByKey(查找返回序号) FindByNum(查找返回元素) ShowAll(显示所有元素)
顺序表的建立（C语言）
17的博客
10-08 4255
线性表的顺序储存是指在内存中用一组地址连续的内存单元一次存储线性表的各元素，用这种存储形式存储的线性表成为顺序表。
【C语言】顺序表的创建
lixxkv的博客
09-11 1万+
顺序表的代码实现
使用C语言创建顺序表
qq_44871378的博客
09-24 8131
C语言顺序表 C语言顺序表 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define MAXSIZE 5 typedef char ElemType ; //声明顺序表的结构体类型 typedef struct{ ElemType *elem; int length; ...
顺序表(C语言实现)
weixin_45235645的博客
02-10 276
顺序表(C语言实现) #define MaxSize 10 #include <stdbool.h> #include <stdlib.h> //线性表的顺序存储结构---静态分配存储最大空间为10 typedef struct{ int data[MaxSize]; int length; }SqList; //初始化顺序表 --先将数组的值全部赋为0（也可以先不用给数组赋值，写个 L->length=0也行） void InitList(SqList *L){ in
C语言 创建一个顺序表
ZL_BKPD的博客
08-19 1万+
#include<stdio.h> #include<stdlib.h> #define Size 5 //对Size进行宏定义，表示顺序表申请空间的大小 /* 申请足够大小的物理空间之外，为了方便后期使用表中的数据，顺序表还需要实时记录以下 2 项数据： 顺序表申请的存储容量； 顺序表的长度，也就是表中存储数据元素的个数； */ typedef struct Table{ int *head; //声明了一个名为head的动态数组（不确定大.
用C语言实现顺序表与链表的表连接操作
在本节中，我们将深入探讨如何使用C语言编程实现顺序表和链表这两种结构，并重点讲解如何利用这两种结构来连接（合并）两个表。 ### 顺序表 顺序表是一种数组结构的线性表，其元素在内存中是连续存放的，每个元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值