对顺序表的基本操作(增删查改),并编写makefile进行编

这篇具有很好参考价值的文章主要介绍了对顺序表的基本操作(增删查改),并编写makefile进行编。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1.定义顺序表结构体

2.创建顺序表

3.从尾部插入数据

4.遍历顺序表

5.从尾部删除数据

6.按下标插入数据

7.按下标删除数据

8.按下标修改数据

9.按下标查找数据

10.按数据修改数据

11..按数据查找位置

12.顺序表去重

        删除重复数据

        (提示:将先出现的数据与后面的数据对比,如果有重复的将后面的数据删除)

        提示:可以直接使用按位置删除的函数

        顺序表中原有:1 2 2 1 1 3 4 3 2 4 5 3 4 5 4 1

        ......

        顺序表中存储:1 2 3 4 5

SeqList.c

#include "./SeqList.h"                                      
#include <stdio.h>                                     
#include <stdlib.h>                                    
//创建顺序表                                           
SeqList* create_seqList()                              
{                                                      
                                                       
    SeqList *list = (SeqList*)malloc(sizeof(SeqList)); 
                                                       
    if(NULL == list)                                   
    {                                                  
        return NULL;                                   
    }                                                  
    list -> pos = 0;//初始化要操作的位置为0            
                                                       
                                                       
    return list;                                       
}                                                      
                                                       
//插入数据                                             
void insert_SeqList(SeqList* list,datatype num)        
{                                                      
    //判断顺序表是否为满                               
    if(list->pos >= N)                                 
    {                                                  
        printf("%d顺序表为满,插入失败!\n",num);        
        return;                                        
    }                                                  
                                                       
    list->data[list->pos] = num;                       
    (list->pos)++;                                     
    printf("%d插入成功!\n",num);                       
    return;                                            
}                                                        
                                                         
//遍历顺序表                                             
void show_SeqList(SeqList* list)                         
{                                                        
    for(int i=0;list->pos>i;i++)                         
    {                                                    
                                                         
        printf("%d ",list->data[i]);                     
                                                         
    }                                                    
    printf("\n");                                        
    return;                                              
}                                                        
                                                         
//从尾部删除                                             
                                                         
datatype del_SeqList(SeqList *list)                      
{                                                        
    int num;                                             
    if(0 == list->pos)                                   
    {                                                    
        printf("顺序表为空!\n");                         
        return 0;                                        
    }                                                    
    (list->pos)--;                                       
    num = list->data[list->pos];                         
                                                         
                                                         
    return num;                                          
}                                                                        
                                                                         
//按位插入                                                               
void insert_location_SeqList(SeqList* list,datatype index,datatype num)  
                                                                         
{                                                                        
    if(list->pos >= N)                                                   
    {                                                                    
        printf("顺序表为满,插入失败!\n");                                
        return;                                                          
    }                                                                    
    if(index<0 || index>list->pos)                                       
    {                                                                    
        printf("index=%d属于非法插入!\n",index);                         
        return;                                                          
    }                                                                    
    int i=0;                                                             
    for( i=list->pos;i>index;i--)                                        
    {                                                                    
        list->data[i] = list->data[i-1];                                 
    }                                                                    
    list->data[i] = num;                                                 
    (list->pos)++;                                                       
    printf("%d成功插入到下标为%d的位置!\n",num,index);                   
    return;                                                              
                                                                         
                                                                         
}                                                                        
//按位删除                                                               
datatype del_location_SeqList(SeqList* list,datatype index)              
{                                                                        
    int i;                                                               
    if(0 == list->pos)                                                   
    {                                                                    
        printf("顺序表为空!\n");                                         
        return 0;                                                        
    }                                                                    
                                                                         
    for( i=index;i<(list->pos)-1;i++)                                    
    {                                                                    
        list->data[i] = list->data[i+1];                                 
    }                                                                    
    (list->pos)--;                                                       
    printf("下标为%d的数据删除成功!\n",index);                           
    return index;                                                        
}                                                                        
//按位修改                                                                             
void rm_location_SeqList(SeqList* list,datatype index,datatype num)                    
{                                                                                      
    if(index<0 || index>list->pos)                                                     
    {                                                                                  
        printf("index=%d属于非法修改!\n",index);                                       
        return;                                                                        
    }                                                                                  
    list->data[index] = num;                                                           
    printf("下标为%d的数据修改成功!\n",index);                                         
                                                                                       
    return;                                                                            
                                                                                       
}                                                                                      
                                                                                       
//按位查找                                                                             
void find_location_SeqList(SeqList* list,datatype index)                               
{                                                                                      
    if(0 == list->pos)                                                                 
    {                                                                                  
        printf("顺序表为空!\n");                                                       
        return;                                                                        
    }                                                                                  
    printf("下标为%d是数据是%d\n",index,list->data[index]);                            
    return;                                                                            
                                                                                       
}                                                                                      
                                                                                       
