顺序表——简单实现（静态数组）

最新推荐文章于 2023-09-19 09:28:34 发布
最新推荐文章于 2023-09-19 09:28:34 发布
阅读量494 收藏 1
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/devil_net/article/details/79555938
版权
实现基于静态数组的顺序表的以下基本操作: 
1. 初始化 
2. 尾插 
3. 尾删 
4. 头插 
5. 头删 
6. 读任意位置元素 
7. 修改任意位置元素 
8. 查找指定元素值的下标 

9. 在任意位置插入元素

实现环境：Centos6.5 vim编辑器

       大体的思路，头插尾插主要是建立在数组的最后位，而数组的下标是以0开始的，即给其数组的静态空间加上尾插的个数，而将尾插的数依次赋给数组的后边，尾删同样的道理，删除完后将空间减一即可。

        头插头删，以头插一个元素为例，开辟的静态数组空间加一，依次由最后一个数替代上一个数，到最后空出来的是第一位，将值传给其空出来的即可。头删同样的道理i=i+1；依次循环将第一个值覆盖，留出最后一个空位置，然后减减。

  先简单的写一下代码，后边有空将补上图解：

SeqList.h文件：

#pragma once  //防止头文件包含


#include<stdlib.h>


#define SeqListMaxNum 1000 


typedef char SeqListType;   //重定义类型  定义类型
typedef struct SeqList{
    SeqListType SeqListArr[SeqListMaxNum];
    size_t size;           //元素个数  标志有效元素
}SeqList;


void SeqListInit(SeqList* seq);    //初始化顺序表


void SeqListPrint(SeqList* seq,char* ch);   //打印顺序表


void SeqListPushEnd(SeqList* seq,SeqListType value);   //尾插一个元素


void SeqListPopEnd(SeqList* seq);     //尾删一个元素


void SeqListPushStart(SeqList* seq,SeqListType value);   //头插一个元素


void SeqListPopStart(SeqList* seq);    //头删一个元素


void SeqListPushPosition(SeqList*seq ,size_t pos,SeqListType value);   //在下标为pos处插入元素


void SeqListPopPosition(SeqList* seq, size_t pos);               //删除下标为pos的元素


void SeqListSetList(SeqList* seq, size_t pos, SeqListType value);     //修改下标为pos的元素



SeqListType SeqListGetList(SeqList* seq, size_t pos);       //读下标为pos的元素

size_t SeqListGetpos(SeqList* seq, SeqListType value);      //查找value元素值的下标





SeqList.c文件：

#include "SeqList.h"
#include<stdio.h>
#include<assert.h>
//初始化顺序表
void SeqListInit(SeqList* seq){
	assert(seq);           //对指针操作时必须先判断是否为空
	seq->size=0;           //->也相当于解引用
}


//打印顺序表
void SeqListPrint(SeqList* seq,char* ch){
	assert(seq);
	int i=0;
	printf("%s\n",ch);
	for( ;i<seq->size;i++){
		printf("下表元素%d的元素是:[%c]\n",i,seq->SeqListArr[i]);
	}
	printf("size=%ld\n\n",seq->size);
}


//尾插一个元素
void SeqListPushEnd(SeqList* seq,SeqListType value){    //参数 往哪个元素中插  要插入的元素
	assert(seq);
	if(seq->size >= SeqListMaxNum){
		printf("顺序表已满，无法插入！\n\n");
		return;
	}
	else{
		seq->SeqListArr[seq->size]=value;
		seq->size++;
	}
}


//尾删一个元素
void SeqListPopEnd(SeqList* seq){
	assert(seq);
	if(seq->size==0){
		printf("顺序表为空表，无法删除！\n\n");
		return;
	}
	else{
		seq->size--;
	}
}


//头插一个元素
void SeqListPushStart(SeqList *seq,SeqListType value){
	assert(seq);
	if(seq->size >= SeqListMaxNum){
		printf("顺序表已满，无法插入！\n\n");
		return;
	}
	else{
		int i=seq->size-1;
		for( ;i>=0;i--){
			seq->SeqListArr[i+1]=seq->SeqListArr[i];
		}
		seq->SeqListArr[0]=value;
		seq->size++;
	}
}


