顺序表-数据结构(C语言)(一)

已于 2022-05-19 16:36:47 修改
阅读量1.2k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++
于 2022-05-06 16:36:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44681349/article/details/124609660
版权

顺序表

顺序表的构造

#include <stdio.h>
#include <stdlib.h>

typedef struct Vector {
	//  size 表示当前表中的最大容量 
	// length 表示当前顺序表中的元素的个数
    int size, length;
    // 定义一个int 类型的指针data , 用来指向存储元素的数组 
    int *data;
} Vector;
// 初始化函数  void init (Vector *vector ,int size)  表示构造一个容量为size 的顺序表
void init(Vector *vector, int size) {
	// 先把顺序表的容量vector->size 的值设为size;
	// 并把当前顺便表的元素个数 vector->lenght 设为0 
    vector->size = size;
    vector->length=0;
    // 将指向存储元素值的空间的指针初始化，让data 指向一段连续size 个 int 的空间。 
    vector->data = (int *)malloc(sizeof(int)  *size);
}


// 在函数结束前我们要释放占用的内存空间 ，否则会发生内存泄露
// 在 clear 函数中使用free 释放vector->data  以及指针vector指向的内存空间。
void clear(Vector *vector) {
    free(vector->data);
    free(vector);
}

int main() {
    Vector *a = (Vector *)malloc(sizeof(Vector));
    init(a, 100);
    clear(a);
    return 0;
}
顺序表的插入
#include <stdio.h>
#include <stdlib.h>

#define ERROR 0
#define OK 1

typedef struct Vector {
    int size, length;
    int *data;
} Vector;

void init(Vector *vector, int size) {
    vector->size = size;
    vector->length = 0;
    vector->data = (int *)malloc(sizeof(int) * size);
}
//  插入函数已经定义好了， 有三个参数 vector、loc  和 value , 其中vector 指针表示茶树元素的顺序表， loc 表示将要插入的位置， value 表示插入的元素值。
// 也就意味着，在插入完成后 $data_loc$的值为value. 当插入到第i个位置后，需要将data loc 后面的所有元素向后顺次移动，并将顺序表的总长度增加 1 ， 如果插入成功，则返回 OK, 否则返回ERROR , 我们已将将OK ， 定义为 1 ，将ERROR 定义为0 了。
//  首先我们需要判断要插入的位置是否合法。记当前顺序表的长度len 为 vector->length , 那么当前 data0 到 datalen -1  都存储着元素，所以0 到 len 都是可以插入的位置。
//  如果传入的参数 loc 比 0 小， 或者 len 大， 那么直接返回ERROR 。

//  除了判断loc 是否合法， 我们还需要判断顺序表当前元素的个数是否已经达到容量的上限 。
//  如果已经达到了上限 ，也就是说 顺序表中数量 vector->length 大于等于 顺序表的容量 vector->size  那么就和上一步的操作一样，直接返回ERROR. 
int insert(Vector *vector, int loc, int value) {
    if(loc < 0 || loc > vector->length) {
      return  ERROR;
    }
    if(vector->length >= vector->size) {
        return ERROR;
    }
    // 在顺序表中，每次向指定位置 loc 插入一个元素之前，都要将loc 之后的所有元素顺次向后移动，从而给新的元素腾出一个空间。
    // 令循环变量 i  从 vector->length  循环到不大于 loc 退出， 将 vector->data[i-1] 的赋值给 vector->data[i].
    for(int i = vector->length; i > loc; --i) {
        vector->data[i] = vector->data[i-1];
        
    }
    // 将插入的元素值 value 赋值 给 vector->data[loc].
    vector->data[loc] = value;
    //  还需要将 顺序表中元素个数加 1 ，以便后续中的各种判断
    vector->length++;
    // 返回OK 
    return OK;
}

void clear(Vector *vector) {
    free(vector->data);
    free(vector);
}

int main() {
    Vector *a = (Vector *)malloc(sizeof(Vector));
    init(a, 100);
    printf("%d\n", insert(a, 1, 0));
    printf("%d\n", insert(a, 0, 1));
    printf("%d\n", insert(a, 2, 1));
    printf("%d\n", insert(a, 1, 2));
    printf("%d\n", insert(a, 0, 3));
    clear(a);
    return 0;
}
顺序表的扩容
#include <stdio.h>
#include <stdlib.h>

