C语言数据结构一：线性表之顺序表的实现

最新推荐文章于 2021-11-11 15:43:21 发布
最新推荐文章于 2021-11-11 15:43:21 发布
阅读量220 收藏 1
点赞数
分类专栏： C 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36250578/article/details/107991421
版权

seqlish.h：头文件

#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#define SEQLIST_INIT_SIZE 8
#define INC 3
typedef int ElemType;

typedef struct SeqList{
    ElemType *base;
    int capacity;
    int size;
}SeqList;

void InitSeqList(SeqList *list);
void push_back(SeqList *list,ElemType x);
void push_front(SeqList *list,ElemType x);
void show_list(SeqList *list);
void pop_back(SeqList *list);
void pop_front(SeqList *list);
void insert_pos(SeqList *list,int pos,ElemType x);
int find(SeqList *list,ElemType x);
int length(SeqList *list);
void delete_pos(SeqList *list,int pos);
void delete_val(SeqList *list,ElemType val);
void clean(SeqList *list);
void destory(SeqList *list);
void sortMP(SeqList *list);
void resver(SeqList *list);
int inc(SeqList *list);

 

seqlist.c：顺序表具体实现

#include "seqlist.h"

int inc(SeqList *list){
    ElemType *newbase = (ElemType *)realloc(list->base,sizeof(ElemType)*(SEQLIST_INIT_SIZE+INC));
    if(newbase == NULL){
        printf("分配内存空间失败，内存不足\n");
        return 0;
    }
    list->base = newbase;
    list->capacity += INC;
    return 1;
}

void InitSeqList(SeqList *list){
    //开辟空间
    list->base = (ElemType *)malloc(sizeof(ElemType)*SEQLIST_INIT_SIZE);
    assert(list->base!=NULL);
    //大小初始化
    list->capacity = SEQLIST_INIT_SIZE;
    list->size = 0;
}

void push_back(SeqList *list,ElemType x){
    //判满
    if(list->size >= list->capacity && !inc(list)){
        printf("顺序表空间已经满了\n");
        return;
    }
    //插入数据
    list->base[list->size]=x;
    //长度增加
    list->size++;
}

void push_front(SeqList *list,ElemType x){
    //if 满
    if(list->size >=list->capacity && !inc(list)){
        printf("顺序表空间已经满了\n");
        return;
    }
    //移动后面的元素
    for(int i=list->size;i>0;--i){
        list->base[i]=list->base[i-1];
    }
    //首位插入数据
    list->base[0]=x;
    list->size++;
}

void show_list(SeqList *list){
    for(int i=0;i<list->size;++i){
        printf("%d ",list->base[i]);
    }
    printf("\n"); 
}

void pop_back(SeqList *list){
    //判空
    if(list->size == 0){
        printf("当前为空\n");
        return;
    }
    
    printf("取出最后一个元素为：%d\n",list->base[list->size-1]);
    list->size--;
}

void pop_front(SeqList *list){ 
    //判空
    if(list->size == 0){
        printf("当前为空\n");
        return;
    }
    
    printf("取出第一个元素为：%d\n",list->base[0]);
    //移动元素
    for(int i=list->size-1;i>0;i--){
        list->base[i-1]=list->base[i];
    }

    list->size--;
}
void insert_pos(SeqList *list,int pos,ElemType x){
    //判断插入位置合法性
    if(pos>list->size||pos<0){
        printf("输入不合法\n");
    }
    if(list->size >=list->capacity && !inc(list)){
        printf("顺序表空间已经满了\n");
        return;
    }
    if(pos == 0){
        push_front(list,x);
    }else if(pos == list->size){
        push_back(list,x);
    }else{
        for(int i=list->size;i>pos;i--){
            list->base[i]=list->base[i-1];
        }
        list->base[pos]=x;
        list->size++;
    }
    
}
int find(SeqList *list,ElemType x){
    for(int i=0;i<list->size;i++){
        if(list->base[i]==x){
            printf("当前查找数在顺序表的的下标为%d，在第%d位\n",i,i+1);
            return i;
        }   
    }
    
    printf("查找结束，未找到对应的数据\n");
    return -1;
}
int length(SeqList *list){
    return list->size;
}
void delete_pos(SeqList *list,int pos){
    if(pos>list->size||pos<0){
        printf("输入不合法\n");
    }
    for(int i=pos;i<list->size-1;i++){
        list->base[i]=list->base[i+1];
    }
    list->size--;
}
void delete_val(SeqList *list,ElemType x){
    int pos = find(list,x);
    if(pos != -1){
        delete_pos(list,pos);
    }
}
void clean(SeqList *list){
    list->size = 0;
}
void destory(SeqList *list){
    free(list->base);
    list->base = NULL;
    list->capacity = 0;
    list->size = 0;
}