//头删一个元素
void SeqListPopStart(SeqList* seq){
	assert(seq);
	if(seq->size ==0){
		printf("顺序表为空，无法删除!\n\n");
		return;
	}
	else{
		int i=0;
		for( ;i<seq->size-1;i++){
			seq->SeqListArr[i]=seq->SeqListArr[i+1];
		}
		seq->size--;
	}
}


//在下标为pos处插入元素
void SeqListPushPosition(SeqList* seq,size_t pos,SeqListType value){
	assert(seq);
	if(seq->size >SeqListMaxNum){
		printf("顺序表已满，无法插入！\n\n");
		return;
	}
	else if(pos >= seq->size){
		printf("非法坐标！\n\n");
		return;
	}
	else{
		int i=seq->size-1;
		for( ;i>=pos;i--){
			seq->SeqListArr[i+1]=seq->SeqListArr[i];   //将pos元素后都后移，留出空间
		}
		seq->SeqListArr[pos]=value;
		seq->size++;
	}


//删除下标为pos的元素
void SeqListPopPosition(SeqList* seq, size_t pos)
{
		assert(seq);
		if (seq->size == 0){
			printf("顺序表为空表，无法删除！\n\n");
			return;
		}
		else if (pos >= seq->size){
			printf("非法坐标！\n\n");
			return;
		}
	else{
		int i = pos;
		for (; i < seq->size - 1; i++){
			seq->SeqListArr[i] = seq->SeqListArr[i + 1];
		}
		seq->size--;
	}
}


//修改下标为pos的元素
void SeqListSetList(SeqList* seq,size_t pos,SeqListType value){
	assert(seq);
	if(pos>=seq->size){
		printf("非法坐标!\n\n");
		return;
	}
	else{
		seq->SeqListArr[pos]=value;
	}
}


//读下标为pos的元素
SeqListType SeqListGetList(SeqList* seq,size_t pos){
	assert(seq);
	if(pos>=seq->size){
		printf("非法坐标!\n\n");
		return -1;
	}
	else{
		return seq->SeqListArr[pos];
	}
}


//查找value元素值的下标
size_t SeqListGetpos(SeqList* seq,SeqListType value){
	assert(seq);
	int i=0;
	for( ;i<seq->size;i++){
		if(seq->SeqListArr[i]==value){
			return i;
		}
	}
	return -1;
}


//****************************///
/测试代码///
//****************************///


//测试初始化顺序表
void TestSeqListInit(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPrint(&seq,"**********初始化顺序表********");
	}


//测试尾插一个元素
void TestSeqListPushEnd(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'a');
	SeqListPushEnd(&seq, 'b');
	SeqListPushEnd(&seq, 'c');
	SeqListPushEnd(&seq, 'd');
	SeqListPrint(&seq,"*********尾插元素**********");
}


//测试尾删一个元素
void TestSeqListPopEnd(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'a');
	SeqListPushEnd(&seq, 'b');
	SeqListPushEnd(&seq, 'c');
	SeqListPushEnd(&seq, 'd');
	SeqListPopEnd(&seq);
	SeqListPrint(&seq,"***********在顺序表中尾删一个元素*******");
	print("空表情况：\n");
	SeqListInit(&seq);
	SeqListPopEnd(&seq);
}


//测试头插一个元素
void TestSeqListPushStart(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'a');
	SeqListPushEnd(&seq, 'b');
	SeqListPushEnd(&seq, 'c');
	SeqListPushEnd(&seq, 'd');
	SeqListPushStart(&seq,'e');
	SeqListPrint(&seq,"******头插一个元素至顺序表******");
}


//测试头删一个元素
void TestSeqListPopStart(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'a');
	SeqListPushEnd(&seq, 'b');
	SeqListPushEnd(&seq, 'c');
	SeqListPushEnd(&seq, 'd');
	SeqListPopStart(&seq);
	SeqListPrint(&seq,"********在顺序表头删一个元素*******");
	printf("空表情况：\n");
	SeqListInit(&seq);
	SeqListPopStart(&seq);
}


