顺序表的实现

最新推荐文章于 2021-11-20 10:12:25 发布
最新推荐文章于 2021-11-20 10:12:25 发布
阅读量107 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lchilde/article/details/99199417
版权

顺序表的实现

一：c语言实现
test.h

#pragma once
typedef struct SeqList
{
 int* array;
 int capacity;
 int size;
}SeqList;
//初始化
void SeqListInit(SeqList* seq);
//销毁
void SeqListDestroy(SeqList* seq);
//头插
void SeqListpushFront(SeqList* seq,int val);
//尾插
void SeqListpushBack(SeqList* seq,int val);
//头删
void SeqListPopFront(SeqList* seq);
//尾删
void SeqListPopBack(SeqList* seq);
//下标插
void SeqListInsert(SeqList* seq, int index, int val);
//下标删
void SeqListErase(SeqList* seq, int index);
//打印
void SeqListprint(SeqList* seq);

test.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include"test.h"
#include<assert.h>
#define INIT_CAPACITY 100
static void ensurecapacity(SeqList* seq) {
 if (seq->size < seq->capacity) {
  return;
 }
 else {
  int newcapacity = 2 * seq->capacity;
  int* newarray = (int*)malloc(newcapacity * sizeof(int));
  for (int i = 0;i < seq->size;i++) {
   newarray[i] =seq->array[i];
  }
  free(seq->array);
  seq->array = newarray;
 }
}
//初始化
void SeqListInit(SeqList* seq) {
 seq->array = (int*)malloc(sizeof(int) * INIT_CAPACITY);
 seq->capacity = INIT_CAPACITY;
 seq->size = 0;
}
//销毁
void SeqListDestroy(SeqList* seq) {
 free(seq->array);
 seq->capacity = 0;
 seq->size = 0;
}
//头插
void SeqListpushFront(SeqList* seq, int val) {
 for (int i = seq->size - 1;i >= 0;i--) {
  seq->array[i + 1] = seq->array[i];
 }
  seq->array[0]=val;
 seq->size++;
}
//尾插
void SeqListpushBack(SeqList* seq, int val) {
  seq->array[seq->size]=val;
 seq->size++;
}
//头删
void SeqListPopFront(SeqList* seq) {
 assert(seq->size > 0);
 for (int i = 0;i < seq->size - 1;i++) {
  seq->array[i] = seq->array[i + 1];
 }
 seq->size--;
}
//尾删
void SeqListPopBack(SeqList* seq) {
 assert(seq->size > 0);
 seq->size--;
}
//下标插
void SeqListInsert(SeqList* seq, int index, int val) {
 if (index < 0 || index>seq->size) {
  printf("下标不合法");
  return;
 }
 ensurecapacity(seq);
 for (int i = seq->size;i > index;i--) {
  seq->array[i] = seq->array[i-1];
 }
 seq->array[index] = val;
 seq->size++;
}
//下标删
void SeqListErase(SeqList* seq, int index) {
 assert(seq->size > 0);
 for (int i = index;i < seq->size - 1;i++) {
  seq->array[i] = seq->array[i + 1];
 }
 seq->size--;
}
//打印
void SeqListprint(SeqList* seq) {
 for (int i = 0;i < seq->size;i++) {
  printf("%d ",seq->array[i]);
 }
 printf("\n");
}

main.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"test.h"
int main() {
 SeqList seqList;
 SeqListInit(&seqList);
 SeqListpushFront(&seqList, 1);
 SeqListpushFront(&seqList, 2);
 SeqListpushFront(&seqList, 3);
 SeqListpushFront(&seqList, 4);
 SeqListprint(&seqList);
 SeqListpushBack(&seqList, 10);
 SeqListpushBack(&seqList, 20);
 SeqListpushBack(&seqList, 30);
 SeqListpushBack(&seqList, 40);
 SeqListprint(&seqList);
 SeqListInsert(&seqList, 4,0);
 SeqListprint(&seqList);
 SeqListErase(&seqList, 5);
 SeqListprint(&seqList);
 SeqListPopFront(&seqList);
 SeqListprint(&seqList);
 SeqListPopBack(&seqList);
 SeqListprint(&seqList);
 system("pause");
 return 0;
}

二：c++实现（模板）
test.h

