【数据结构】顺序表

最新推荐文章于 2024-11-05 00:21:35 发布
最新推荐文章于 2024-11-05 00:21:35 发布
阅读量535 收藏 27
点赞数 22
文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72651735/article/details/136219189
版权

一、线性表

        线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。

二、顺序表

        顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改，顺序表的本质就是一个数组。

优点：物理空间连续，下标随机访问。        缺点：删除数据比较麻烦

1.静态顺序表

        使用定长数组存储

#define N 10
typedef int SLDatatype;
//静态数据库缺点
//给小了不够用，给大了浪费

struct SeqList
{
    SLDatatype a[N];
   	int size;
};

2.动态顺序表

        使用动态开辟的数组存储。

typedef int SLDatatype;
typedef struct SeqList
{
	SLDatatype* a;
	int size;	   // 有效数据个数
	int capacity;  // 容量
}SL;

三、实现动态顺序表

1.接口函数

void SLInit(SL* psl);//初始化
void SLCheckCapacity(SL* psl);//检查容量
void SLDestroy(SL* psl);//释放
void SLPrint(SL* psl);//打印
void SLPushBack(SL* psl, SLDatatype X);//尾部插入
void SLPushFront(SL* psl, SLDatatype X);//头部插入
void SLPopBack(SL* psl);//尾部删除
void SLPopFront(SL* psl);//头部删除
void SLInsert(SL* psl, int pos,SLDatatype X);//中间插入
void SLErase(SL* psl, int pos);//中间删除
int SLFind(SL* psl, SLDatatype x);//查找数据
void SLModify(SL* psl, int pos, SLDatatype x);//改数据

1.顺序表初始化

初始化是注意是传值传参，还是传址传参，一定是传址传参。

void SLInit(SL* psl)
{
	assert(psl);
	psl->a = (SLDatatype*)malloc(sizeof(SLDatatype) * 4);
	if (psl->a == NULL)
	{
		perror("SLInit");
		return;
	}
	psl->capacity = 4;
	psl->size = 0;
}

2.检查容量

当有效数据和容量相等时，扩大容量。

void SLCheckCapacity(SL* psl)
{
	assert(psl);
	if (psl->size == psl->capacity)
	{
		SLDatatype* pf = (SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * (psl->capacity + 3));
		if (pf == NULL)
		{
			perror("SLCheckCapacity");
			return;
		}
		psl->a = pf;
		psl->capacity += 3;
	}
}

3.打印

void SLPrint(SL* psl)
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

4.尾部插入

void SLPushBack(SL* psl, SLDatatype X)
{
	assert(psl);
	SLCheckCapacity(psl);//检查增容
	psl->a[psl->size] = X;
	psl->size++;
	//SLInsert(psl, psl->size, X);
}

5.顶部插入

void SLPushFront(SL* psl, SLDatatype X)
{
	assert(psl);
	SLCheckCapacity(psl);

	//插入数据
	int i = 0;
	for (i = psl->size; i > 0; i--)
	{
		psl->a[i] = psl->a[i - 1];
	}
	psl->a[0] = X;
	psl->size++;
	//SLInsert(psl, 0, X);
}

6.尾部删除

void SLPopBack(SL* psl)
{
	assert(psl);
	assert(psl->size > 0);
	psl->size--;
	if (psl->size > 0)
	{
		psl->size--;
	}
	//SLErase(psl, psl->size - 1);
}

7.顶部删除

void SLPopFront(SL* psl)
{
	assert(psl);
	assert(psl->size > 0);
	int i = 0;
	for (i = 1; i < psl->size; i++)
	{
		psl->a[i-1] = psl->a[i];
	}
	psl->size--;
	//SLErase(psl, 0);
}

8.中间插入

void SLInsert(SL* psl, int pos, SLDatatype X)
{
	assert(psl);
	assert(pos >= 0 && pos <= psl->size);

	SLCheckCapacity(psl);
	int i = 0;
	for (i = psl->size-1; i >= pos; i--)
	{
		psl->a[i+1] = psl->a[i];
	}
	psl->a[pos] = X;
	psl->size++;
}

9.中间删除

void SLErase(SL* psl, int pos)
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);
	int i = 0;
	for (i = pos; i < psl->size-1; i++)
	{
		psl->a[i] = psl->a[i + 1];
	}
	psl->size--;
}

10.数据查找

找到返回下标，否则返回-1

int SLFind(SL* psl, SLDatatype x)
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