//测试在pos处插入一个元素
void TestSeqListPushPosition(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'a');
	SeqListPushEnd(&seq, 'b');
	SeqListPushEnd(&seq, 'c');
	SeqListPushEnd(&seq, 'd');
	SeqListPushPosition(&seq,2,'s');
	SeqListPrint(&seq,"****在顺序表指定位置插入元素*****");
	printf("非法坐标情况：\n");
	SeqListPushPosition(&seq,21,'r');
}
//测试删除下标为pos的元素
void TestSeqListPopPosition(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'a');
	SeqListPushEnd(&seq, 'b');
	SeqListPushEnd(&seq, 'c');
	SeqListPushEnd(&seq, 'd');
	SeqListPopPosition(&seq, 2);
	SeqListPrint(&seq, "*****在顺序表中指定位置删除一个元素*****");
	printf("非法坐标情况(删除下标为8的元素)：\n");
	SeqListPopPosition(&seq, 8);
}


//测试修改下标为pos的元素
void TestSeqListSetList(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'a');
	SeqListPushEnd(&seq, 'b');
	SeqListPushEnd(&seq, 'c');
	SeqListPushEnd(&seq, 'd');
	SeqListSetList(&seq, 1, 'o');
	SeqListPrint(&seq, "*****在顺序表中修改指定位置的元素*****");
	printf("非法坐标情况(修改下标为10的元素)：\n");
	SeqListSetList(&seq, 10, 'k');
}


void TestSeqListGetList(){
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'e');
	SeqListPushEnd(&seq, 'f');
	SeqListPushEnd(&seq, 'g');
	SeqListPushEnd(&seq, 'h');
	SeqListPrint(&seq,"*********在顺序表中读取指定位置元素******");
	char ch =SeqListGetList(&seq,1);
	printf("下标为1的元素为%c\n", ch);
	printf("非法坐标情况(读取下标为6的元素)：\n");
	SeqListGetList(&seq, 6);
}
	
//测试查找value元素值的下标
void TestSeqListGetpos()
{
	SeqList seq;
	SeqListInit(&seq);
	SeqListPushEnd(&seq, 'e');
	SeqListPushEnd(&seq, 'f');
	SeqListPushEnd(&seq, 'g');
	SeqListPushEnd(&seq, 'h');
	SeqListPrint(&seq, "*****在顺序表中读取指定位置元素下标*****");
	size_t pos = SeqListGetpos(&seq, 'h');
	printf("h元素的下标为%ld\n", pos);
	printf("非法情况(读取元素W的下标)：\n");
	size_t pos1 = SeqListGetpos(&seq, 'W');
	printf("W元素的下标为%ld，坐标非法！\n\n", pos1);
}




int main(){
	TestSeqListInit();
	TestSeqListPushEnd();
	TestSeqListPopEnd();
	TestSeqListPushStart();
	TestSeqListPopStart();
	TestSeqListPushPosition();
	TestSeqListPopPosition();
	TestSeqListSetList();
	TestSeqListGetList();
	TestSeqListGetpos();
	return 0;

}

Makefile文件：

SeqList:SeqList.c
    gcc $^ -o $@


.PHONY:clean
clean:
    rm -rf *.o SeqList


 

 


 


 



                

        

        

    

  


    

      

        

            

              
                
                  Devil_Net
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
【数据结构】顺序表的实现——动态分配

				
			

			

				

					m0_74195174的博客
				

				

					04-01
					
					1525
					
				

			

		

		

			
				
本文旨在深入探讨顺序表的动态分配实现，帮助读者理解并掌握这一技术的核心概念和应用方法。通过动态分配内存，我们可以根据实际需求动态地调整顺序表的大小，从而更加高效地管理数据

			
		

	



                

              
                



	

		

			

				
					
[数据结构]线性表的顺序存储——顺序表，静态分配时的脏数据

				
			

			

				

					m0_64973566的博客
				

				

					03-07
					
					583
					
				

			

		

		

			
				
初始化顺序表时，将所有数据元素设置为默认值。



初始化顺序表时，如果将L.data[i]=0这句代码去掉的话，打印整个data数组会出现脏数据。



不过这种打印方式显然是不合理的。应该写作i<L.length;



实际上，i<L.length也不够好。可以使用线性表的基本操作。GetElem(L,i)，按位查找操作，获取表L中的第i个位置上的元素的值。



同时要理解L.length=0;不可以省略，因为要默认初始时存储的数据个数为0。
...

			
		

	



                


  
              

                


	

		

			

				
					
