day1补充：数据结构&算法之顺序表

已于 2022-07-09 11:26:36 修改
阅读量260 收藏
点赞数 1
文章标签： 数据结构
于 2022-07-05 23:18:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjjaibc/article/details/125630084
版权

目录

一、基本概念以及相关思路、注意点

        1.注意细节：

        2.核心模块：增 删 改 查

                ①增加（两种方法）：

                ②删除(伪删除)

                ③查找：由data获取并返回data的index

二、C语言实现顺序表

sqlist.h

 sqlist.c

 Main顺序表.c

三、C++实现顺序表 

sqlist.h

sqlist.cpp

Main顺序表.cpp 

一、基本概念以及相关思路、注意点

        1.注意细节：

                顺序表：取值时，优先判断是否为NULL，增加时要看是否满了(链表就无需担心)

                        null 、curSize、MaxSize

        2.核心模块：增 删 改 查

                ①增加（两种方法）：

                        法一：直接把数据丢到末尾，然后依次swap至index指定位置

                        法二：现平移出位置，然后对空位进行赋值

                优化：提供push_front()和push_back()两种接口

                对于有序表：

                                step1：先将data插入到表的最后面，

                                step2：再依次和前面进行比较，找到比其小的位置(注意边界问题：不能越界&&记得不管是增还是删除，及时更新curSize!!!)

                ②删除(向前移动覆盖->伪删除)

                                ->真正的删除在curSize--

                 优化：提供pop_front()和pop_back()两种接口

                ③查找：由data获取并返回data的index

二、C语言实现顺序表

sqlist.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define MAX 10		//最大元素个数
typedef int DataType;
//结构体抽象---> 抽象长相
enum INFO {OK=1,ERROR=-1};
typedef struct 
{
	DataType* dataMemory;			//一级指针动态内存申请变成一位数组
	int maxSize;					//最大元素个数-->容量
	int curSize;					//当前元素个数
}Sqlist,*LPSqlist;

LPSqlist	createSqlist(int maxSize);	
//万金油函数-->所有数据结构都可以有的
int			size(LPSqlist sqlist);
int			empty(LPSqlist sqlist);
//增删改查
DataType	getData(LPSqlist sqlist, int index);
int			insertSqlist(LPSqlist sqlist, int index, DataType data);
void		printSqlist(LPSqlist sqlist);
int			deleteSqlist(LPSqlist sqlist, int index);
void		push_front(LPSqlist sqlist,DataType data);    //头部插入
void		pop_front(LPSqlist sqlist);
void		push_back(LPSqlist sqlist, DataType data);
void		pop_back(LPSqlist sqlist);
int			searchSqlist(LPSqlist sqlist, DataType data);
void		insert_sort(LPSqlist sqlist, DataType data);
void		destroySqlist(LPSqlist* sqlist);

 sqlist.c

#include "sqlist.h"
LPSqlist createSqlist(int maxSize)
{
    //创建过程，就是初始化数据
    LPSqlist sqlist = (LPSqlist)malloc(sizeof(Sqlist));
    assert(sqlist);
    sqlist->curSize = 0;
    sqlist->maxSize = maxSize;
    //指针变成一个数组
    sqlist->dataMemory = (DataType*)malloc(sizeof(DataType)*maxSize);
    assert(sqlist->dataMemory);
    return sqlist;
}
int size(LPSqlist sqlist)
{
    if (sqlist == NULL)
        return ERROR;
    return sqlist->curSize;
}
int empty(LPSqlist sqlist)
{
    if (sqlist == NULL)
        return ERROR;
    return sqlist->curSize==0;
}

DataType getData(LPSqlist sqlist, int index)
{
    if (sqlist == NULL||sqlist->curSize==0) 
    {
        printf("sqlist is empty,unable to get......\n");
        return ERROR;
    }
    if ( sqlist->curSize < index) 
    {
        //invalid 无效
        printf("index is invalid,unable to get......\n");
        return ERROR;
    }
    //index是第几个元素
    return sqlist->dataMemory[index-1];
}