#pragma once
#include<iostream>
using namespace std;
#define MAX_SIZE 10
template<class Type>
class SeqList {
private:
 Type* array;
 size_t capacity;
 size_t size;
public:
 ~SeqList();
 SeqList(size_t sz=MAX_SIZE);
 bool isfull()const;
 bool isempty()const;
 void SeqListPushFront(const Type& val);//头插
 void SeqListPushBack(const Type &val);//尾插
 void SeqListPopFront();//头删
 void SeqListPopBack();//尾删
 void SeqListprint();//打印
 void SeqListInsert(int index, const Type& val);//按位置插入
 void SeqListerase(int index);//按位置删除
 int Find(const Type& val);//按值查找
 void delete_val(const Type& val);//按值删除
 int length();//求长度
 void reserve();//反转
 void sort();//排序
 void clear();
};
 template<class Type>
SeqList<Type>::~SeqList() {
 delete[]array;
 capacity = 0;
 size = 0;
}
template<class Type>
SeqList<Type>::SeqList(size_t sz) {//分配空间
 capacity = sz > MAX_SIZE? sz : MAX_SIZE;
 array = new int[capacity];
 size = 0;
}
template<class Type>
bool SeqList<Type>::isfull()const {
 return size >= capacity;
}
template<class Type>
bool SeqList<Type>::isempty()const {
 return size==0;
}
template<class Type>
void SeqList<Type>::SeqListPushFront(const Type& val) {
 if (isfull()) {
  cout << "顺序表已满，不可插入" << endl;
 }
 else {
  for (int i = size;i >0;i--) {
   array[i] = array[i-1];
  }
  array[0] = val;
  size++;
 }
}
template<class Type>
void SeqList<Type>::SeqListPushBack(const Type& val) {
 if (isfull()) {
  cout << "顺序表已满，不可插入" << endl;
 }
 array[size++] = val;
}
template<class Type>
void SeqList<Type>::SeqListPopFront() {
 if (isempty()) {
  cout << "顺序表为空，不可删除" << endl;
 }
 for (int i = 0;i < size ;i++) {
  array[i] = array[i + 1];
 }
 size--;
}
template<class Type>
void SeqList<Type>::SeqListPopBack() {
 if (isempty()) {
  cout << "顺序表为空，不可删除" << endl;
 }
 size--;
}
template<class Type>
void SeqList<Type>::SeqListprint() {
 for (int i = 0;i < size;i++) {
  cout << array[i] << " ";
 }
 cout << endl; 
}
template<class Type>
void SeqList<Type>::SeqListInsert(int index, const Type& val) {
 if (index<0 || index>size) {
  cout << " 插入位置非法" << endl;
 }
 if (isfull()) {
  cout << "顺序表已满，不可插入" << endl;
 }
 for (int i = size;i > index;i--) {
  array[i] = array[i - 1];
 }
 array[index] = val;
 size++;
}
template<class Type>
void SeqList<Type>::SeqListerase(int index) {
 if (isempty()) {
  cout << " 顺序表为空，不可删除" << endl;
 }
 for (int i = index;i < size;i++) {
  array[i] = array[i + 1];
 }
 size--;
}
template<class Type>
int SeqList<Type>::Find(const Type& val) {
 for (int i = 0;i < size;i++) {
  if (array[i] == val)
  {
   cout << i << endl;
   return i;
  }
 }
 cout << "顺序表中没有该数" << endl;
 return -1;
}
template<class Type>
void SeqList<Type>::delete_val(const Type& val) {
 for (int i = 0;i < size;i++) {
  if (array[i] == val) {
   return SeqListerase(i);
  }
 }
 return;
}
template<class Type>
int SeqList<Type>::length() {
  cout << size << endl;
  return size;
}
template<class Type>
void SeqList<Type>::reserve() {
 int m = size - 1;
 for (int i = 0;i <=((size-1)/ 2);i++) {
  int temp = array[i];
  array[i] = array[m];
  array[m] = temp;
  m--;
 } 
}
template<class Type>
void SeqList<Type>::sort() {
 for (int i = 0;i < size;i++) {
  for (int j = 0;j < size - i - 1;j++) {
   if (array[j] > array[j + 1]) {
    int temp = array[j];
    array[j] = array[j + 1];
    array[j + 1] = temp;
   }
  }
 }
}
template<class Type>
void SeqList<Type>::clear() {
 while (size) {
  array[size--] =NULL;
 }
}