//按数据修改                                                                           
void update_SeqList(SeqList* list,datatype oldNum,datatype newNum)                     
{                                                                                      
    int i=0;                                                                           
    for(i=0;i<list->pos;i++)                                                           
    {                                                                                  
        if(list->data[i] == oldNum)                                                    
        {                                                                              
            list->data[i] == newNum;                                                   
        }                                                                              
    }                                                                                  
    printf("数据修改完成!\n");                                                         
    return;                                                                            
}                                                                                      
                                                                                       
                                                                                       
                                                                                       
//按数据查找                                                                           
int select_SelqList(SeqList* list,datatype num)                                        
{                                                                                      
    int i=0;                                                                           
    for(i=0;i<list->pos;i++)                    
    {                                           
        if(list->data[i] == num)                
        {                                       
            return i;                           
        }                                       
    }                                           
    return -1;                                  
}                                               
                                                
                                                
//顺序表去重                                    
//1221134324534541                              
//12345                                         
void delrepeat_SeqList(SeqList* list)           
{                                               
    if(0 == list->pos)                          
    {                                           
        printf("顺序表为空!\n");                
        return ;                                
    }                                           
                                                
    int i,j;                                    
    for(i=0;i<(list->pos);i++)                  
    {                                           
        for(j=i+1;j<(list->pos);j++)            
        {                                       
            if(list->data[i] == list->data[j])  
            {                                   
                del_location_SeqList(list,j);   
                j--;                            
            }                                   
                                                
        }                                       
    }                                           
    printf("去重成功!\n");                      
                                                
    return;                                     
                                                
}                                               

mian.c

#include <stdio.h>
#include "./SeqList.h"
int main(int argc, const char *argv[])
{   
    SeqList * list = create_seqList();

 /*
  insert_SeqList(list,10);
    insert_SeqList(list,100);
    insert_SeqList(list,1000);
    insert_SeqList(list,10000);
    insert_SeqList(list,100000);
    
    show_SeqList(list);                              
    del_SeqList(list);
    show_SeqList(list);
    del_SeqList(list);
    show_SeqList(list);
    del_SeqList(list);
    show_SeqList(list);
    del_SeqList(list);
    show_SeqList(list);
    del_SeqList(list);
    show_SeqList(list);

    insert_location_SeqList(list,2,222);
    show_SeqList(list);

    del_location_SeqList(list,2);
    show_SeqList(list);

    rm_location_SeqList(list,2,222);
    show_SeqList(list);

    find_location_SeqList(list,2);
    
    update_SeqList(list, 11, 111);
    show_seqList(list); 

    int index = select_SelqList(list, 2222);
    printf("index=%d\n", index);

*/ 
    insert_SeqList(list,1);
    insert_SeqList(list,2);
    insert_SeqList(list,2);
    insert_SeqList(list,1);
    insert_SeqList(list,1);
    insert_SeqList(list,3);
    insert_SeqList(list,4);
    insert_SeqList(list,3);      
    insert_SeqList(list,2);      
    insert_SeqList(list,4);      
    insert_SeqList(list,5);      
    insert_SeqList(list,3);      
    insert_SeqList(list,4);      
    insert_SeqList(list,5);      
    insert_SeqList(list,4);      
    insert_SeqList(list,1);      
                                 
    delrepeat_SeqList(list);     
    show_SeqList(list);          
                                 
                                 
    return 0;                    
}                                

SeqList.h

#ifndef __01_H__                                                         
#define __01_H__                                                         
#define N 17 //顺序表容量                                                
typedef int datatype;                                                    
typedef struct                                                           
{                                                                        
    datatype data[N];                                                    
    int pos;                                                             
}SeqList;                                                                
                                                                         
SeqList* create_seqList();                                               
void insert_SeqList(SeqList* list,datatype num);                         
                                                                         
void show_SeqList(SeqList* list);                                        
datatype del_SeqList(SeqList *list);                                     
void insert_location_SeqList(SeqList* list,datatype index,datatype num); 
datatype del_location_SeqList(SeqList* list,datatype index);             
void rm_location_SeqList(SeqList* list,datatype index,datatype num);     
void find_location_SeqList(SeqList* list,datatype index);                
void update_SeqList(SeqList* list,datatype oldNum,datatype newNum);      
                                                                         
int select_SelqList(SeqList* list,datatype num);                         
                                                                         
void delrepeat_SeqList(SeqList* list);                                   
#endif                                                                   

makefile.cfg