int insertSqlist(LPSqlist sqlist, int index, DataType data)
{
    //数组实现的数据结构：放进去需要考虑满
    if (sqlist == NULL) 
    {
        printf("sqlist is empty,unable to insert......\n");
        return ERROR;
    }
    if (sqlist->curSize == sqlist->maxSize) 
    {
        printf("sqlist is full,unbale to insert......\n");
        return ERROR;
    }
    if (index == 0) 
    {
        sqlist->dataMemory[sqlist->curSize++] = data;
        return OK;
    }
    if (sqlist->curSize < 1 || sqlist->curSize < index) 
    {
        printf("index is invalid,unable to insert......\n");
        return ERROR;
    }
#if 0
    int pos = sqlist->curSize;
    sqlist->dataMemory[pos] = data;     //插在最后面
    while (pos != index) 
    {
        DataType temp = sqlist->dataMemory[pos];
        sqlist->dataMemory[pos] = sqlist->dataMemory[pos - 1];
        sqlist->dataMemory[pos - 1] = temp;
        pos--;
    }
    sqlist->curSize++;
#endif
    for (int k = sqlist->curSize; k >= index; k--) 
    {
        sqlist->dataMemory[k] = sqlist->dataMemory[k - 1];
    }
    sqlist->dataMemory[index - 1] = data;
    sqlist->curSize++;
    return OK;
}

void printSqlist(LPSqlist sqlist)
{
    if (sqlist == NULL||sqlist->curSize==0)
    {
        printf("sqlist is empty,unable to print......\n");
        return;
    }
    for (int i = 0; i < sqlist->curSize; i++) 
    {
        printf("%d\t", sqlist->dataMemory[i]);
    }
    printf("\n");
}
int deleteSqlist(LPSqlist sqlist, int index)
{
    if (sqlist == NULL || sqlist->curSize == 0) 
    {
        printf("sqlist is empty,unable to delete......\n");
        return ERROR;
    }
    if (sqlist->curSize < index) 
    {
        printf("index is invalid,unbale to delete......\n");
        return ERROR;
    }
    for (int k = index - 1; k < sqlist->curSize; k++) 
    {
        sqlist->dataMemory[k] = sqlist->dataMemory[k + 1];
    }
    sqlist->curSize--;              //伪删除
    return OK;
}
void push_front(LPSqlist sqlist, DataType data)
{
    insertSqlist(sqlist, 1, data);
}
void pop_front(LPSqlist sqlist)
{
    deleteSqlist(sqlist, 1);
}
void push_back(LPSqlist sqlist, DataType data)
{
    if (sqlist == NULL)
    {
        printf("sqlist is empty,unable to pushback");
        return;
    }
    if (sqlist->curSize == sqlist->maxSize) 
    {
        printf("sqlist is full,unable to pushback");
        return;
    }
    sqlist->dataMemory[sqlist->curSize++] = data;
}
void pop_back(LPSqlist sqlist)
{
    deleteSqlist(sqlist, sqlist->curSize);
}
int searchSqlist(LPSqlist sqlist, DataType data)
{
    if (sqlist == NULL) 
    {
        printf("sqlist is empty,unable to search......\n");
        return ERROR;
    }
    for (int i = 0; i < sqlist->curSize; i++) 
    {
        if (sqlist->dataMemory[i] == data) 
        {
            return i;
        }
    }
    return ERROR;
}
void insert_sort(LPSqlist sqlist, DataType data)
{
    if (sqlist == NULL) 
    {
        printf("sqlist is empty,unable to insert......\n");
        return;
    }
    if (sqlist->curSize == sqlist->maxSize) 
    {
        printf("sqlist is full,unable to insert......\n");
        return;
    }
    if (sqlist->curSize == 0)
    {
        sqlist->dataMemory[sqlist->curSize++] = data;
    }
    sqlist->dataMemory[sqlist->curSize] = data;
    int pos = sqlist->curSize;
    for (int k = sqlist->curSize;k>0; k--)
    {
        if (sqlist->dataMemory[k] < sqlist->dataMemory[k - 1])
        {
            DataType temp = sqlist->dataMemory[k];
            sqlist->dataMemory[k] = sqlist->dataMemory[k - 1];
            sqlist->dataMemory[k - 1] = temp;
        }
        else 
        {
            break;
        }
    }
    sqlist->curSize++;
}