#define ERROR 0
#define OK 1

typedef struct Vector {
    int size, length;
    int *data;
} Vector;

void init(Vector *vector, int size) {
    vector->size = size;
    vector->length = 0;
    vector->data = (int *)malloc(sizeof(int) * size);
}

// 请在下面实现扩容函数 expand
//  通常来讲， 每次扩容都是将容量修改为之前的两倍。 扩容时，要重新开辟一块空间，将原有的数据依次拷贝过去，再将原来的空间释放。
//   扩容函数的参数为 Vector 类型的指针变量 vector , 表示要处理的顺序表 函数没有返回值 。
// 首先 定义一个指向int 的指针 old_data， 并赋值为当前 vector->data  指向的空间地址。 
//  下面我们要 将 容量 vector->size  更新为原来的2 倍， 并借助 malloc 开辟一段 新容量大小的连续空间，vector->data  指向它的首地址。 
//  令循环变量 i 从  循环到不小于 vector->length 时退出，并将 old_data[i] 的值 复制到 vector->data[i] 里。 即使for  循环中只有一条语句， 也要记得加上大括号 。
//  在扩容函数最后 把旧的空间进行回收。 
// 我们把 insert 函数里判断是否达 容量上限里面的 return ERROR，  注释掉 
//  在刚刚注释的代码下面调用 扩容操作 。

void expand(Vector *vector) {
    int *old_data = vector->data; 
    vector->size = vector->size * 2;
    vector->data = (int *)malloc(sizeof(int) * vector->size); 
    // vector->data 
    for(int i = 0; i < vector->length; ++i) {
        vector->data[i] = old_data[i]; 
    }
    free(old_data);
    
        
}

int insert(Vector *vector, int loc, int value) {
    if (loc < 0 || loc > vector->length) {
         return ERROR;
    }
    if (vector->length >= vector->size) {
        // return ERROR;
        expand(vector);
    }
    for (int i = vector->length; i > loc; --i) {
        vector->data[i] = vector->data[i - 1];
    }
    vector->data[loc] = value;
    vector->length++;
    return OK;
}

void clear(Vector *vector) {
    free(vector->data);
    free(vector);
}

int main() {
    Vector *a = (Vector *)malloc(sizeof(Vector));
    init(a, 100);
    printf("%d\n", insert(a, 1, 0));
    printf("%d\n", insert(a, 0, 1));
    printf("%d\n", insert(a, 2, 1));
    printf("%d\n", insert(a, 1, 2));
    printf("%d\n", insert(a, 0, 3));
    clear(a);
    return 0;
}
顺序表的查找
#include <stdio.h>
#include <stdlib.h>

#define ERROR 0
#define OK 1

typedef struct Vector {
    int size, length;
    int *data;
} Vector;

void init(Vector *vector, int size) {
    vector->size = size;
    vector->length = 0;
    vector->data = (int *)malloc(sizeof(int) * size);
}

void expand(Vector *vector) {
    int *old_data = vector->data;
    vector->size = vector->size * 2;
    vector->data = (int *)malloc(sizeof(int) * vector->size);
    for (int i = 0; i < vector->length; ++i) {
        vector->data[i] = old_data[i];
    }
    free(old_data);
}

int insert(Vector *vector, int loc, int value) {
    if (loc < 0 || loc > vector->length) {
        return ERROR;
    }
    if (vector->length >= vector->size) {
        //return ERROR;
        expand(vector);
    }
    for (int i = vector->length; i > loc; --i) {
        vector->data[i] = vector->data[i - 1];
    }
    vector->data[loc] = value;
    vector->length++;
    return OK;
}
// 我们使用最朴素的查找算法，依次枚举所有顺序表中元素，判断元素的值是否和传入的参数 value 相等， 如果相等则直接返回对应的下标即可。
//  用 for 循环进行枚举，令循环变量i 从 0  循环到不小于 vector->length 时退出， 
// 在循环内部，对枚举的每一个下标i, 如果对应的vector->data[i] 和 value 的值相等， 那么直接返回下标i 的 值。  
int search(Vector *vector, int value) {
    for(int i = 0; i < vector->length; ++i) {
        if(vector->data[i] == value) {
            return i;
        }
        
    }
    //  如果在顺序表中没有找到和 value 的值相等的元素,直接返回 -1. 
    // 在主函数中调用 search() 
    return -1;
}

