顺序表C语言

最新推荐文章于 2024-05-14 23:13:17 发布
最新推荐文章于 2024-05-14 23:13:17 发布
阅读量25 收藏
点赞数
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45611085/article/details/132713157
版权

线性表

线性表是n个具有相同特性的数据元素的有限序列，是一种实际中广泛使用的数据结构，常见的线性表有顺序表、链表、栈、队列、字符串
线性表在逻辑上是线性结构，即连续的一条直线，但在物理上不一定连续，线性表在物理上存储时，通常以数组和链式结构的形式存储
在这里插入图片描述
在这里插入图片描述

顺序表及其特点

数组缺陷：定义数组时必须指定数组大小，但是如果指定的大小不能满足使用空间需求时，就会有问题
顺序表含义及特点：顺序表本质是数组，是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改，顺序表要从左往右连续存储数据。顺序表的逻辑结构和物理结构都是连续的
2.顺序表分类：顺序表有两种，包括静态顺序表和动态顺序表
1、静态顺序表：使用定长数组存储元素。

//顺序表的静态存储
#define N 7
typedef int SLDataType
typedef struct SeqList
{
	SLDataType array[N];//定长数组
	size_t size;//有效数据的个数
}SeqList;

在这里插入图片描述
（2）动态顺序表：使用动态开辟的数组存储。

typedef struct SeqList
{
	SLDataType* array;//指向动态开辟的数组
	size_t size;//有效数据的个数
	size_t capacity;//容量
}SeqList;

在这里插入图片描述
3. 顺序表缺陷：
（1）动态增容有性能消耗。
（2）当头部插入数据时，需要挪动数据

顺序表的实现

静态顺序表容量是固定的，因此静态顺序表不实用。那么如何实现动态顺序表呢？

dynamicSequenceTable.h

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;
	int size;
	int capacity;
}SeqList,SEQ;
//初始化顺序表
void SeqListInit(SeqList* seq);
//销毁
void SeqListDestroy(SeqList* seq);
//打印
void print(SqList* seq);
//扩容
void SeqCheckCapacity(SeqList* seq);
//尾插
void SeqListPushBack(SeqList* seq,SLDataType x);
//头插
void SeqListPushFront(SeqList* seq,SLDataType x);
//尾删
void SeqListPopBack(SeqList* seq);
//头删
void SeqListPopFront(SeqList* seq);
//查找
int SeqListFind(SeqList* seq);
//某一位插入数据
void SeqListInsert(SeqList* seq,int pos,SLDataType x)
//某一位置删除数据
void SeqListErase(SeqList* seq,int num);
//某一位置删除数据
void SeqListModify(SeqList* seq,int pos,SeqDataType x);

dynamicSequenceTable.c

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include "dynamicSequenceTable.h"
//初始化顺序表
void SeqListInit(SeqList* seq)
{
	seq->a=NULL;
	seq->size=0;
	seq->capacity=0;
}
//销毁
void SeqListDestroy(SeqList* seq)
{
	free(seq->a);
	seq->a=NULL
	seq->size=0;
	seq->capacity=0;
}
//打印
void print(SqList* seq)
{
	int i=0;
	for(i=0;i<seq->size;i++)
	{
		printf("%d ",seq->a[i]);
	}
	printf("\n");
}
//扩容
void SeqCheckCapacity(SeqList* seq)
{
	if(seq->size==seq->capacity)
	{
		int newCapacity=seq->capacity==0?4:seq->capacity*2;
		SLDataType* new = (SLDataType*)realloc(seq->a,sizeof(SLDataType)*newCapacity);
		if(new==NULL)
		{
			printf("realloc error:");
			return;
		}
		seq->a=new;
		seq->capacity=newcapacity;
	}
}
//尾插
void SeqListPushBack(SeqList* seq,SLDataType x)
{
	SeqCheckCapacity(seq);
	seq->a[size]=x;
	seq->size++;
}
//头插
void SeqListPushFront(SeqList* seq,SLDataType x)
{
	SeqCheckCapacity(seq);
	int end=seq->size-1;
	while(end>=0)
	{
		seq->a[end+1]=seq->a[end];
		end--;
	}
	seq->a[0]=x;
	seq->size++;
}
//尾删
void SeqListPopBack(SeqList* seq)
{
	seq->size--;
}
//头删
void SeqListPopFront(SeqList* seq)
{
	int begin=0;
	while(begin<size)
	{
		seq->a[begin]=seq->q[begin+1];
		begin++;
	}
	seq->size--;
}
//查找
int SeqListFind(SeqList* seq,SLDataType x)
{
	SeqCheckCapacity(seq);
	int i=0;
	for(i=0;i<seq->size;i++)
	{
		if(seq->a[i]==x)
		{
			return i;
		}
	}
	return -1;
}
//某一位插入数据
void SeqListInsert(SeqList* seq,int pos,SLDataType x)
{
	SeqCheckCapacity(seq);
	int i=seq->size-1;
	while(i>=pos)
	{
		seq->a[i+1]=seq->a[i];
		i--;
	}
	seq->a[pos]=x;
	seq->size++;
}
//某一位置删除数据
void SeqListErase(SeqList* seq,int num)
{
	int i=pos;
	for(i;i<seq->size;i++)
	{
		seq->a[i]=seq->a[i+1];
	}
	seq->size--;
}
//修改某一位置数据
void SeqListModify(SeqList* seq,int pos,SeqDataType x)
{
	pq->a[pos] = x;
}