void sortMP(SeqList *list){
    //冒泡排序思想：
    //多次遍历，两两比对，大后小前
    //这个是比较的躺数，一共n个数，比较n-1躺 。
    for(int i =0;i<list->size-1;i++){
        //每一趟的比较次数，随着躺数增加，大的到了后面，比较次数减少，后面的不比
        //一次比较，少比1次，n次比较，少比n次
        for(int j = 0;j<list->size-i-1;j++){
            if(list->base[j]>list->base[j+1]){
                ElemType temp = list->base[j];
                list->base[j]=list->base[j+1];
                list->base[j+1]=temp;
            }
        }  
    }
}
void resver(SeqList *list){
    if(list->size==0||list->size ==1) return;
    int low = 0;
    int high = list->size-1;
    while(low<high){
        ElemType temp = list->base[low];
        list->base[low] = list->base[high];
        list->base[high] = temp;
        low++;
        high--;
    }
}

 

main.c ：主函数

#include "seqlist.h"

int main(){
    SeqList mylist;
    InitSeqList(&mylist);
    ElemType x;
    int pos;
    int select = 1;
    while(select){
        printf("*********************************\n");
        printf("请输入您需要的顺序表操作\n");
        printf("*   1.尾部插入     2.头部插入\n");
        printf("*   3.顺序表展示   4.尾部取一个\n");
        printf("*   5.头部取一个   6.插入在指定位置\n");
        printf("*   7.查找         8.长度\n");
        printf("*   9.按位删除     10.按值删除\n");
        printf("*   11.排序        12.反置\n");
        printf("*   13.清空        14.销毁\n");
        printf("    0.退出\n");
        printf("*********************************\n");
        printf("请选择：\n");    
        scanf("%d",&select);
        if(select == 0) break;
        
        switch(select){
            case 1:
                printf("请输入您的数据(输入-1结束)\n");
                //逗号表达式，输出以最后为准
                while(scanf("%d",&x),x != -1){
                    push_back(&mylist,x);
                }
                break;
            case 2:
                printf("请输入您的数据,系统会按顺序做头部插入（输入-1结束）\n");
                while(scanf("%d",&x),x != -1){
                    push_front(&mylist,x);
                }
                break;
            case 3:
                show_list(&mylist); 
                break;
            case 4:
                pop_back(&mylist);
                break;
            case 5:
                pop_front(&mylist);
                break;
            case 6:
                printf("请输入插入的数据\n");
                scanf("%d",&x);
                printf("请输入插入的位置\n");
                scanf("%d",&pos);
                insert_pos(&mylist,pos,x);
                break;
            case 7:
                printf("请输入查找的数据\n");
                scanf("%d",&x);

                find(&mylist,x);
                break;
            case 8:
                printf("当前顺序表长度为%d\n",length(&mylist));
                break;
            case 9:
                printf("请输入删除的顺序表下标\n");

                scanf("%d",&pos);

                delete_pos(&mylist,pos);
                show_list(&mylist); 
                break;
            case 10:
                printf("请输入删除的顺序表元素\n");

                scanf("%d",&x);
                
                delete_val(&mylist,x);
                show_list(&mylist); 
                break;
            case 11:
                sortMP(&mylist);
                show_list(&mylist);
                break;
            case 12:
                resver(&mylist);
                show_list(&mylist);
                break;
            case 13:
                clean(&mylist);
                break;
            case 14:
                destory(&mylist);
                select = 0;
                break;
            default:
                printf("输入错误\n");
                break;
        }
    }
    destory(&mylist);
}

makefile

main.out:seqlist.o main.c
	gcc seqlist.o main.c
seqlist.o:seqlist.c
	gcc -c seqlist.c

 

