可扩容的线性表

最新推荐文章于 2024-10-08 20:32:22 发布
最新推荐文章于 2024-10-08 20:32:22 发布
阅读量49 收藏
点赞数 1
文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75473409/article/details/134276005
版权 
dsqlist.cpp



#define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<stdlib.h>
#include"dsqlist.h"
#include<assert.h>
#include<stdlib.h>

#define INIT_SIZE 10
//初始化
void  InitSqlist(DSQList ps) {
    assert(ps != NULL);
    if (ps == NULL) {
        return;
    }
    ps->elem = (int*)malloc(INIT_SIZE * sizeof(int));
    ps->length = 0;
    ps->lengthsize = INIT_SIZE;
}

//判满
static bool IsFull(DSQList ps)
{
    return ps->length == ps->lengthsize;
}

//扩容
static bool Inc(DSQList ps) {
    ps->elem= (int*)realloc(ps->elem, (INIT_SIZE*2) * sizeof(int));
    assert(ps != NULL);
    ps->lengthsize *= 2;
    return true;
}

//插入数据,在顺序表ps的pos位置插入val;
bool Insert(DSQList ps, int pos, int val) {
    assert(ps != NULL);
    if (ps == NULL) {
        return false;
    }
    if (pos < 0 || ps->length < pos) {
        return false;
    }
    if (IsFull(ps)) {
        Inc(ps);
    }
    for (int i = ps->length - 1; i >= pos; i--) {
        ps->elem[i + 1] = ps->elem[i];
    }
    ps->elem[pos] = val;
    ps->length++;

    return true;

}
//判空
bool IsEmpty(DSQList ps)
{
    return ps->length == 0;
}

//在ps中查找第一个key值,找到返回下标,没有找到返回-1
int  Search(DSQList ps, int key) {
    assert(ps != NULL);
    if (ps == NULL) {
        return false;
    }
    for (int i = 0; i < ps->length; i++) {
        if (key == ps->elem[i]) {
            return i;
        }
    }
    return -1;
}

//删除pos位置的值
bool  DelPos(DSQList ps, int pos) {
    assert(ps != NULL);
    if (ps == NULL) {
        return false;
    }
    if (pos < 0 || ps->length < pos) {
        return false;
    }
    for (int i = pos; i <= ps->length - 1; i++) {
        ps->elem[i] = ps->elem[i + 1];
    }
    ps->length--;
    return true;
}

//删除第一个val的值
bool  DelVal(DSQList ps, int val) {
    assert(ps != NULL);
    if (ps == NULL) {
        return false;
    }
    /*for (int i = 0; i <= ps->length - 1; i++) {
        if (val == ps->elem[i]) {
            ps->elem[i] = ps->elem[i + 1];
            break;
        }
        ps->length--;
    }*/
    int i = Search(ps, val);
    if (i <= 0) {
        return false;
    }
    return DelPos(ps, i);

}

//返回key的前驱下标,如果不存在返回-1
int  GetPrio(DSQList ps, int key) {
    /*assert(ps != NULL);
    if (ps == NULL) {
        return false;
    }
    for (int i = 0; i < ps->length; i++) {
        if (key == ps->elem[i]) {
            return i - 1;
        }
        if (i > ps->length - 1) {
            return -1;
        }
    }*/
    int i = Search(ps, key);
    if (i <= 0)
        return -1;
    return i - 1;
}

//返回key的后继下标,如果不存在返回-1
int  GetNext(DSQList ps, int key) {
    /*assert(ps != NULL);
    if (ps == NULL) {
        return false;
    }
    for (int i = 0; i < ps->length - 1; i++) {
        if (key == ps->elem[i]) {
            return i + 1;
        }
        if (i > ps->length - 1) {
            return -1;
        }
    }*/
    int i = Search(ps, key);
    if (i == ps->length - 1 || i < 0)
        return -1;
    return i + 1;
}

//返回线性表的长度
int Getlength(DSQList ps) {
    return ps->length;
}
//输出
void  Show(DSQList ps) {
    assert(ps != NULL);
    if (ps == NULL) {
        return ;
    }
    for (int i = 0; i < ps->length; i++) {
        printf("%d ", ps->elem[i]);
    }
    printf("\n");
}

//清空数据
void  Clear(DSQList ps) {
    ps->length = 0;
}

//销毁整个内存
void  Destroy(DSQList ps) {
    free(ps->elem);
    ps->elem = NULL;
    ps->length = 0;
    ps->lengthsize = 0;
    ps = NULL;//无用 error
}

//比较顺序表大小
int comparelist(SQList list1, SQList list2) {

    if (list1.length > list2.length) {
        return 1;
    }
    else if (list1.length < list2.length) {
        return -1;
    }

    for (int i = 0; i < list1.length; i++) {
        if (list1.elem[i] > list2.elem[i]) {
            return 1;
        }
        else if (list1.elem[i] < list2.elem[i]) {
            return -1;
        }
    }
    return 0;
}