顺序表的应用

https://leetcode-cn.com/problems/add-to-array-form-of-integer/
数组形式的整数相加
对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。示例：
输入：A = [9,9,9,9,9,9,9,9,9,9], K = 1
输出：[1,0,0,0,0,0,0,0,0,0,0]
解释：9999999999 + 1 = 10000000000
分析:
1、不确定数组和数字相加的结果会不会产生进位，因此要用malloc为新数组分配空间，大小为数组和数字较大位数值+1
2、进位如何解决？将数组和数字对应位及进位相加的和如果比10大，那么该位结果就要-10，进位置1
3、对于（2）中的结果如何存放？如果将结果在新数组中从最右侧往最左侧存放，那么有可能相加的最终结果最高位没有产生进位，这就会导致新数组最高位为0，还需要将其他位顺次向前挪，如下图左图所示。因此应从最左侧往最右侧存放，记录新数组实际使用的长度，计算完毕再将数组逆序
在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
int* addToArrayForm(int* A, int ASize, int k, int* returnSize) 
{
	int kSize = 0;
	int num = k;
	
	//计算数字k的位数
	while (num)
	{
		num /= 10;
		kSize++;
	}
 
	//新数组大小为：max{数组长度，数字位数}+1，+1的原因是并不知道相加的最高位会不会有进位
	int len = ASize > kSize ? ASize + 1 : kSize + 1;
	
	//为新数组malloc动态开辟空间
	int* retArr = (int*)malloc(sizeof(int) * len);
	
	if (retArr == NULL)
	{
		return NULL;
	}
	
	int Ai = ASize - 1;//数组下标
	int Ki = 0;//数字从低到高第i位
	int next = 0;//进位
	int reti = 0;//新数组最终长度
	
	//只要数组和数字有一个没走完就进while循环
	while (Ai >= 0 || Ki < kSize)
	{
		int aval = 0;
		
		if (Ai >= 0)
		{
			aval = A[Ai--];//取数组最右端一位
		}
 
 
		int kval = k % 10;//取数字最低位
		k /= 10;
		Ki++;
 
		//相加和
		int ret = aval + kval + next; 
 
		//判断相加和是否产生进位
		if (ret >= 10)
		{
			next = 1;
			ret -= 10;
		}
		else
		{
			next = 0;
		}
 
		//注意此时将结果在新数组中按照从左到右的顺序存储，因此执行结束后，新数组需要逆置
		retArr[reti++] = ret;
	}
 
	//最高位相加的结果如果进位是1，那么还需将1存储在新数组最高位
	if (next == 1)
	{
		retArr[reti++] = 1;
	}
	
	//逆置新数组
	int begin = 0, end = reti - 1;
	while (begin < end)
	{
		int temp = retArr[begin];
		retArr[begin] = retArr[end];
		retArr[end] = temp;
		begin++;
		end--;
	}
 
	*returnSize = reti;
	return retArr;
	
}
int main()
{
	int array[] = { 9,9,9,9,9 };
	int len = sizeof(array) / sizeof(array[0]);
	int* p = array;
	int number = 999;
	int newlen = 0;
	
	int *p1 = addToArrayForm(array, len, number, &newlen);
	
	int i = 0;
	for (i = 0; i < newlen; i++)
	{
		printf("%d ", *(p1 + i));
	}
	return 0;
}

2.力扣网- 合并两个有序数组
给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

分析：1）nums1长度为m+n，无需开辟新数组。