11.更改数据

void SLModify(SL* psl, int pos, SLDatatype x)
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);
	psl->a[pos] = x;
}

12.释放顺序表

void SLDestroy(SL* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = 0;
	psl->size = 0;
}

四、完整代码

SeqList.h

#pragma once
#include<stdlib.h>
#include<stdio.h>
#include<assert.h>
typedef int SLDatatype;

//#define N 10
//
静态数据库缺点
给小了不够用，给大了浪费
//
//struct SeqList
//{
//	SLDatatype a[N];
//	int size;
//};

//动态顺序表
typedef struct SeqList
{
	SLDatatype* a;
	int size;	   // 有效数据个数
	int capacity;  // 容量
}SL;

void SLInit(SL* psl);//初始化
void SLDestroy(SL* psl);//释放
void SLPrint(SL* psl);//打印
void SLPushBack(SL* psl, SLDatatype X);//尾部插入
void SLPushFront(SL* psl, SLDatatype X);//头部插入
void SLPopBack(SL* psl);//尾部删除
void SLPopFront(SL* psl);//头部删除
void SLInsert(SL* psl, int pos,SLDatatype X);//中间插入
void SLErase(SL* psl, int pos);//中间删除
int SLFind(SL* psl, SLDatatype x);//查找数据
void SLModify(SL* psl, int pos, SLDatatype x);//改数据

SeqList.c

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

void SLInit(SL* psl)//初始化
{
	assert(psl);
	psl->a = (SLDatatype*)malloc(sizeof(SLDatatype) * 4);
	if (psl->a == NULL)
	{
		perror("SLInit");
		return;
	}
	psl->capacity = 4;
	psl->size = 0;
}

void SLDestroy(SL* psl)//销毁
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = 0;
	psl->size = 0;
}

int SLFind(SL* psl, SLDatatype x)//查找数据
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void SLCheckCapacity(SL* psl)//检查容量
{
	assert(psl);
	if (psl->size == psl->capacity)
	{
		SLDatatype* pf = (SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * (psl->capacity + 3));
		if (pf == NULL)
		{
			perror("SLCheckCapacity");
			return;
		}
		psl->a = pf;
		psl->capacity += 3;
	}
}

void SLPushBack(SL* psl, SLDatatype X)//尾部插入
{
	assert(psl);
	SLCheckCapacity(psl);
	//psl->a[psl->size] = X;
	//psl->size++;
	SLInsert(psl, psl->size, X);
}

void SLPrint(SL* psl)//打印
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

void SLPushFront(SL* psl, SLDatatype X)//顶部插入
{
	assert(psl);
	SLCheckCapacity(psl);

	//插入数据
	int i = 0;
	for (i = psl->size; i > 0; i--)
	{
		psl->a[i] = psl->a[i - 1];
	}
	psl->a[0] = X;
	psl->size++;
	//SLInsert(psl, 0, X);
}

void SLPopBack(SL* psl)//尾部删除
{
	assert(psl);
	assert(psl->size > 0);
	psl->size--;
	if (psl->size > 0)
	{
		psl->size--;
	}
	//SLErase(psl, psl->size - 1);
}

void SLPopFront(SL* psl)//顶部删除
{
	assert(psl);
	assert(psl->size > 0);
	int i = 0;
	for (i = 1; i < psl->size; i++)
	{
		psl->a[i-1] = psl->a[i];
	}
	psl->size--;
	//SLErase(psl, 0);
}

void SLInsert(SL* psl, int pos, SLDatatype X)//中间插入
{
	assert(psl);
	assert(pos >= 0 && pos <= psl->size);

	SLCheckCapacity(psl);
	int i = 0;
	for (i = psl->size-1; i >= pos; i--)
	{
		psl->a[i+1] = psl->a[i];
	}
	psl->a[pos] = X;
	psl->size++;
}

void SLErase(SL* psl, int pos)//中间删除
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);
	int i = 0;
	for (i = pos; i < psl->size-1; i++)
	{
		psl->a[i] = psl->a[i + 1];
	}
	psl->size--;
}

void SLModify(SL* psl, int pos, SLDatatype x)//数据更改
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);
	psl->a[pos] = x;
}

test.c

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

void menu()
{
	printf("#######################################\n");
	printf("####### 1.尾部插入   2.顶部插入 #######\n");
	printf("####### 3.尾部删除   4.顶部删除 #######\n");
	printf("####### 5.中间插入   6.中间删除 #######\n");
	printf("####### 7.查找数据   8.更改数据 #######\n");
	printf("####### 9.打印数据   0.EXIT     #######\n");
	printf("#######################################\n");
}