Target:=a.out                   
obj:=SeqList.o main.o           
CAN:=-c -o                      
CC:=gcc

makefile文章来源地址https://www.toymoban.com/news/detail-828852.html

-include ./makefile.cfg
$(Target):$(obj)
    $(CC) $^ -o $@
%.o:%.c
    $(CC) $< $(CAN) $@
.PHONY:clean

clean:
    rm $(obj) $(Target)

到了这里,关于对顺序表的基本操作(增删查改),并编写makefile进行编的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 顺序表的基本操作

    目录 一.什么是顺序表 二.顺序表的基本操作   1.初始化 2.增容 3.尾插 4.头插 5.尾删 6.头删 7.指定位置插入 8.指定位置删除 9.打印 10.查找 11.销毁         顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据

    2024年01月20日
    浏览(38)
  • 【头歌】顺序表的基本操作

    任务描述 本关任务:编写顺序表的初始化、插入、遍历三个基本操作函数。 相关知识 顺序表的存储结构 顺序表的存储结构可以借助于高级程序设计语言中的数组来表示,一维数组的下标与元素在线性表中的序号相对应。线性表的顺序存储结构可用C语言中动态分配的一维数

    2024年04月08日
    浏览(64)
  • 数据结构入门(C语言)顺序表的增删查改

    本章会用C语言来描述数据结构中的顺序表,实现简单的增删查改操作,其中头文件包含在新建的头文件SeqList.h内,顺序表的实现在新建的Seqlist.c内,主函数Text.c将会实现菜单,方便我们进行功能的选择。 顺序表是用一段物理地址 连续 的存储单元依次存储数据元素的线性结构

    2024年02月03日
    浏览(38)
  • 【数据结构.C】顺序表和单链表的增删查改

    宝子,你不点个赞吗?不评个论吗?不收个藏吗? 最后的最后,关注我,关注我,关注我,你会看到更多有趣的博客哦!!! 喵喵喵,你对我真的很重要。 目录 单链表增删查改 c1.h sqlist.c number.c 单链表的增删查改  c1.h stuscore.c c1.h sqlist.c number.c  c1.h stuscore.c   宝子,你不点

    2024年02月11日
    浏览(91)
  • 【MySQL】基本查询(表的增删查改)

    CRUD : 四种操作 Create(创建), Retrieve(读取), Update(更新), Delete(删除) 创建一张学生表 查询展示 查询展示 由于 主键 或者 唯一键 对应的值已经存在而导致插入失败 可以选择性的进行同步更新操作 语法: 插入主键冲突把插入操作该为更新操作 创建一张表 全列查询 – 通常

    2024年02月15日
    浏览(32)
  • 顺序表的基本操作(初始化,增,删,查,改等等)

    1.线性表 线性表(linear list)是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构, 常见的线性表:顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的, 线性

    2024年02月03日
    浏览(29)
  • 数据结构实验---顺序表的合并---链表的基本操作---重点解析约瑟夫问题

    实验的写法多种多样,但本文并未采用 #define 定义容量的写法,这样写已经是很老旧过时的写法。所有实验主体采用均为动态开辟,后续如果利用 C++ 来写或许会应用更多语法… 本篇展示数据结构的两个实验 其中,重点分析约瑟夫问题 实验中代码的命名风格等均与下方博客

    2024年02月16日
    浏览(49)
  • 数据结构 线性表的定义和基本操作(以顺序表为例)

    名人说:一花独放不是春,百花齐放花满园。——《增广贤文》 作者:Code_流苏(CSDN) (一个喜欢古诗词和编程的Coder😊) 以下代码个人分享出来,仅供学习交流,且仅在CSDN平台发布,未经授权禁止二次转发。 〇、线性表是什么? 1、定义 线性表 是具有 相同数据类型 的 n(

    2024年02月12日
    浏览(40)
  • 线性表的基本操作及在顺序存储及链式存储的实现

    一个数据结构的基本操作是指其最核心、最基本的操作。其他较复杂的操作可通过其基本操作来实现。线性表的主要操作如下 注意:1:基本操作的实现取决于采用哪种存储结构,存储结构不同,算法的实现也不同 2:“” 表示c++中的引用调用。若存入的变量是指针变量,且

    2024年02月13日
    浏览(32)
  • 【数据结构】顺序表的实现及基本操作完整代码(C语言实现)

    顺序表:逻辑上相邻的数据元素,其物理次序也是相邻的 这里之所以要把int分别创建新名字为SqlElemType和Status,是因为实际应用时数据的类型不一定是int型,这样设置方便修改元素类型,提高代码适用性。 LocateElem的时间复杂度为O(n) InsertSq的时间复杂度为O(n) DeleteSq的时间

    2024年04月12日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包