void destroySqlist(LPSqlist* sqlist)
{
    if (*sqlist == NULL) 
    {
        printf("sqlist is empty, unable to destory......\n");
        return;
    }
    free((*sqlist)->dataMemory);
    free(*sqlist);
    *sqlist = NULL;
}

 Main顺序表.c

#include "sqlist.h"
int main() 
{
	LPSqlist sqlist = createSqlist(MAX);
	printf("test insert:\n");
	insertSqlist(sqlist, 0, 0);  //0
	insertSqlist(sqlist, 1, 1);  //1 0
	insertSqlist(sqlist, 1, 2);  //2 1 0
	insertSqlist(sqlist, 1, 3);  //3 2 1 0
	insertSqlist(sqlist, 4, 444);
	printSqlist(sqlist);
	printf("test delete:\n");
	deleteSqlist(sqlist, 4);
	printSqlist(sqlist);
	printf("test push and pop:\n");
	push_front(sqlist, 666);
	push_back(sqlist, 999);
	printSqlist(sqlist);
	pop_front(sqlist);
	pop_back(sqlist);
	printSqlist(sqlist);
	int pos = searchSqlist(sqlist, 3);
	printf("pos:%d\n", pos);	
	destroySqlist(&sqlist);
	LPSqlist sortSqlist = createSqlist(MAX);
	insert_sort(sortSqlist, 1);
	insert_sort(sortSqlist, 100);
	insert_sort(sortSqlist, 77);
	insert_sort(sortSqlist, -1);
	printSqlist(sortSqlist);
	destroySqlist(&sortSqlist);
	return 0;
}

 输出：

test insert:
3       2       1       444     0
test delete:
3       2       1       0
test push and pop:
666     3       2       1       0       999
3       2       1       0
pos:0
-1      1       1       77      100

三、C++实现顺序表 

sqlist.h

#pragma once
#pragma once
#include <iostream>
using namespace std;
#define MAX 10		//最大元素个数
typedef int DataType;
//结构体抽象---> 抽象长相
enum INFO { OK = 1, ERROR = -1 };
class Sqlist 
{
public:
	Sqlist(int MaxSize);
	int			size() const;
	int			empty()const;
	DataType	getData(int index);
	int			insertSqlist(int index, DataType data);
	void		printSqlist();
	int			deleteSqlist( int index);
	void		push_front( DataType data);    //头部插入
	void		pop_front();
	void		push_back(DataType data);
	void		pop_back();
	int			searchSqlist( DataType data);
	void		insert_sort(DataType data);
	void		destroySqlist();
protected:
	DataType* dataMemory;			
	int maxSize;					
	int curSize;				
};

sqlist.cpp

#include "sqlist.h"

Sqlist::Sqlist(int MaxSize)
{
    //创建过程，就是初始化数据
    curSize = 0;
    maxSize = MaxSize;
    //指针变成一个数组
    dataMemory =new DataType[maxSize];
}

int Sqlist::size() const
{
    if (dataMemory == NULL)
        return ERROR;
    return curSize;
}

int Sqlist::empty() const
{
    if (dataMemory == NULL)
        return ERROR;
    return curSize==0;
}

DataType Sqlist::getData(int index)
{
    if (curSize == 0)
    {
        cout<<"sqlist is empty,unable to get......"<<endl;
        return ERROR;
    }
    if (curSize < index)
    {
        //invalid 无效
        cout << "index is invalid,unable to get......" << endl;;
        return ERROR;
    }
    //index是第几个元素
    return dataMemory[index - 1];
}