int main()
{
	int input = 0;
	SL s;
	SLInit(&s);
	int num = 0;
	int pos = 0;
	do
	{
		menu();
		printf("请输入选项:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("\n请输入要插入尾部的数字:>");
			scanf("%d", &num);
			SLPushFront(&s, num);
			break;
		case 2:
			printf("\n请输入要插入顶部的数字:>");
			scanf("%d", &num);
			SLPushFront(&s,num);
			break;
		case 3:
			SLPopBack(&s);
			break;
		case 4:
			SLPopFront(&s);
			break;
		case 5:
			printf("\n请输入要插入的下标:>");
			scanf("%d", &pos);
			printf("\n请输入要插入中间的数字:>");
			scanf("%d", &num);
			SLInsert(&s, pos, num);
			break;
		case 6:
			printf("\n请输入要删除的下标:>");
			scanf("%d", &pos);
			SLErase(&s, pos);
			break;
		case 7:
			printf("\n请输入要查找的数据:>");
			scanf("%d", &num);
			pos = SLFind(&s, num);
			if (pos != -1)
			{
				printf("你所查找数据的下标为:>%d\n", pos);
			}
			else
			{
				printf("没有此数据\n");
			}
			break;
		case 8:
			printf("\n请输入要更改数据的下标:>");
			scanf("%d", &pos);
			printf("\n请输入要更改的数据:>");
			scanf("%d", &num);
			SLModify(&s, pos, num);
			break;
		case 9:
			SLPrint(&s);
			break;
		case 0:
			printf("EXIT\n");
			break;
		default:
			printf("输入错误请重新输入\n");
			break;
		}
	} while (input);

	SLDestroy(&s);
	return 0;
}

五、相关题目

1.移除元素

        给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例

输入：nums = [0, 1, 2, 2, 3, 0, 4, 2], val = 2
输出：5, nums = [0, 1, 3, 0, 4]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

题解

        

int removeElement(int* nums, int numsSize, int val) 
{
    int f = 0;
    int s = 0;

    for(f = 0; f < numsSize; f++)
    {
        if(nums[f] != val)
        {
            nums[s] = nums[f];
            s++;
        }
    }   
    return s; 
}

2.合并两个有序数组

        给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 ：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

题解

        从两个数组中最后面开始比较，大的数放到后面，遍历一次数组后，若剩余数组还有数据，则倒序向前放入。

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) 
{
    int src = m-1;//0
 
    int dest = n-1;//0

    while(src>=0 && dest>=0)
    {
        if(nums1[src] < nums2[dest])
        {
            nums1[src+dest+1] = nums2[dest];
            dest--;
        }
        else
        {
            
            nums1[src+dest+1] = nums1[src];
            src--; 
        }
    }

    while(dest >= 0)
    {
        nums1[dest] = nums2[dest];
        dest--;
    }

}

3.删除有序数组中的重复项

        给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

  • 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
  • 返回 k 。

示例 ：