void clear(Vector *vector) {
    free(vector->data);
    free(vector);
}

int main() {
    Vector *a = (Vector *)malloc(sizeof(Vector));
    init(a, 100);
    printf("%d\n", insert(a, 1, 0));
    printf("%d\n", insert(a, 0, 1));
    printf("%d\n", insert(a, 2, 1));
    printf("%d\n", insert(a, 1, 2));
    printf("%d\n", insert(a, 0, 3));
    printf("%d\n", search(a, 1));
    printf("%d\n", search(a, 4));
    clear(a);
    return 0;
}
顺序表的删除

顺序表的删除操作
顺序表的删除操作是指, 将顺序表中第i 个位置（0 < i < len ） 的元素从顺序表中删除，并将该元素之后的所有元素顺次向前移动一个位置，len 表示顺序表元素个数。
delete_nod 函数已经定义好了, 除了 Vector 类型的指针参数 vector , 还有一个参数 index ， 表示已经删除测下标 , 返回值为int 类型， 表示是否删除成功。

首先对传入参数的合法性进行判断， 如果传入的下标比0 小， 或者大于等于len , 那么直接返回 ERROR .

#include <stdio.h>
#include <stdlib.h>

#define ERROR 0
#define OK 1

typedef struct Vector {
    int size, length;
    int *data;
} Vector;

void init(Vector *vector, int size) {
    vector->size = size;
    vector->length = 0;
    vector->data = (int *)malloc(sizeof(int) * size);
}

void expand(Vector *vector) {
    int *old_data = vector->data;
    vector->size = vector->size * 2;
    vector->data = (int *)malloc(sizeof(int) * vector->size);
    for (int i = 0; i < vector->length; ++i) {
        vector->data[i] = old_data[i];
    }
    free(old_data);
}

int insert(Vector *vector, int loc, int value) {
    if (loc < 0 || loc > vector->length) {
        return ERROR;
    }
    if (vector->length >= vector->size) {
        //return ERROR;
        expand(vector);
    }
    for (int i = vector->length; i > loc; --i) {
        vector->data[i] = vector->data[i - 1];
    }
    vector->data[loc] = value;
    vector->length++;
    return OK;
}

int search(Vector *vector, int value) {
    for (int i = 0; i < vector->length; ++i) {
        if (vector->data[i] == value) {
            return i;
        }
    }
    return -1;
}

int delete_node(Vector *vector, int index) {
    if (index < 0 || index >= vector->length) {
         return ERROR;
    }
    // 接下来 , 需要将index  后面的所有元素顺次向前移动， 令循环变量 i  从 index + 1  循环不小于 vector->length 时退出，将vector->data[i] 的值赋给 vactor->data[i-1]. 
    
    for(int i = index + 1;  i <  vector->length; ++i) {
          vector->data[i-1] = vector->data[i];
    }
    // 顺序表中实际上 剩下 vector->length - 1 个 元素了，接下来在delete_node 函数中将 vector->length 更新。 
    // 将 OK 作为 delete_node 函数的返回值返回。
    
    vector->length--;
    return OK;
}

void clear(Vector *vector) {
    free(vector->data);
    free(vector);
}

int main() {
    Vector *a = (Vector *)malloc(sizeof(Vector));
    init(a, 100);
    printf("%d\n", insert(a, 0, 1));
    printf("%d\n", insert(a, 0, 2));
    printf("%d\n", delete_node(a, 1));
    printf("%d\n", search(a, 0));
    printf("%d\n", search(a, 1));
    clear(a);
    return 0;
}
顺序表的遍历
#include <stdio.h>
#include <stdlib.h>

#define ERROR 0
#define OK 1

typedef struct Vector {
    int size, length;
    int *data;
} Vector;

void init(Vector *vector, int size) {
    vector->size = size;
    vector->length = 0;
    vector->data = (int *)malloc(sizeof(int) * size);
}

void expand(Vector *vector) {
    int *old_data = vector->data;
    vector->size = vector->size * 2;
    vector->data = (int *)malloc(sizeof(int) * vector->size);
    for (int i = 0; i < vector->length; ++i) {
        vector->data[i] = old_data[i];
    }
    free(old_data);
}