（2）从数组左侧开始比较还是从数组右侧开始比较？如果从左侧开始比较，如果nums2的数据值<nums1的数据值，那么nums2的数据值放在nums1的对应位上，nums1的数据就会被覆盖，找不回来了，如下图所示。因此要从数组右侧向左开始比较。
在这里插入图片描述
（3）什么时候比较结束？nums1和nums2有一个走完就不用比较了，因此进入循环的判断条件是nums1和nums2的下标同时要>=0，当有一个不满足条件时，表明有一个数组走完了。此时如果是nums1走完了，那么就要把nums1剩下的数据直接拷贝到nums1前面剩下的几个位置中；如果是nums2走完了，那么就不用动，因为这就说明nums1剩下的没走的那几个数据比nums2的数据都小
在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) 
{
	int end1 = m - 1;
	int end2 = n - 1;
	int end = m + n - 1;
 
	//从右侧开始比较nums1和nums2的数据值，将较大者放在nums1数组的最右侧
	while (end1 >= 0 && end2 >= 0)
	{
		if (nums1[end1] > nums2[end2])
		{
			nums1[end--] = nums1[end1--];
		}
		else
		{
			nums1[end--] = nums2[end2--];
		}
		 
	}
 
	//有一个数组走完，如果是nums2没走完，需要将nums2剩余数据拷贝到nums1前面位置中
	//如果是nums1没走完，不用动，因为nums1剩下的数据是最小的，本身就在nums1中
	while (end2 >= 0)
	{
		nums1[end--] = nums2[end2--];
	}
}
 
int main()
{
	int arr1[] = { 2,3,6,0,0,0,0};
	int len1 = sizeof(arr1) / sizeof(arr1[0]);
 
	int arr2[] = {1,2,5,7};
	int len2 = sizeof(arr2) / sizeof(arr2[0]);
	
	merge(arr1, len1, 3, arr2, len2, len2);
	
	int i = 0;
	for (i = 0; i < len1; i++)
	{
		printf("%d ", arr1[i]);
	}
}

3力扣网-轮转数组
给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。要求空间复杂度O(1)
示例：
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
分析：有2种解法可以让空间复杂度为O(1)：

（1）先实现旋转一次，再对旋转一次的方法执行旋转k次
在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
void rotate(int* nums, int numsSize,int k)
{
 
	int i = 0;
	int end = numsSize;
 
	//旋转次数>数组长度，旋转次数需要对数组长度取模
	k %= numsSize;
	for (i = 0; i < k; i++)
	{
		//将最后一个元素保存下来
		int temp = nums[numsSize - 1];
		int j = 0;
 
		//一次向右旋转，将其余元素依次向后挪动
		for (j = numsSize - 2; j >= 0; j--)
		{
			nums[j + 1] = nums[j];
		}
 
		//把最后一个元素放在数组首元素的位置
		nums[0] = temp;
	}
 
}
 