int Sqlist::insertSqlist(int index, DataType data)
{
    //数组实现的数据结构：放进去需要考虑满
    if (curSize == maxSize)
    {
        printf("sqlist is full,unbale to insert......\n");
        return ERROR;
    }
    if (index == 0)
    {
        dataMemory[curSize++] = data;
        return OK;
    }
    if (curSize < 1 || curSize < index)
    {
        printf("index is invalid,unable to insert......\n");
        return ERROR;
    }
#if 0
    int pos = sqlist->curSize;
    dataMemory[pos] = data;     //插在最后面
    while (pos != index)
    {
        DataType temp = dataMemory[pos];
        dataMemory[pos] = dataMemory[pos - 1];
        dataMemory[pos - 1] = temp;
        pos--;
    }
    curSize++;
#endif
    for (int k = curSize; k >= index; k--)
    {
        dataMemory[k] = dataMemory[k - 1];
    }
    dataMemory[index - 1] = data;
    curSize++;
    return OK;
}

void Sqlist::printSqlist()
{
    if (curSize == 0)
    {
        cout << "sqlist is empty,unable to print......\n" << endl;
        return;
    }
    for (int i = 0; i < curSize; i++)
    {
        printf("%d\t", dataMemory[i]);
    }
    printf("\n");
}

int Sqlist::deleteSqlist(int index)
{
    if (curSize == 0)
    {
        cout<<"sqlist is empty,unable to delete......\n";
        return ERROR;
    }
    if (curSize < index)
    {
        cout<<"index is invalid,unbale to delete......\n";
        return ERROR;
    }
    for (int k = index - 1; k < curSize; k++)
    {
        dataMemory[k] = dataMemory[k + 1];
    }
    curSize--;              //伪删除
    return OK;
}

void Sqlist::push_front(DataType data)
{
    insertSqlist(1, data);
}

void Sqlist::pop_front()
{
    deleteSqlist(1);
}

void Sqlist::push_back(DataType data)
{
    if (curSize == maxSize)
    {
        printf("sqlist is full,unable to pushback");
        return;
    }
    dataMemory[curSize++] = data;
}

void Sqlist::pop_back()
{
    deleteSqlist(curSize);
}

int Sqlist::searchSqlist(DataType data)
{
    for (int i = 0; i < curSize; i++)
    {
        if (dataMemory[i] == data)
        {
            return i;
        }
    }
    return ERROR;
}

void Sqlist::insert_sort(DataType data)
{
    if (curSize ==maxSize)
    {
        cout<<"sqlist is full,unable to insert......\n";
        return;
    }
    if (curSize == 0)
    {
       dataMemory[curSize++] = data;
    }
    dataMemory[curSize] = data;
    int pos = curSize;
    for (int k = curSize; k > 0; k--)
    {
        if (dataMemory[k] < dataMemory[k - 1])
        {
            DataType temp = dataMemory[k];
            dataMemory[k] = dataMemory[k - 1];
            dataMemory[k - 1] = temp;
        }
        else
        {
            break;
        }
    }
    curSize++;
}

void Sqlist::destroySqlist()
{
    delete [] dataMemory;
    dataMemory = nullptr;
}

Main顺序表.cpp 

#include "sqlist.h"
int main()
{
	Sqlist *pSqlist=new Sqlist(MAX);
	printf("test insert:\n");
	pSqlist->insertSqlist( 0, 0);  //0
	pSqlist->insertSqlist( 1, 1);  //1 0
	pSqlist->insertSqlist( 1, 2);  //2 1 0
	pSqlist->insertSqlist( 1, 3);  //3 2 1 0
	pSqlist->insertSqlist( 4, 444);
	pSqlist->printSqlist();
	printf("test delete:\n");
	pSqlist->deleteSqlist( 4);
	pSqlist->printSqlist();
	printf("test push and pop:\n");
	pSqlist->push_front(666);
	pSqlist->push_back(999);
	pSqlist->printSqlist();
	pSqlist->pop_front();
	pSqlist->pop_back();
	pSqlist->printSqlist();
	int pos = pSqlist->searchSqlist(3);
	printf("pos:%d\n", pos);
	pSqlist->destroySqlist();
	delete pSqlist;
	pSqlist = nullptr;
	Sqlist sortSqlist(10);
	sortSqlist.insert_sort(1);
	sortSqlist.insert_sort(100);
	sortSqlist.insert_sort(77);
	sortSqlist.insert_sort(-1);
	sortSqlist.printSqlist();
	sortSqlist.destroySqlist();
	return 0;
}