int insert(Vector *vector, int loc, int value) {
    if (loc < 0 || loc > vector->length) {
        return ERROR;
    }
    if (vector->length >= vector->size) {
        //return ERROR;
        expand(vector);
    }
    for (int i = vector->length; i > loc; --i) {
        vector->data[i] = vector->data[i - 1];
    }
    vector->data[loc] = value;
    vector->length++;
    return OK;
}

int search(Vector *vector, int value) {
    for (int i = 0; i < vector->length; ++i) {
        if (vector->data[i] == value) {
            return i;
        }
    }
    return -1;
}

int delete_node(Vector *vector, int index) {
    if (index < 0 || index >= vector->length) {
        return ERROR;
    }
    for (int i = index + 1; i < vector->length; ++i) {
        vector->data[i - 1] = vector->data[i];
    }
    vector->length = vector->length - 1;
    return OK;
}
// 顺序表的遍历操作，是指将顺序表中 的所有元素顺次输出。 我们将会把顺序表的所有元素输出到一行中，并用空格分隔。Vector 的遍历函数 print  已经定义好了， 
//  我们在 print  函数中写好的输出所有元素的循环体， 令循环变量 i 从 0 循环到不小于vector->length 时退出，并协商一对 大括号。
//  在循环内部，我们先把输出的每个元素之间的空格输出.  如果不是在行首，也就是说，i 大于0  那么就输出一个空格， 使用 printf 输出。
// 输出完空格之后， 把当前第i个 元素也输出。 
//  输出完所有元素之后， 再输出一个空行。 

void print(Vector *vector) {
    for (int i = 0; i < vector->length; ++i) {
        if(i > 0) {
            printf(" ");
        }
        printf("%d",vector->data[i]);
    }
    printf("\n");
    
}

void clear(Vector *vector) {
    free(vector->data);
    free(vector);
}