main.cpp

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdlib.h>
#include"test.h"
int main() {
 SeqList<int> seqList;
 seqList.SeqListPushFront(1);
 seqList.SeqListPushFront(2);
 seqList.SeqListPushFront(3);
 seqList.SeqListPushFront(4);
 seqList.SeqListprint();
 seqList.SeqListPushBack(10);
 seqList.SeqListPushBack(20);
 seqList.SeqListPushBack(30);
 seqList.SeqListPushBack(40);
 seqList.SeqListprint();
 seqList.SeqListPopFront();
 seqList.SeqListPopFront();
 seqList.SeqListprint();
 seqList.SeqListPopBack();
 seqList.SeqListprint();
 seqList.SeqListInsert(0, 0);
 seqList.SeqListprint();
 seqList.SeqListerase(5);
 seqList.SeqListprint();
 seqList.Find(1);
 seqList.Find(100);
 seqList.delete_val(1);
 seqList.SeqListprint();
 seqList.length();
 seqList.reserve();
 seqList.SeqListprint();
 seqList.reserve();
 seqList.SeqListprint();
 seqList.clear();
 seqList.SeqListprint();
 seqList.length();
 return 0;
}

三：c++实现

test.h

#pragma once
class SeqList {
private:
 int* array;
 int capacity;
  int size;
public:
 SeqList();
 ~SeqList();
 void ensurecapacity();
 void SeqListPushFront(int val);
 void SeqListPushBack(int val);
 void SeqListPopFront();
 void SeqListPopBack();
 void SeqlistInsert(int index, int val);
 void SeqListErase(int index);
 void SeqListprint();
};

test.cpp

#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#define INIT_CAPAICTY 100
#include"test.h"
SeqList::SeqList() {
 array = new int[INIT_CAPAICTY];
 capacity = INIT_CAPAICTY;
 size = 0;
}
SeqList::~SeqList() {
 delete[]array;
 capacity = 0;
 size = 0;
}
void SeqList::ensurecapacity() {
 if (size < capacity) {
  return;
 }
 else {
  int newcapacity = 2 * capacity;
  int* newarray = new int[newcapacity];
  for (int i = 0;i < size;i++) {
   newarray[i] = array[i];
  }
  delete[]array;
  array = newarray;
 }
}
void SeqList::SeqListPushFront(int val) {
 for (int i = size-1;i >=0;i--) {
  array[i+1] = array[i];
 }
 array[0] = val;
 size++;
}
void SeqList::SeqListPushBack(int val) {
 array[size] = val;
 size++;
}
void SeqList::SeqListPopFront() {
 for (int i = 0;i<size;i++) {
  array[i] = array[i+1];
 }
 size--;
}
void SeqList::SeqListPopBack() {
 size--;
}
void SeqList::SeqlistInsert(int index, int val) {
 if (index<0 || index>size) {
  cout << "下标不合法" << endl;
 }
 ensurecapacity();
 for (int i = size;i > index;i--) {
  array[i] = array[i-1];
 }
 array[index] = val;
 size++;
}
void SeqList::SeqListErase(int index) {
 for (int i = index;i < size;i++) {
  array[i] = array[i + 1];
 }
 size--;
}
void SeqList::SeqListprint() {
 for (int i = 0;i < size;i++) {
  cout << array[i]<<" ";
 }
 cout << endl;
}

main.cpp