JUVETUS
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言顺序表详解
e1419573074的博客
02-06 722
顺序表顺序表是什么？顺序表代码构思创建文件创建结构体初始化尾插内存扩容尾删打印头插头删任意位置插入任意位置删除解释的不好，最后献上完整代码头文件 SeqList.h 代码源文件 SeqList.c 代码源文件 test.c 代码 顺序表是什么？ 顺序表是在计算机内存中以数组的形式保存的线性表，线性表是最基本、最简单、最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系。 顺序表代码构思 创建文件 首先创建3个文件分别是一个头文件和二个源文件 创建结构体 在头文件 SeqLIst.h 里面写 创建
顺序表的基本操作
罗小黑の窝
04-22 681
进入数据结构首先接触到的就是线性结构，而顺序表是典型的线性结构。在此我们一起来实现关于顺序表的一些基本操作。 int begin();             //开始位置 int end(SeqList *list);  //结束位置 void InitSeqList(SeqList *list);//初始化 bool isempty(SeqList *list);//判断是否为空 b
数据结构顺序表（C语言实现）
Sveinn的博客
04-14 391
数据结构顺序表（C语言实现） 头文件和函数申明 #include <stdio.h> #include <malloc.h> #include <stdlib.h> typedef struct Arr //定义了一个数据类型，该数据类型的名字叫做struct Arr,该数据类型含有三个成员PBase,len,cnt { int *pBase;//储存的是数组...
C语言实现定长顺序表
weixin_43823473的博客
04-10 190
线性表的顺序表示指的是用一组地址连续的存储单元一次存储线性表的数据元素，其中顺序表中所有存储的数据元素都是从data的0号下标连续的。 这里我们要实现的，便是定长顺序表。 首先我们先定义顺序表的结构： struct SeqList { ElemType data[SIZE]; Int length; }; 其中SIZE是我选择用宏，因为是定长顺序表，没必要创造一个新变量。 我们要实现的基本...
C语言实现顺序表
lu_1079776757的博客
04-24 178
SeqList.h #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;assert.h&gt; #include&lt;memory.h&gt; typedef int DataType; //顺序表的元素类型 #define N ...
数据结构2-线性表之顺序储存（顺序表）C语言版
10-21
代码对应的博客：https://blog.csdn.net/u011017694/article/details/109196934
【数据结构实现】C语言实现顺序表
03-06
内容概要：线性表是一种相当灵活的数据结构，其长度可以根据需要增长或缩短，对线性表的数据元素不仅可以进行访问，还可以进行插入和删除等操作。本次试验用C语言实现顺序表，实现 Init 初始化线性表 Destory 销毁...
C语言_线性表之顺序表
01-16
C语言实现顺序表，代码约200行，附赠测试案例(带菜单选择功能) 实现的操作： 1，头插、尾插、指定位置插 2，头删、尾删、指定位置和元素删除 3，求大小、判断是否为NULL 4，排序、查找、翻转
用C语言实现数据结构中的线性表
11-15
本人在学习数据结构时使用的是严蔚敏的《数据结构》，并根据课本内容完成了这个头文件，这个头文件把课本中的线性表的顺序表的表示和实现都囊括在内了。部分实现中也做了相应的优化处理。由于一次性只能发一个文件，...
数据结构+顺序表的C语言实现
最新发布
04-24
本工程实现了严蔚敏 《数据结构 C语言》中顺序表的实现以及常用的操作。包括顺序表的初始化、销毁、求表长、查找、查询前驱节点、查询后继节点、插入、删除、遍历、打印等功能。并且写了测试代码，对每个函数都做了...
顺序表的实现（包含插入，删除，及查找）
lzm420241的专栏
04-21 940
#include       #define MAX 1000      int isfull(int n);//judge if the list is full or not      void insert(int *p,int len,int i,int elem);//*p represent the first element'id of list,i represent w
求帮助修改程序，实现顺序表的功能
qq_41922317的博客
03-29 366
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#define SIZE 100typedef int DataType;typedef struct{DataType items[SIZE];int length;}SqList;int InitList(SqList *L);int ListLength(SqList L);int ListEm...
C语言顺序表的几种实现
踏踏实实
06-09 309
#include #include #include using namespace std; typedef int DataType; #define DEFAULT_INC 9 #define DEFAULT_CAPACITY 7 class SeqList { public: friend ostream& operator<<(ostream& os, const SeqList&
顺序表——单链表基础
m0_55993923的博客
11-11 668
头文件： #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct node { ElemType data; struct node* next; }SLinkNode; //初始化单链表 void InitList(SLinkNode*& L) { L = (SLinkNode*)malloc(sizeof(SLinkNode)); L-> next = NU.
实验一：数据结构顺序表的建立
记录软件测试过程中遇到的问题
09-24 9756
实验一 线性表的基本操作实现及其应用 一、实验目的 1、熟练掌握线性表的结构特点，掌握顺序表的基本操作。 2、巩固 C++相关的程序设计方法与技术。 3、学会使用顺序表解决实际问题。 二、实验内容 1、顺序表的建立与操作实现 建立 n 个元素的顺序表（n 的大小和表里数据自己确定）。 2、实现相关的操作：输出，插入，删除，查找等功能。 3、编写完整程
数据结构顺序表实验
linxibo's CSDN
09-19 1749
顺序表实验
数据结构习题——1顺序表的插入运算
momochen的博客
08-29 3596
description 已知顺序表L递增有序，编写程序，将X插入到线性表的适当位置上，以保持线性表的有序性。 input 第一行输入顺序表元素个数elenum；(0&lt;elenum&lt;1000) 第二行输入顺序表L； 第三行输入插入值X。 output 输出插入...
线性表的顺序实现
Tiramisu_zyp的博客
09-16 356
#include #include #define LIST_INIT_SIZE 50 #define LIST_ADD_SIZE 10 #define OK 1 #define OVERFLOW -1 #define ERROR -1 #define NOTFOUND -1 typedef int elemtype; struct seqlist{ elemtype *
c语言关于使用链表排序（选择排序、冒泡排序）
热门推荐
Vectory0213的博客
01-26 3万+
链表冒泡排序 比较两个相邻的元素大小，每一趟会把较大（或较小）的数放在往后移。链表冒泡排序思想：设置两个指针，一个是当前指针，一个是尾指针，当前的指针指向头节点，将尾指针赋为空，当当前的指针不等于尾指针是一次循环，第一次将当前一个节点的值与下一个节点的值相比较，直到下一个节点和尾指针相等（即为空），结束本次循环，最后当前的指针赋给尾指针，当前指针重新指向头结点，再两两相比较，把最大（或最小）的数
c语言数据结构实现对顺序表的操作
09-16
顺序表是一种线性表的存储结构，元素在内存中连续存储。 首先，你需要定义顺序表的结构体和相关的操作函数。下面是一个示例代码： ```c #include #include #define MAX_SIZE 100 typedef struct { int data...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值