int main() {
    Vector *a = (Vector *)malloc(sizeof(Vector));
    init(a, 100);
    printf("%d\n", insert(a, 0, 1));
    printf("%d\n", insert(a, 0, 2));
    print(a);
    printf("%d\n", delete_node(a, 1));
    print(a);
    printf("%d\n", search(a, 0));
    printf("%d\n", search(a, 1));
    clear(a);
    return 0;
}
java_prinln
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之顺序表（C语言）
梦路遥
01-31 458
目录 一、顺序表的定义 二、顺序表的特征 三、顺序表的操作 四、顺序表的优点和缺点 一、顺序表的定义 在顺序存储方式下，线性表中的数据元素按照逻辑顺序依次存储在一组连续的存储单元中。用顺序存储结构存储的线性表简称为顺序表。 二、顺序表的特征 1. 数据存储在一段连续的内存。 2. 数据的存储顺序和逻辑顺序相同。 3. 根据数据元素编号能够计算出它的存储地址。 三、顺序表的操作 这里通过一个例子来说明顺序表的操作。 需求：用顺序表存储一...
数据结构顺序表（C语言）
qq_46692427的博客
06-17 98
1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并且退出运行。 #include<stdio.h> #include<stdlib.h> int Del_MinEle(int* arr,int len) { if (len == 0) { printf("数组为空"); return 0; } int min = *arr, minpos = 0;//min为第一个元素的值，minpo
数据结构-顺序表（C语言实现）
qq_45767476的博客
04-26 921
主函数代码（main.c） #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include "sqlist.h" int main() { sqlist *list= NULL,*list_next= NULL; int pos = 0; int i, err, value; int arr[10] = { 10,20,30,40,50,60,70,80,90,100 }; int arr_next[10] = { 11,2
【数据结构】顺序表基本操作
℉f的博客
04-08 1383
顺序表基本操作
C中的函数功能介绍以及顺序表的书写
qq_43643506的博客
01-04 733
typedefine：函数执行的时候，进行符号的转换。 define：只做简单的替换，预处理 区别： 预处理：展开文件，对预处理的命令替换。 如何定义一个函数指针：先定义指针，*p，括号起来。再在 指针：存放地址的。存放内部值要加* sizeof：数组占的空间，8个 ，字符串占8个字节 strlen：字符占的空间，7，字符串占7个字节，不加\0，所以少一个字节。 顺序表的书写思路：首先...
数据结构（C语言）：有序顺序表的设计及相关操作函数
lbcbjtlhmjq的博客
05-24 2066
有序顺序表的操作，包括初始化，求数据元素个数，插入，删除和取数据元素。放在头文件中（建议尝试用动态数组实现有序顺序表）；注意有序顺序表的操作与课本上的操作有所不同，需要重写一些操作，如ListInsert(L,x)，不需要参数i）； 设计合并函数ListMerge（L1,L2,L3），其功能是把有序表L1和L2中的数据合并到L3中，要求L3中的数据依然保持有序。(要求时间复杂度O(n), n= n1+n2，n1、n2分别为两个顺序表的长度)；
C语言顺序表及其实现
ygy555的博客
07-29 653
顺序表
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
数据结构C语言-顺序表PPT课件.ppt
12-27
数据结构C语言顺序表知识点 根据提供的PPT课件，以下是相关的知识点： 1. 线性表的逻辑结构 * 线性表是由n（n≥0）个类型相同的数据元素组成的有限序列。 * 线性表的逻辑结构可以用以下形式表示：L=(a1, a2,...,...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构-C语言描述（顺序表、链表）
04-01
### 数据结构-C语言描述（顺序表、链表） #### 实验背景 本次实验的主要目的是让学生通过C语言实现顺序表和链表的相关操作，加深对这两种基本数据结构的理解，并掌握其在实际编程中的应用技巧。 #### 实验目的 1...
有序顺序表的设计与实现
qq_43510083的博客
05-12 5035
1、有序顺序表的设计（osqlist.h）：设计头文件osqlist.h，其内容如下： ①类型设计 ②基本操作的设计（包括初始化、插入、删除、索引、遍历等） 2、设计文件c.h，提供比较和遍历时的操作函数及有序表的有序规则（递增还是递减） 3、测试：设计测试文件application.cpp文件，验证所设计的有序顺序表的正确性。其内容如下： 设计一个主函数。 1、osqlist.h文件 #include "c.h" #include <stdlib.h> #define LISTSIZE 20
顺序表C语言实现
陈桃桃的博客
01-24 183
函数接口 bool IsFull(SeqList *pst); bool IsEmpty(SeqList *pst); void SeqListInit(SeqList *pst); void SeqListPushBack(SeqList *pst, ElemType x); void SeqListPushFront(SeqList *pst, ElemType x); void SeqListShow(SeqList *pst); void SeqListPopBack(SeqList *pst);
数据结构学习之栈
m0_54765221的博客
08-30 825
栈 顺序存储（单向 双向） 链表存储（单向 ）
数据结构：顺序表及其函数的实现
Prosperity_c的博客
01-29 2371
数据结构：顺序表及其函数的实现 本文顺序表采用动态数组的方法来进行初始化。主要实现了以下一些功能。 函数功能： void InitList(Sqlist &L); 初始化表。构造一个空的线性表 void IncreaseSize(Sqlist &L, int len);//增加动态数组长度 void DestroyList(Sqlist &L);//销毁操作。销毁L并释放L所占用的内存空间 int GetLength(Sqlist L);//求表长；即L中数据元素的个数 int L
c语言数据结构的主函数怎么写,数据结构算法前面的头文件该如何写?主函数该如何写?...
weixin_39618456的博客
05-20 2174
一、头文件头文件一般包含类、子程序、变量和其他标识符的前置声明。需要在一个以上源文件中被声明的标识符可以被放在一个头文件中，并在需要的地方包含这个头文件。头文件用于让编译器持有正确的标识符词典。头文件不正确的时候，最常出现的错误是“标识符未定义”(identifier undefined)。要修正这些问题，事实上应该去查询你所使用的标识符(函数、变量等)的文档。以VC为代表的Windows系列的I...
数据结构与算法：顺序表和链表的常用操作 （很全，基本涵盖本章所有算法）
Specif1c的博客
06-23 2233
前言： 数据结构中的表操作算是里面较为简单的章节，但也比较重要，3月份学完的此章节，左思右想今天还是写篇 关于顺序表和链表的博客。 ps ： 复制代码可以在编译器上直接运行。 一、顺序表 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 #define N 100 typedef int SLDataTyp
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 389
【代码】c语言（7.23）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值