//顺序表的逆置
int reverse(DSQList ps) {
    int i = 0;
    int j = ps->length - 1;
    while (i < j) {
        int tmp = ps->elem[i];
        ps->elem[i] = ps->elem[j];
        ps->elem[j] = tmp;
        i++;
        j--;
    }
    return 1;
}


//插入元素后顺序表依然有序
void insert_num(DSQList ps,int x) {
    for (int i = 0; i < 25; i++) {
        if (x < ps->elem[i]) {
            Insert(ps, i, x);
            break;
        }
    }
}








dsqlist.h



#pragma once
#pragma once
#include<stdlib.h>
//预防头文件被重复引用

//定长顺序表
//定义与声明

typedef struct  SQList
{
    int* elem;//存放数据,固定长度为10;
    int length;//有效数据的个数
    int lengthsize;//总长度
}SQList, * DSQList;


//初始化
void  InitSqlist(DSQList ps);

//插入数据,在顺序表ps的pos位置插入val;
bool Insert(DSQList ps, int pos, int val);

//判满
static bool IsFull(DSQList ps);


//扩容
static bool Inc(DSQList ps);

//判空
bool  IsEmpty(DSQList ps);

//在ps中查找第一个key值,找到返回下标,没有找到返回-1
int  Search(DSQList ps, int key);

//删除pos位置的值
bool  DelPos(DSQList ps, int pos);

//删除第一个val的值
bool  DelVal(DSQList ps, int val);

//返回key的前驱下标,如果不存在返回-1
int  GetPrio(DSQList ps, int key);

//返回key的后继下标,如果不存在返回-1
int  GetNext(DSQList ps, int key);

//返回线性表地长度
int Getlength(DSQList ps);

//输出
void  Show(DSQList ps);

//清空数据
void  Clear(DSQList ps);

//销毁整个内存
void  Destroy(DSQList ps);

//比较顺序表大小
int comparelist(SQList list1, SQList list2);

//顺序表的逆置
int reverse(DSQList ps);


//插入元素后顺序表依然有序
void insert_num(DSQList ps, int x);









test.cpp



#define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<stdlib.h>
#include"dsqlist.h"
int main() {
    SQList dsq;
    InitSqlist(&dsq);
    for (int i = 0; i < 25; i++)
    {
        Insert(&dsq, i, i);
    }
    Show(&dsq);
    printf("长度为：%d", Getlength(&dsq));
    printf("\n");

    printf("判断线性表是否为空(1表示空，0表示不为空)\n");
    printf("%d\n", IsEmpty(&dsq));
    printf("\n");

    printf("请输入要查找的数：\n");
    int key1;
    scanf("%d", &key1);
    if (key1 == Search(&dsq, key1)) {
        printf("已找到，要查找的值为：%d\n", Search(&dsq, key1));
    }
    else {
        printf("未能查找到该数\n");
    }
    printf("\n");


    printf("请输入需要返回前驱和后继的值：\n");
    int key;
    scanf("%d", &key);
    int x = GetPrio(&dsq, key);
    int y = GetNext(&dsq, key);
    printf("%d的前驱是：%d\n", key, x);
    printf("%d的后继是：%d\n", key, y);
    printf("\n");

    printf("请输入要删除的位置\n");
    int val;
    scanf("%d", &val);
    DelPos(&dsq, val);
    printf("删除后链表为：\n");
    Show(&dsq);
    printf("\n");


    printf("请输入要删除的第一个数字\n");
    int key2;
    scanf("%d", &key2);
    DelVal(&dsq, key2);
    printf("删除后链表为：\n");
    Show(&dsq);
    printf("\n");


    printf("插入元素后依然有序\n");
    int num = 4;
    insert_num(&dsq, num);
    printf("插入%d后顺序表为：\n", num);
    Show(&dsq);


    SQList list1;
    InitSqlist(&list1);
    Insert(&list1, 0, 1);
    Insert(&list1, 1, 2);
    Insert(&list1, 2, 3);
    printf("list1：");
    Show(&list1);
    SQList list2;
    InitSqlist(&list2);
    Insert(&list2, 0, 1);
    Insert(&list2, 1, 2);
    Insert(&list2, 2, 4);
    printf("list2：");
    Show(&list2);
    comparelist(list1, list2);
    if (comparelist(list1, list2) == 1) {
        printf("list1 > list2\n");
    }else if (comparelist(list1, list2) == -1) {
        printf("list1 < list2\n");
    }
    else {
        printf("list1 = list2\n");
    }


    reverse(&dsq);
    printf("逆置后顺序为：\n");
    Show(&dsq);

    //清空数据
    //Clear(&dsq);

    //销毁整个内存
    //Destroy(&dsq);


}