创建一个静态的顺序表存放整数

				
			

			

				

					04-17
				

			

		

		

			
				
创建一个静态的顺序表存放整数。大小为10.完成以下的操作输入6个整数，1.打 印出顺序表中的内容，并显示表中剩余的空间个数。在顺序表中的第3个位置插入元素O.2.打印出顺序表中的内容，并显示表中剩余的空间个数。再试图向表中第11个位置插入整数0,3.程序提示超出范围。4.删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。 二：编写一程序，动态地创建一个顺序表。要求顺序表初始长度为20,向顺序表中输 入15个整数，并打印出来: 再删除顺序表中的第5个元素。打印出删除后的结果。

			
		

	





	

		

			

				
					
数据结构——顺序表（静态数组）实现

				
			

			

				

					qq_44887899的博客
				

				

					07-24
					
					242
					
				

			

		

		

			
				
参考王道考研的视频
#include<stdio.h> 
#include<iostream>
using namespace std;

#define Maxsize 50 //线性表的最大长度，一旦定下，使用中不能更改

typedef struct {
	int data[Maxsize]; //定义一个表，这个例子我用了int类型的
	int length; //表中目前存在几个元素
}Sqlist;

//初始化一个顺序表
void InitList(Sqlist &am

			
		

	



		

			
		



	

		

			

				
					
静态数组顺序表

				
			

			

				

					qq_38325803的博客
				

				

					07-25
					
					117
					
				

			

		

		

			
				
**实现基于静态数组的顺序表的以下基本操作:

初始化
尾插
尾删
头插
头删
读任意位置元素
修改任意位置元素
查找指定元素值的下标
在任意位置插入元素**

实现在顺序表中增删查改需注意以下几点：
  1.初始化时不用将所有元素赋值为0，那样会降低代码效率
  2.插入元素时应该判断顺序表是否已经满了
  3.删除元素时只需将需删除的元素覆盖，使之无效即可
以下是实现代码：
SeqList.h...

			
		

	





	

		

			

				
					
简单实现顺序表

				
			

			

				

					lesileqin的博客
				

				

					03-02
					
					806
					
				

			

		

		

			
				
//简单顺序表的实现
#include<iostream> 
#define MAXSIZE 10
#define OVERFLOW -2
using namespace std;

typedef struct{
	int *elem;
	int length;
}Sqlist;

bool InitList(Sqlist &L)
{
	L.elem=new int[MAX...

			
		

	





	

		

			

				
					
数据结构-顺序表的简单实现

				
			

			

				

					dongxu_85的专栏
				

				

					08-09
					
					272
					
				

			

		

		

			
				
使用连续地址的数组实现简单的一个顺序表。

主要实现了线性表的初始化，在一个节点中插入数据，删除一个节点的数据，获取一个节点的数据的功能 。

 

#define LETTER_BUFFER_LENGTH    20    // 数组长度
#define LETTER_BUFFER_INCREAM    10    // 数组增加长度

typedef struct 
{
    char ch...

			
		

	





	

		

			

				
					
顺序表——静态分配的实现

				
			

			

				

					大块儿肉的博客
				

				

					07-18
					
					325
					
				

			

		

		

			
				
顺序表的静态分配实现

			
		

	





	

		

			

				
					
静态链表 - 用数组实现链表

					
最新发布

				
			

			

				

					eaglelau的专栏
				

				

					09-19
					
					179
					
				

			

		

		

			
				
链表 数组  静态链表 动态链表 

			
		

	





	

		

			

				
					
职工管理系统  ——静态数组实现

				
			

			

				

					 静-静的雪
				

				

					08-09
					
					755
					
				

			

		

		

			
				
职工管理系统——静态数组实现职工管理系统maincpp
my_arraycpp
my_filecpp
mainh
my_arrayh
my_filehmain.cpp//main.cpp
#include<stdio.h>
#include"my_file.h"
#include"my_array.h"
#include"main.h"void menu()
{
    printf("******

			
		

	





	

		

			

				
					
顺序表—简单功能的实现

				
			

			

				

					weixin_45636889的博客
				

				

					12-02
					
					151
					
				

			

		

		

			
				
顺序表的头文件如下：
typedef int SLDataType;
typedef struct Seqlist
{
	SLDataType* a;
	size_t size;
	size_t capacity;
}Seqlist;
//对数据的管理：增删查改
void SeqlistPrint(Seqlist* ps);//顺序表的显示
void SeqlistInit(Seqlist* ps...

			
		

	





	

		

			

				
					
数据结构（使用静态数组实现顺序表）

				
			

			

				

					DMHY123的博客
				

				

					07-18
					
					1337
					
				

			

		

		

			
				
数据结构（使用静态数组实现顺序表）

			
		

	





	

		

			

				
					
表的简单数组实现

				
			

			

				

					木之本樱的博客
				

				

					03-02
					
					234
					
				

			

		

		

			
				
表的简单数组实现
public class 表的简单数组实现 {
    public static void main(String[] args) {
        // 虽然数组是固定容量创建的，但必要的时候可以创建一个双倍容量的数组来进行扩充
        int[] arr = new int[10];
        for (int i = 0; i < arr.lengt...

			
		

	





	

		

			

				
					
数据结构（java语言描述）-- 表的简单数组实现

				
			

			

				

					一大三千的博客
				

				

					10-01
					
					1069
					
				

			

		

		

			
				
首先了解下抽象数据类型的概念：


抽象数据类型（Abstract Data Type)是指一个数学模型以及定义在该模型上的一组操作。

ADT包括数据数据元素，数据关系以及相关的操作。

即ADT

{

数据对象：（数据元素集合）

数据关系：（数据关系二元组结合）

基本操作：（操作函数的罗列）

}

抽象数据类型（ADT）是一个实现包括储存数据元素的

			
		

	





	

		

			

				
					
静态数组的顺序表

				
			

			

				

					lly9876000的博客
				

				

					03-17
					
					185
					
				

			

		

		

			
				
Seqlist1.h头文件#pragma once#include &lt;stddef.h&gt;#define SeqListMaxSize 1000typedef char SeqListType;typedef struct SeqList{ SeqListType data[SeqListMaxSize];size_t size;}SeqList;void SeqListInit(Seq...

			
		

	





	

		

			

				
					
数据结构---实现基于静态数组的顺序表的基本操作

				
			

			

				

					啦~啦~啦~的博客
				

				

					12-10
					
					689
					
				

			

		

		

			
				
实现基于静态数组的顺序表的以下基本操作: 
首先先定义一个结构体类型seqlist（ arr【】，size（有效的元素个数）），预定义一个数组的最大长度，将整型数据变量typedef为datatype，为了以后在插入删除别的类型时方便修改


初始化      void InitSeq(seqlist *s) 
将数组的size置为0，不需要给每个元素进行赋值，
尾插    void SeqLis...

			
		

	





	

		

			

				
					
表的数组实现

				
			

			

				

					Kinglliam的专栏
				

				

					05-04
					
					1883
					
				

			

		

		

			
				
将一个表存储到计算机中，可以采用许多不同的方法，其中既简单又自然的是顺序存储方法，即将表中的元素逐个存放于数组的一些连续的存储单元中。在这种表示方式下，容易实现对表的遍历。要在表的尾部插入一个新元素，也很容易。但是要在表的中间位置插入一个新元素，就必须先将其后面的所有元素都后移一个单元，才能腾出新元素所需的位置。执行删除运算的情形类似。如果被删除的元素不是表中最后一个元素，则必须将它后面的所有元素

			
		

	





	

		

			

				
					
数据结构 顺序表静态分配的代码实现

				
			

			

				

					clzZ2的博客
				

				

					02-20
					
					1073
					
				

			

		

		

			
				
#include <iostream>

using namespace std;

#define maxSize 64 // !定义最大长度

typedef struct
{
    int data[maxSize]; // !用静态的“数组”存放数据元素
    int length;        // !顺序表的长度
} SqList;              // !顺序表的类型定义

// !初始化顺序表
void initList(SqList &l)
{
    

			
		

	





	

		

			

				
					
王道考研数据结构代码解析：静态与动态顺序表实现

				
			

			

				

					
				

			

		

		

			
				
这里提到的代码是针对数据结构中的一个重要概念——顺序表的实现，用于教育和考试准备，尤其是计算机考研的复习。  顺序表是一种线性数据结构，其中元素在内存中按顺序存储，可以是静态或动态分配。下面我们将分别...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值