输入：nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
输出：5, nums = [0, 1, 2, 3, 4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

题解

int removeDuplicates(int* nums, int numsSize) 
{
    int src = 1;
    int dest = 0;
    while(src < numsSize)
    {
        if(nums[src] != nums[dest])
        {
            nums[++dest] = nums[src++];
        }
        else
        {
            src++;
        }
    }
    return dest+1;
}

 

S_WEAN
关注
数据结构 顺序表学习总结
sumandavg的博客
10-24 1588
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。 目录前言1. 顺序表介绍1.1 什么是顺序表1.2 顺序表的性质1.3 顺序表的构成1.4 顺序表的框架代码（C++版）2. 顺序表的操作2.1 初始化顺序表2.1.1 步骤2.1.2 代码展示2.2 顺序表的插入2.2.1 步骤2.2.2 代码展示2.3 顺序表的扩容2.3.1 步骤2.3.2 代码展示2.4 顺序表的查询2.4.1 步骤2.4.
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
c++数据结构顺序表实现
cangyue_a的博客
04-05 2920
c++数据结构中的方法通过面向对象的机制提高了程序的效率。
数据结构-顺序表基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-13 21万+
今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现，主要实现函数如下，读者有需要可以评论，我可以适当加几个。 CreatList(SqList &L,int n) 参数：顺序表L，顺序表长度n 功能：创建长度为的顺序表 时间复杂度：O(n) InitList(SqList &...
数据结构 顺序表的查找
weixin_57500505的博客
12-09 2840
按值查找顺序表。请在程序中建立一个含有10个元素，分别是1,2,3,4,5,6,7,8,9,10的顺序表。然后等候用户输入要查找的元素值，如顺序表中有该元素，则输出该元素位序，否则输出查找失败。 【输入】要查找的元素值 【输出】该元素位序 或查找失败 代码 #include<iostream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int ElemType.
数据结构：顺序表详解
Zhenyu_Coder的博客
07-30 6204
顺序表作为一种基本的数据结构，在许多应用场景中具有重要的意义和作用，可以提高数据的访问和操作效率，简化算法设计，提高内存利用率。本篇博客将向你详细介绍其模拟过程及全代码
C语言数据结构 顺序表的输入与输出
qq_60649317的博客
12-03 2579
大学新手
数据结构 顺序表实现手机通讯录
taotu_tao的博客
03-29 6158
代码 #include <stdio.h> #include <malloc.h> #include <string.h> #include <stdlib.h> #include <windows.h> #include <conio.h> //#include <stack> typedef struct { char name[10]; char tel[12]; }ElemType; typedef s
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 1万+
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
Educoder头歌数据结构顺序表及其应用
qq_50848214的博客
11-05 1万+
头歌实践平台答案 数据结构-顺序表及其应用 第1关：顺序表的实现之查找功能 /************************************************************* 顺序表的实现之查找功能 实现文件 更新于2020年4月13日 **************************************************************/ void SL_GetAt(SqList L, int i, ElemType &e)
数据结构（顺序表）
小马同学的博客
11-07 2444
数据机构的顺序表实现
头歌数据结构顺序表的基本操作1-6关
05-18
【顺序表】是一种基本的数据结构，它在计算机科学中被广泛使用，特别是在处理大量有序或无序数据时。顺序表的实现通常是通过数组来完成的，数组中的元素按顺序存储，便于快速访问和操作。本题涉及顺序表的六种基本...
数据结构顺序表c++代码
12-06
本文将深入探讨“数据结构顺序表”的概念以及如何使用C++实现它的基本操作，包括创建、查找、插入和删除。 顺序表，顾名思义，是元素在内存中按照线性顺序排列的数组。它具有连续的存储空间，每个元素都有一个固定...
C语言数据结构顺序表 学生表 学生成绩管理系统.zip
06-25
本项目以"C语言数据结构顺序表 学生表 学生成绩管理系统"为主题，涉及到的核心知识点包括顺序表、学生表的设计以及如何用C语言构建一个简单的学生成绩管理系统。 首先，我们来讨论“顺序表”。顺序表是一种基础的...
数据结构 顺序表 （c++实现）代码讲解
09-27
这是讲解代码中函数关系的Keynote 为了大家方便，已转换为ppt 博客地址blog.csdn.net/u012350104
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现
青山师
11-04 1019
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现。
【进阶】java基础之集合(2)数据结构＜树＞
最新发布
Y0UZI的博客
11-05 325
二叉查找树，又称二叉排序树或者二叉搜索树。:任意节点左右子树高度差不超过1。
Redis常见面试题：ZSet底层数据结构，SDS、压缩列表ZipList、跳表SkipList
qq_44700578的博客
11-02 963
String类型底层数据结构，List类型全面解析，ZSet底层数据结构；简单动态字符串SDS、压缩列表ZipList、哈希表、跳表SkipList、整数数组IntSet
【数据结构与算法】第8课—数据结构之二叉树(堆)
weixin_70620792的博客
11-02 786
树是一种非线性的数据结构，它是由n(n>=0)个有限节点组成一个具有层次关系的集合，一般是树根朝上，树叶朝下树有一个特殊的节点，叫做根节点，根节点没有前驱节点树的根节点下面又有很多子节点，但是这些子节点是不相交的除根节点外，每棵子树的根节点有且只有一个前驱，但是可以有0个或多个后继，因此，树是递归定义的。
C语言实现数据结构顺序表查找
该资源是一个使用C语言编写的顺序表查找程序，主要涉及数据结构中的顺序查找算法。程序首先初始化一个顺序表，然后允许用户输入数据填充表，并进行指定键值的查找操作。 在数据结构中，顺序表是一种简单的线性数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值