int main()
{
	int arr[] = { 1,2,3,4,5,6,7 };
	int len = sizeof(arr) / sizeof(arr[0]);
	
	int k = 6;
	
	rotate(arr, len, k);
 
	int i = 0;
	for (i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	
	return 0;
}

（2）三步翻转法：将前k个元素进行翻转，再将后面len-k个元素进行翻转，最后整体翻转。
在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
 
//实现从起始位置到结束位置的翻转
void reverse(int* nums, int begin, int end)
{
	//起始位置与结束位置逐一对调
	while (begin < end)
	{
		int temp = nums[begin];
		nums[begin] = nums[end];
		nums[end] = temp;
		begin++;
		end--;
	}
}
 
void rotate(int* nums, int numsSize, int k) 
{
	reverse(nums, 0, k - 1);//翻转前k个元素
	reverse(nums, k, numsSize - 1);//翻转后len-k个元素
	reverse(nums, 0, numsSize - 1);//整体翻转
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7 };
	int len = sizeof(arr) / sizeof(arr[0]);
 
	int k = 3;
 
	rotate(arr, len, k);
	int i = 0;
	for (i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
 
	return 0;
}
我想学iT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
用c语言编写顺序表
m15082717021的博客
08-13 2215
用c语言实现顺序表的实现
顺序表合并c语言
m0_66098335的博客
12-01 1337
自学数据结构，顺序表的合并
顺序表C语言版
iwkxi的博客
03-18 3379
文章目录1.线性表2.顺序表2.1概念及结构2.2接口实现2.2.1 SeqList.h2.2.2 SeqList.c2.2.2.1 初始化顺序表 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一
顺序表C语言实现详解
hurryddd
04-03 2988
1、线性表 线性表。全名为线性存储结构，可以理解为即“把所有数据用一根线儿串起来，再存储到物理空间中”。线性表并不是一种具体的存储结构，它包含 顺序存储结构 和 链式存储结构，是顺序表和链表的统称。除了数组，链表、队列、栈等也是线性表结构。 顺序存储结构：将数据依次存储在连续的整块物理空间中 链式存储结构：数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系 非线性表。在非线性表中，数据之间并不是简单的前后关系。比如树、图 2、顺序表 它用一组连续的内存空间，来存储一组具有
顺序链表C语言实现
zcg_741454897的博客
11-04 3310
顺序链表没什么说的啦，直接上代码，参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了，不过没关系，都一样。 Operation中有一处语法上的疑惑，就是插入的那个函数中，node为什么要强制转换成整型，既然等式两边都是指针，为什么不是转化成int* ，有心人帮忙解答一下，谢谢。 SeqList.h头文件 #ifndef _SEQLIST_H_ #define _SEQLIST_...
C语言实现顺序表
辰多代码的博客
07-26 1831
1.2 SeqList.c 1.3 test.c 二、顺序表的实现 2.1 顺序表 创建一个顺序表结构体，成员包含顺序表地址、长度、大小，用于创建顺序表变量。 将顺序表变量的地址传参，通过指针接收对顺序表的顺序表数组初始化为空，长度为0，大小为0。 同样传地址，要先断言指针是否为空，不然会出异常。然后判断顺序表大小是否为0，为0则代表顺序表中没有有效元素，打印提示，并返回函数，如果大于0，则有元素，从下标0开始，打印size个顺序表元素，并用空格相隔。 当我们结束程序
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 2793
轻松带你搞定顺序表！
顺序表C语言实现
sun_Hmtl的博客
10-04 1491
  复习数据结构，写了一段顺序表的代码 定义一个头文件header.h 来描述表结构 #define MaxSize 100 //header 头文件 typedef struct { int data[MaxSize]; //最多存放数据MaxSize int length; //元素个数 }SeqList; #include "stdio.h" #inclu...
顺序表（C语言版）
m0_64520498的博客
10-13 1590
静态顺序表：以定长数组储存元素 ；动态顺序表：使用动态开辟的数组储存
约瑟夫环 顺序表 c语言,用顺序表解决约瑟夫环问题，用C++实现该算法
weixin_39921023的博客
05-21 952
满意答案pooakmmwk2013.08.17采纳率：46%等级：8已帮助：712人# include # define SIZE 20int joseph(int a[],int m,int n){int b[SIZE];int i;int flag=0;int code;int sum=n;int point=0;int num=m;for...
数据结构顺序表 C语言代码实现以及realloc的使用
07-09
数据结构顺序表 C语言代码实现以及realloc的使用
C语言实现顺序表的合并
12-23
C语言数据结构实现顺序表的动态申请内存并且合并，代码可以直接使用。
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
C语言顺序表的实现代码
08-29
主要为大家详细介绍了C语言实现顺序表的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
比大小（打擂台）（C语言）
m0_67184754的博客
05-14 212
【代码】比大小（打擂台）（C语言）
c语言：递归与迭代
qq_58761784的博客
05-14 1088
它却没有得出结果，这是为什么呢，因为，函数在内部多次调用了自己，产生了大量的重复计算，导致计算量巨大，代码执行效率非常低，让计算机也无法快速得出结果，这个例子告诉我们，递归是有使用条件的 ，如果要设计一个需要重复计算的程序，不能无脑使用递归，而是首先要思考递归能不能用，是否能让代码简洁的同时，更加高效，那么此类例子我们如何解决呢？可以看到，很快就得到了结果，但是答案是错误的，因为要求的数太大，一个字节无法表示，但是我们可以很直观的看见两者的差别，在这这样一个例子中，使用迭代会优于使用递归。
手撕C语言题典——链表的中间节点
Antigonos的博客
05-14 400
链表的中间节点同样也是力扣上一道简单题，适合刚学过单链表的我们更好的理解链表相关知识~
从需求角度介绍PasteSpider(K8S平替部署工具适合于任何开发语言)
最新发布
05-14 1102
Kubernetes的强大毋庸置疑，但是你有问自己这么个大杀器真的适合你么？这里推荐一款更加小巧的容器部署工具，集报表，发布，环境，通知于一身的PasteSpider! 支持git/svn发布，支持平滑升级，支持环境隔离，支持用户隔离，支持运行变量设定等，关键易上手！
数据结构顺序表c语言
05-24
顺序表是一种线性表，它的物理存储结构是连续的。在 C 语言中，可以用数组来实现顺序表。以下是一个简单的顺序表的 C 语言实现： ```c #include #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值