_Ocean__
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
176-C++重要知识点7
weixin_45964837的博客
01-28 412
1.C++中的切片问题 class Object { int value; public: Object(int x = 0):value(x) {} }; class Base : public Object { int num; public: Base(int x = 0):Object(x + 10),num(x) {} }; int main() { Object obja; Base base(10); return 0; } 切片问题是继承关系，必须是公有继承，只有把子对象赋给
数据结构_day05_排序算法
12-21
排序算法排序排序算法的稳定性冒泡排序冒泡排序的分析代码体现冒泡排序的时间复杂度选择排序选择排序分析代码体现选择排序的时间复杂度插入排序插入排序的分析代码演示希尔排序希尔排序的分析希尔排序的代码演示希尔排序的时间复杂度快速排序(重点掌握)快速排序分析快速排序代码体现时间复杂度归并排序归并算法的分析归并算法的代码体现归并排序的时间复杂度二分查找二分查找程序分析二分查找代码时间复杂度 排序 排序算法(Sorting algorithm) 是一种能将一串数据依照特定顺序进行排列的一种算法。 排序算法的稳定性 稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有
数据结构_day01_算法引入
12-21
算法引入数据结构和算法Python版算法的提出补充:最坏时间复杂度:Python内置类型性能分析数据结构概念概念算法和数据结构的区别 数据结构和算法Python版 算法的提出 我们最终写好运行的程序比作战场，我们是将军，Python是士兵和兵器，数据结构和算法则是兵法。 引入: 第一次尝试 如果 a+b+c = 1000 且a的平方+b的平方等于c的平方(abc都是自然数)，如何求出a、b、c可能的组合? # 枚举法 # a # b # c import time a1 = time.time() for a in range(0,1001): # 进行嵌套 for b in rang
Day4div1数据结构1
08-03
前言树相比于一般的图有着很特殊的性质，是一种非常重要的数据结构，现在让我们看看算法竞赛中常用的对树的处理技巧。Newnode (清清清华华华大大大学学学)数数数
数据结构与算法学习——基础知识（一）
JavaKobeBryant的技术交流
11-09 577
数据结构与算法线性结构和非线性结构线性结构基本概念非线性结构基本概念 线性结构和非线性结构 数据结构主要包括线性结构和非线性结构。 线性结构基本概念 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的(地址是连续的)。 链式存储的线性表称为链表，链表中得存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息 线性结构常见的有：数据、队列、链
定长顺序表
DW___的博客
10-09 172
顺序表的存储结构 可以构造一个定长的数组elem来存放数据，然后定义变量cursize来存放有效数据的个数，即有效长度。 顺序表的代码实现 SeqList.h #define ARRAY_SIZE 10 typedef int ELEM_TYPE; typedef struct Seqlist { ELEM_TYPE elem[ARRAY_SIZE]; int cursize; }S...
C语言一维数组
qq_59969777的博客
03-13 1371
文章目录 第一章 认识数组 第二章 一维数组常规操作 第三章 字符数组和字符串 第四章 字符串处理函数 前言 在C语言中， 数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。 一、数组是什么？ 数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，...
C++ || 浅拷贝 深拷贝
LQEmptycity的博客
08-22 328
文章目录浅拷贝 深拷贝 浅拷贝 深拷贝 //防止浅拷贝 if (NULL != src._name) { //判空 _name = new char[strlen(src._name) + 1]; memset(_name, 0, strlen(src._name) + 1); for (int i = 0; i < strlen(src._name); i++) { _name[i] = src._name[i]; } } else
c指针笔记
ouyangfang19920313的博客
10-26 164
2017-10-26 1.int  *a:指的是定义一个指向int类型数据的指针a,即：这是一个名叫a的指针，这个指针指向的是int类型。
第三周项目一（2）—顺序表的基本运算
liu_wenping54的博客
09-14 182
*Copyright (c)2017,烟台大学计算机与控制工程学院 *All rights reservrd. *作者：刘文平 *完成时间：2017年9月14日 *版本号：v1.0 *问题描述:在已经创建线性表的基础上，求线性表的长度ListLength、求线性表L中指定位置的某个数据元素GetElem、查找元素LocateElem的算法都可以实现了
57春节7天练---Day-1：数组和链表 数组和链表.pdf
04-18
57春节7天练---Day-1：数组和链表 数组和链表.pdf
12.20 day1 数据结构
12-20
12.20 day1 数据结构
线性表的基本概念
OR的博客
08-04 2万+
一、线性表的定义线性表：零个或多个数据元素的有限序列。几个关键的地方。 首先它是一个序列。也就是说，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都只有一个前驱和后继。然后，线性表强调是有限的。事实上，在计算机中处理的对象都是有限的，那种无限的数列，只存在于数学的概念中。如果用数学语言来定义。可如下： 若将线性表记为(a1，…，ai-1，ai，ai+1，
【C语言_动态内存管理详解】
Sugar_wolf的博客
01-26 1509
动态内存管理1.什么是动态内存2.动态内存分配函数2.1、malloc2.2、calloc 动态内存管理 本节课程的主要内容： 什么是动态内存 动态内存管理函数 动态内存的使用 动态内存与结构体 1.什么是动态内存 示例： 运行时程序崩溃。这是为什么呢? 分析编译链接过程 栈区： 我们知道栈区在函数被调时分配，用于存放函数的参数值，局部变量等值。在 windows 中栈的默认大小是1M，在 vs 中可以设置栈区的大小。在 Liunx 中栈的默认大小是 10M，在 gcc 编译时可以设置栈区的大小。.
SqList *L 和 SqList * &L的一些理解以及多重指针的简单应用
weixin_44374545的博客
08-18 5057
SqList *L 和 SqList * &L 关于 SqList *L 和 SqList * &L 的理解 复习数据结构（李春葆 c++版本）时看到了 SqList * &L 当时好像没弄明白今天花点时间理顺下： typedef struct { Elemtype data[MaxSize]； int length; }SqList; // void CreateList(SqList * &L,ElemType a[ ],int n) { int i;
数据结构-冒泡排序（含全部代码）
热门推荐
关注网络安全、云原生安全
03-15 2万+
目录 函数分析 代码 全部代码 结果截图 函数分析 下标从小到大，相邻依次比较，直到最后两个被比较，每次比较，若为逆序，则交换，以上为一趟冒泡排序。 使用一个标记，有交换时标记，若一趟下来没有需要交换的，则停止。 void BubbleSort(SqList &L) 参数：顺序表L，时间复杂度O(n^2)，空间复杂度O(1)，稳定性：稳定 代码 //冒泡排序 升序排序 void BubbleSort(SqList &L) { int m = L.length - 1;
C++顺序表基本操作的代码笔记
决明子的博客
09-20 571
//1.创建一个顺序表 //2.遍历顺序表 //3.通过下标获取元素 //4.查找要查询的元素的下标 //5.通过下标插入元素 //6.通过下标删除一个元素 //7.获取顺序表的长度 //8.删除所有元素 //9.判断顺序表是否为空 //10.判断顺序表是否满 //11.根据数据删除节点 //12.在头部插入数据 //13.在头部删除数据 /...
C++之智能指针
ZBQ__的博客
08-04 149
C++98引入了auto_ptr auto_ptr: **特点:**管理权限唯一,控制权限唯一<所有权唯一> 只有一个指针对象进行管理,剩下的都会失效.数据无法共享 不能在容器中保存auto_ptr,也不能从函数中返回auto_ptr. 上图所示是错误的,因为所有权是唯一的. 所以在C++11摒弃了auot_ptr:要避免因为潜在的内存问题导致程序崩溃. auto_ptr的简单实现:...
[Collection与数据结构] Map与Set(二):哈希表
最新发布
2301_80050796的博客
05-20 832
🏵️热门专栏:🍕 Collection与数据结构 (91平均质量分)🧀Java EE(94平均质量分)🍭MySql数据库(93平均质量分)🍬算法(97平均质量分)
数据结构C语言day
08-27
- *1* *2* *3* [数据结构-C语言代码 day 5-多项式加法](https://blog.csdn.net/yydslty/article/details/124612624)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_Ocean__

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值