#define  _CRT_SECURE_NO_WARNINGS 1
#include"test.h"
#include<stdlib.h>
int main() {
 SeqList seqList;
 seqList.SeqListPushFront(1);
 seqList.SeqListPushFront(2);
 seqList.SeqListPushFront(3);
 seqList.SeqListPushFront(4);
 seqList.SeqListprint();
 seqList.SeqListPushBack(10);
 seqList.SeqListPushBack(20);
 seqList.SeqListPushBack(30);
 seqList.SeqListPushBack(40);
 seqList.SeqListprint();
 seqList.SeqListPopFront();
 seqList.SeqListprint();
 seqList.SeqListPopBack();
 seqList.SeqListprint();
 seqList.SeqlistInsert(0, 0);
 seqList.SeqListprint();
 seqList.SeqListErase(8);
 seqList.SeqListprint();
 system("pause");
 return 0;
}
L公子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表实现
11-05
在Java中，数组是最直接的顺序表实现方式，数组的索引范围通常是0到数组长度减1。 实现Java顺序表时，我们通常创建一个泛型类，允许存储任何类型的数据。例如： ```java public class SeqList<T> { private T[] ...
数据结构期末复习
wangwangwangz的博客
12-15 1242
数据结构 算法概念,及其特性;数据结构的基本术语 算法是解决特定问题求解步骤的描述,在计算机中表现为指令的有限序列,并且每条指令表示一个或者多个操作 算法的五大特性:输入,输出,有穷性,确定性,可行性 数据结构的基本术语: 数据结构:相互之间存在一种或者多种特定关系的数据元素的集合 数据元素:一个数据元素可以由若干个数据项组成 数据项: 是数据不可分割的最小单元 顺序表,链表中各种情况下的插入,删除,访问操作的时间复杂度;执行插入,删除操作时,空和满的判断条件 操作 顺序表 链表
数据结构——顺序表
kankanim的博客
04-03 4743
数据结构——顺序表 顺序表是指在计算机内存中以数组的形式保存的线性表；将元素一个接一个的存入一组连续的存储单元，这种方式称为顺序结构。 C语言定义顺序表的结构体 #define MAXSIZE N // N 是可以存储多少个数据 typedef int data_t; // data_t 是数据类型 typedef struct{ data_t data[MAXSIZE]; ...
数据结构（一）线性结构（1）顺序表
floatinglong的博客
03-11 3740
线性表是最基本、最常用的数据结构，大部分线性表中数据元素之间的关系是一对一的关系，除了首尾元素，其它元素都是首尾相连的 其表示方法主要有顺序表示（顺序表）以及链式表示（链表），在本节介绍顺序表的一些操作实现 顺序表至少包含一个用于存储数据的数组和一个表示数据个数的变量，因此顺序表可定义为： typedef struct { int aiArray[ARRAY_SIZE]; i...
使用顺序表实现奇偶排序
最新发布
09-25
【顺序表实现奇偶排序】 在给定的问题中，我们需要对一个整数顺序表进行特殊排序，即把所有的奇数移到偶数的前面。这里我们使用C++编程语言来实现这个算法。首先，顺序表是一种数据结构，它将元素存储在连续的内存...
顺序表实现的图书管理
06-19
定义图书类型结构，定义顺序表；完成功能：初始化构建空表、插入新记录到第i个位置、删除表中第i个记录、按图书名称进行查找、按作者进行查找、按价格区间进行查找。
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
在本文中，我们将深入探讨如何使用C语言实现一个顺序表来统计单词的出现频率。顺序表是一种基础的数据结构，它将元素存储在一个连续的内存区域中，通过索引来访问元素，具有简单直观的操作方式。 首先，我们需要...
数据结构——顺序表的基本操作
qq_48229658的博客
08-29 1807
题目： 将顺序表的基本算法（如初始化、求长度、插入、删除、输出等）汇总在一起，用一个完整的程序实现顺序表的基本运算，并且编写顺序表的判空、判满等基本运算的算法。 代码： #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define MAXSIZE 1024 typedef int elemtype; typedef struct { elemtype data[MAXSIZ...
顺序表的初始化、插入、删除、获得长度、判空、清空、打印等操作具体实现。
漆黑梦工厂
04-22 4615
/**************************** * 文件名：[main.c] * 作者：〈漆黑〉 * 描述：〈顺序表〉 * 创建时间：2019.4.22 ****************************/ #include <stdio.h> #include <stdlib.h> #include "DataElement.h" ElementTyp...
数据结构算法实现-顺序表实现
jiaye_mi的博客
03-08 3339
C++实现数据结构顺序表代码，仅用于学习。
线性表之顺序表 C++代码实验
u014302425的博客
10-31 253
基本的查空、插入/删除、显示功能。其他功能只需要在这个结构上照着写函数即可，就不放在代码里面，否则反而影响阅读。 #include<iostream> using namespace std; #define MaxNum 100 //线性表最大长度 typedef int DataType; //线性表数据类型，简单起见设为int class SeqList{ //线性表 public: DataTyp
C++ 顺序表的基本操作
wherehw的博客
11-20 1180
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
数据结构手把手教学——顺序表
Sanjay_Wu的博客
12-01 2216
文章不空谈理论，完全采用手把手教学，并有综合示例练习题，看完这篇，你绝对能掌握数据结构顺序表。
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
顺序表实现与操作
本资源提供了一个简单的顺序表（Sequence List）实现，用于演示数据结构的基本操作。 顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储。这个实现中，顺序表由一个名为`Vector`的结构体表示，包含三个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值