kk three
关注
Java实现:数组实现可扩容线性表
Xrj_int的博客
03-30 183
/* 数组实现可扩容线性表 */ class MyArrayListTest { public static void main(String[] args) { MyArrayList<String> arrayList = new MyArrayList<>(3); arrayList.add("a"); arrayList.add("b"); arrayList.add("c"); arr
可扩容的线性表的C++实现
weixin_45189666的博客
05-12 690
文章目录头文件：线性表的定义和包含的成员函数部分函数实现逻辑扩容ListExpansion(int )缩容ListShrinkage()有参构造函数CreateList(ElemType, int)初始化函数InitList( )获取某个元素第一次出现的位置LocateElem(ElemType)插入一个元素ListInsert(int , ElemType )删除一个元素ListDelete(int, ElemType&)批量添加ListInsertAll(int, ElemType*,int )
线性表的建立（输入+扩容+遍历）
weixin_67578693的博客
10-31 328
#include <iostream> #include <stdio.h> #include <stdlib.h> using namespace std; #define InitSize 10 typedef struct { int *data; int length; int maxsize; }SqList; void InitList(SqList &L) { L.length = 0; L.data = (i
创建线性表增删扩容并测试
HAN&BLOG
10-16 188
既然线性结构可以由顺序存储结构和链式存储结构实现，那么将两者对线性结构共同的操作进行抽取，定义出线性结构的接口。不能使用==，原因是要比较两个对象的内容是相等，且不能让传入的参数和已存在的比较，如果传入的参数是空的，就会发生空指针异常。缩容：当有效元素达到数组的1/4，且数组的长度大于10，才可以缩容，且缩到原来的1/4。让i从index+1开始，将i的值赋给i-1，i要小于size，size--底层既可以用数组实现，也可以用链表实现，都是增删改查，具体的实现方法不同。清空，新建一个数组，令size=0。
线性表主函数+扩容
m0_51418215的博客
11-06 448
线性表主函数 #include<stdio.h> #include<string.h> #include<time.h> #include<stdlib.h> typedef struct vector { int* data; int size; int len; }Vec; int insert(Vec *v,int idx,int val) { if (!v) return 0; if (idx<0||id
线性表-顺序表动态扩容
lujiangui的专栏
09-22 239
public class App { public static void main( String[] args ){ //扩容 SequenceList<String> list = new SequenceList<>(3); System.out.println(list.capacity()); list.insert("aaa"); list.insert("bbb"); .
数组的扩容
shuai_xue_dai的博客
05-13 5356
数组的扩容我这里给出了三种的扩容方式： 主要运用了两种数组的特性： （1）址传递 （2）寻址算法：数组名为首地址可得到一个公式 下一个数据的地址数： 首地址+数组类型所占字节数*下标 1.基础方式： 1）先创建一个更大的数组 2）将原数组中的数据放置到新数组中 3）原数组赋值给新数组 例子： package class...
Java中数组的扩容
m0_72014660的博客
08-11 419
Java中数组的扩容
线性表：顺序表的实现以及遍历扩容
weixin_33418394的博客
09-03 36
Java学习手册+面试指南：https://javaxiaobear.cn顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻...
数据结构与算法-线性表
ProgrammersFighting的博客
10-01 587
实现与C++模板库中vector相似的功能【增,删,查,改】,同时能存储任意类型的数据。
用Java动态数组扩充实现线性表
07-02
2. **扩容机制**：当线性表的元素数量达到当前数组容量时，需要进行扩容操作。通常的做法是创建一个新的、容量更大的数组，然后将旧数组中的元素复制到新数组中。新容量的选择通常是旧容量的某个倍数，例如1.5倍或2...
数构java线性表扩容
09-17
线性表的扩容在Java中通常使用数组的扩容来实现。在Java中，可以使用Arrays类的copyOf方法来实现数组的扩容。具体步骤如下： 1. 创建一个新的数组，长度是原数组的两倍。 2. 使用Arrays类的copyOf方法，将原数组中的...
vector的扩容机制—为何是1.5倍或者是2倍【通俗易懂】
weixin_44545838的博客
09-22 1576
在 C++ 编程中，Vector 是一种常用的动态数组容器。其大小是可以动态调整的，而在扩容操作中，Vector 通常会将容量增加为原来的两倍。本篇博客将详细介绍 Vector 扩容的原理、扩容过程，并解释为何选择两倍进行扩容。如果新空间大小为旧空间大小+1，也就是边插入边扩容，这样每一次插入都要进行拷贝，时间复杂度为O(n)，效率非常低下。如果新空间大小为旧空间大小+k，其中k是一个固定的增量，那么在每次扩容时，新空间的大小会增加k个单位。
C语言实现可增加长度的线性表（示例实现交并补差）
m0_57945153的博客
10-24 3166
总所周知，C语言的数组是不可增加长度的，这就导致很多时候不能采取随机存储结构数组。这时很多人想到了链表，我们可以申请空间存放数据然后插入表中，确实可行，但是随机存储结构的优点可以在“O(1)”的时间内存就不存在了，得到的是一个可以很方便插入删除的链表。 但这时问题就来了，如果我并不需要频繁的做插入删除操作呢？链表的缺点是需要一个指针指向下一个节点，这浪费了很多的空间。 上图是顺序存储结构示意图，可以很容易得到，存放n个数据需要n*存放数据的数据类型...
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 747
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 851
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 804
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
生成哈夫曼树
最新发布
TTz012的博客
10-08 117
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1239
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值