数据结构（第一周总结）
[TOC]
学习视频来源：==王道计算机考研 数据结构== （哔哩哔哩）
参考笔记：梦入_凡尘 数据结构学习笔记（王道）
木木要加油 王道考研数据结构笔记
繁凡さん 《数据结构》C语言版（清华严蔚敏考研版）
1.绪论🔸
数据：是信息的载体，是描述客观事物属性的数。字符及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。数据是计算机程序加工的原料
数据元素：是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成。
数据项：数据的不可分割的最小单位。
数据结构：相互之间存在着一种或多种特定关系的数据元素的集合
数据对象：是具有相同性质的数据元素的集合，是数据的一个子集
抽象数据类型（Abstract Data Type,ADT）是抽象数据组织及与之相关的操作
指一个数学模型以及定义在该模型上的一组操作，只取决于它的一组逻辑特性，用一个三元组表示（D, S, P）。
数据类型：是程序设计语言中的一个概念，它是一个值的集合和操作的集合。
逻辑结构：
线性结构：结构中的数据元素之间存在一对一的关系。
树型结构：结构中的数据元素之间存在一对多的关系。
图状结构（网状结构）：结构中的数据元素之间存在多对多的关系。
存储结构：
顺序存储方式
链式存储方式
索引存储方式
散列存储方式
2.算法🎨
2.1算法：
程序=数据结构+算法
数据结构是要处理的信息
算法是处理信息的步骤
是对特定问题求解步骤的一种描述，是指令的有限序列。其中每一条指令表示一个或多个操作。
算法的特性：
有穷性：有穷时间内能执行完（程序可以无穷）
确定性：相同输入只会产生相同输出
可行性：可以用基本的·已有操作实现算法
输入
输出
算法的设计目标：
正确性
可读性：其他人也能看的懂
健壮性：能处理一些异常状况
高效率与低存储量需求：算法执行省时，省内存
时间复杂度低，空间复杂度低
2.2时间复杂度
如何计算：
==当问题规模足够大时，可以只考虑阶数高的部分==
找到一个基本操作（最深层循环)
分析该基本操作的执行次数x与问题规模n的关系 x = f ( n ) x=f(n)x=f(n)
x的数量级O ( x ) O(x)O(x)就是算法时间复杂度T ( n ) T(n)T(n)：O ( x ) = T ( n ) O(x)=T(n)O(x)=T(n)
常用技巧：
加法规则：O ( f ( n ) ) + O ( g ( n ) ) = O ( m a x ( f ( n ) , g ( n ) ) )
乘法规则：O ( f ( n ) ) × O ( g ( n ) ) = O ( f ( n ) × g ( n ) )
“常对幂指阶”
O(1)<O(㏒2n)<O(n)<O(n㏒2n)<O(n²)<O(n³)<O(2的n次方)<O(n!)<O(n的n次方)
程序的时间复杂度越低，程序执行越快
三种复杂度：
最坏时间复杂度：考虑输入数据“最坏”的情况。
平均时间复杂度：考虑所有输入数据都等概率出现的情况。
最好时间复杂度：考虑输入数据“最好”的情况。
（检验算法好坏通常只看最坏时间复杂度与平均时间复杂度）
算法的性能问题只有在 n 很大时才会暴露出来（例如几百人游戏匹配的程序不一定适用于几万人在线匹配）
2.3算法的空间复杂度
普通程序：
找到所占空间大小与问题规模相关的变量
分析所占空间 x 与问题规模 n 的关系 x = f ( n )
x 的数量级 O ( x ) 就是算法空间复杂度 S(n)（s表示”space“）
算法原地工作——算法所需内存空间为常量
算法原地工作是指辅助空间不随着数据规模的增大而增大，不是说不需要辅助空间
递归程序：
找到递归调用的深度x与问题规模n的关系 x = f ( n )
x的数量级 O(x)就是算法空间复杂度 S ( n )
空间复杂度就是递归调用的深度（大部分情况)
有的算法各层函数所需的存储空间不同，分析方法稍有区别
3.线性表（linear list)🚗
各结点由两个域组成：
数据域：存储元素数值数据
指针域：存储直接后继结点的存储位置
结点：数据元素的存储映像。 由数据域和指针域两部分组成
链表： n 个结点由指针链组成一个链表。它是线性表的链式存储映像，称为线性表的链式存储结构
单链表、双链表、循环链表：
结点只有一个指针域的链表，称为单链表或线性链表
有两个指针域的链表，称为双链表
首尾相接的链表称为循环链表
头指针是指向链表中第一个结点的指针
首元结点是指链表中存储第一个数据元素a1的结点
头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息
3.1线性表的定义和操作
3.1.1. 线性表的基本概念
线性表：是具有相同数据类型的 n 个数据元素的有限序列，其中n为表长，当n=0时，线性表是一个空表
若用L命名线性表，一般形式为
L=（a1,a2,a3......an)
如用ai表示数据元素，则i称为数据元素ai在线性表中的位序。
a1是表头元素，an是表尾元素（位序从一开始，数组从0开始）
除第一个元素之外，每个元素均只有一个直接前驱。
除最后一个元素之外，每个元素均只有一个直接后继。
3.1.2. 线性表的基本操作
InitList(&L)：初始化表。构造一个空的线性表 L，并分配内存空间。
DestroyList(&L)：销毁操作。销毁线性表，并释放线性表 L 占用的内存空间。
ListInsert(&L, i, e)：插入操作。在表 L 的第 i 个位置插入指定元素 e 。
ListDelete(&L, i, &e)：删除操作。删除表 L 中第 i 个位置的元素，并用 e 返回删除元素的值。
GetElem(L, i)：按位查找。获取表 L 中第 i 个位置的元素的值。
LocateElem(L, e)：按值查找。在表 L 中查找具有给定元素值的元素。
其他常用操作：
Length(L)：求表长。返回线性表 L 的长度，即表中元素的个数。
PrintList(L)：打印表。按顺序输出线性表 L 的所有元素值。
Empty(L)：判断是否为空。若 线性表L 为空表，则返回 true，否则返回 false。
对数据的操作（记忆思路）：创销、增删改查
实际开发中，可根据实际需求定义其他的基本操作
什么时候要传入参数的引用&--对参数的修改结果需要“带回来”
(●'◡'●)
3.2. 顺序表
3.2.1. 顺序表的基本概念
顺序表：用顺序存储的方式实现线性表。顺序存储，将* 逻辑上相邻的元素存储在相邻的物理位置上。 *（存储结构）
特点：
随机访问，即可以在 O ( 1 ) 时间内找到第 i 个元素。
存储密度高，每个节点只存储数据元素。
拓展容量不方便（即使使用动态分配的方式实现，拓展长度的时间复杂度也比较高，因为需要把数据复制到新的区域）。
插入删除操作不方便，需移动大量元素：O ( n )
3.2.2. 顺序表的实现:
静态实现：
使用“静态数组”实现
大小一旦确定就无法改变
#include <stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct{
int data[MaxSize]; //用静态的“数组”存放数据元素 ElemType:int
int Length; //顺序表的当前长度
}SqList; //顺序表的类型定义
//基本操作——初始化一个顺序表
void InitList(SqList &L){
for(int i=0; i<MaxSize; i++){
L.data[i]=0; //将所有数据元素设置为默认初始值0,如果没有这一步，内存中会有遗留的“脏数据”
}
L.Length=0; //顺序表初始长度为0
}
int main(){
SqList L; //声明一个顺序表
//在内存里分配存储顺序表L的空间
//包括MaxSize*sizeof(ElemType)和存储length的空间
InitList(L); //初始化这个顺序表
//...
return 0;
}动态实现：
使用“动态数组”实现
顺序表存满时，可再用malloc动态扩展顺序表的最大容量
需要将数据元素复制到新的存储区域，并用free函数释放原区域
malloc函数:
L.data = (ElemType*)malloc(sizeof(ElemType)InitSize) 其中(ElemType)可强制转换数据类型
#include <stdlib.h> //malloc,free函数的头文件
#define InitSize 10 //默认的最大长度
typedef struct{
int *data; //指示动态分配数组的指针
int MaxSize; //顺序表的最大容量
int length; //顺序表的当前长度
}SeqList;
void InitSize(SeqList &L){
L.data = (int*)malloc(sizeof(int)*InitSize); //用malloc函数申请一片连续的存储空间
L.length = 0;
L.MaxSize = InitSize;
}
int main(){
SeqList L;
InitSize(L);
//...其余操作
IncreaseSize(L,5);
return 0;
}
//增加动态数组的长度
void IncreaseSize(SeqList &L, int len){
int *p=L.data
L.data = (int*)malloc((L.MaxSize+len)*sizeof(int));
for(int i=0; i<L.length; i++){
L.data[i] = p[i] //将数据复制到新区域
}
L.MaxSize = L.MaxSize + len; //顺序表最大长度增加len
free(p); //释放原来的内存空间
}3.2.3. 顺序表的基本操作
插入：
ListInsert(&L, i, e)：插入操作。在表 L 的第 i 个位置插入指定元素 e 。
插入位置之后的元素都要后移
#define MaxSize 10 //定义最大长度
typedef struct{
int data[MaxSize]; //用静态的“数组”存放数据元素 ElemType:int
int Length; //顺序表的当前长度
}SqList; //顺序表的类型定义
//基本操作——在L的位序i处插入元素e
bool ListInsert(SqList &L, int i, int e){
//判断i的范围是否有效
if(i<1||i>L.length+1)
return false;
if(L.length>MaxSize) //当前存储空间已满，不能插入
return false;
for(int j=L.length; j>i; j--){ //将第i个元素及其之后的元素后移
L.data[j]=L.data[j-1];
}
L.data[i-1]=e; //在位置i处放入e
L.length++; //长度加1
return true;
}
int main(){
SqList L; //声明一个顺序表
InitList(L); //初始化这个顺序表
//...插入几个元素
ListInsert(L,3,3);
return 0;
}时间复杂度：
关注最深层循环语句——L.data[j]=L.data[j-1]的执行次数与问题规模n——L.length的关系;
最好时间复杂度：O ( 1 ) 新元素插入到表尾
最坏时间复杂度：O ( n ) 插入表头，需要将原有的n个元素全都向后移动，i=1，循环n次；
平均时间复杂度：O ( n ) 假设新元素插入到任何一个位置的概率p(=1/n+1)相同
平均循环次数 = np + (n-1)p + (n-2)p + … + 1×p = [ n(n+1)/2 ]×[ 1/(n+1) ] = n/2
删除：
ListDelete(&L, i, &e)：删除操作。删除表 L 中第 i 个位置的元素，并用 e 返回删除元素的值。
删除位置之后的元素都要前移
#define MaxSize 10
typedef struct {
int data[MaxSize];
int length;
} SqList;
// 删除顺序表i位置的数据并存入e
bool ListDelete(SqList &L, int i, int &e) {
if (i < 1 || i > L.length) // 判断i的范围是否有效
return false;
e = L.data[i-1]; // 将被删除的元素赋值给e
for (int j = i; j < L.length; j++) //将第i个位置后的元素前移
L.data[j-1] = L.data[j];
L.length--;
return true;
}
int main() {
SqList L;
InitList(L);
int e = -1;
if (ListDelete(L, 3, e))
printf("已删除第3个元素，删除元素值为%d\n", e);
else
printf("位序i不合法，删除失败\n");
return 0;
} 时间复杂度：
最好时间复杂度：O ( 1 ) 删除表尾元素，不需要移动其他元素
最坏时间复杂度：O ( n )删除表头元素，需要将后续的n-1个元素全都向前移动，循环n-1次
平均时间复杂度：O ( n ) 假设删除任何一个元素的概率相同
按位查找：
GetElem(L, i)：按位查找。获取表 L 中第 i 个位置的元素的值。
// 静态分配的按位查找
#define MaxSize 10
typedef struct {
ElemType data[MaxSize];
int length;
}SqList;
ElemType GetElem(SqList L, int i) {
return L.data[i-1];
}// 动态分配的按位查找
#define InitSize 10
typedef struct {
ElemType *data;
int MaxSize;
int length;
}SeqList;
ElemType GetElem(SeqList L, int i) {
return L.data[i-1];
}时间复杂度： O ( 1 )
按值查找：
GetElem(L, i)：按位查找。获取表 L 中第 i 个位置的元素的值。
#define InitSize 10
typedef struct {
ElemType *data;
int MaxSize;
int length;
}SqList;
// 查找第一个元素值为e的元素，并返回其位序
int LocateElem(SqList L, ElemType e) {
for (int i = 0; i < L.length; i++)
if (L.data[i] == e)
return i+1; // 数组下标为i的元素值等于e，返回其位序i+1
return 0; // 没有查找到
}时间复杂度：
最好时间复杂度：O(1)
最坏时间复杂度：O ( n )
平均时间复杂度：O ( n )
在《数据结构》考研初试中，手写代码可以直接用“==”，无论 ElemType 是基本数据类型还是结构类型
3.3. 链表🎯
3.3.1. 单链表的基本概念
1.单链表：用链式存储实现了线性结构。一个结点存储一个数据元素，各结点间的前后关系用一个指针表示。
2.特点：
优点：不要求大片连续空间，改变容量方便。
缺点：不可随机存取，要耗费一定空间存放指针。
3.两种实现方式：
带头结点，写代码更方便。头结点不存储数据，头结点指向的下一个结点才存放实际数据。
不带头结点，麻烦。对第一个数据结点与后续数据结点的处理需要用不同的代码逻辑，对空表和非空表的处理 需要用不同的代码逻辑。
如果每次都要写struct很麻烦，所以可以利用typedef关键字——数据类型重命名：type<数据类型><别名>
Eg:
typedef int zhengshu;
typedef int *zhengshuzhizhen; //指向int型的指针3.3.2. 单链表的实现
不带头结点的单链表：
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//初始化一个空的单链表
bool InitList(LinkList &L){
L = NULL; //空表，暂时还没有任何结点
return true;
}
void test(){
LinkList L; //声明一个指向单链表的头指针
//初始化一个空表
InitList(L);
...
}
//判断单链表是否为空
bool Empty(LinkList L){
return (L==NULL)
}带头结点的单链表：
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
// 初始化一个单链表（带头结点）
bool InitList(LinkList &L){
L = (LNode *)malloc(sizeof(LNode)); //分配一个头结点
if (L == NULL) //内存不足，分配失败
return false;
L->next = NULL; //头结点之后暂时还没有结点
return true;
}
void test(){
LinkList L; //声明一个指向单链表的头指针
//初始化一个空表
InitList(L);
...
}
//判断单链表是否为空
bool Empty(LinkList L){
if (L->next == NULL)
return true;
else
return false;
}3.3.3. 单链表的插入
按位序插入（带头结点）：
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1)
return False;
LNode *p; //指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p = L; //循环找到第i-1个结点
while(p!=NULL && j<i-1){ //如果i>lengh，p最后会等于NULL
p = p->next;
j++;
}
//p值为NULL说明i值不合法
if (p==NULL)
return false;
//在第i-1个结点后插入新结点
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
//将结点s连到p后
return true;
}时间复杂度：
最好时间复杂度：O ( 1 )
最坏时间复杂度：O ( n )
平均时间复杂度：O ( n )
按位序插入（不带头结点）：
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, ElemType e){
//判断i的合法性
if(i<1)
return false;
//需要判断插入的位置是否是第1个
if(i==1){
LNode *s = (LNode *)malloc(size of(LNode));
s->data =e;
s->next =L;
L=s; //头指针指向新结点
return true;
}
//i>1的情况与带头结点一样，唯一区别是j的初始值为1
LNode *p; //指针p指向当前扫描到的结点
int j=1; //当前p指向的是第几个结点
p = L;
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ //如果i>lengh，p最后会等于NULL
p = p->next;
j++;
}
//p值为NULL说明i值不合法
if (p==NULL)
return false;
//在第i-1个结点后插入新结点
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
return true;
}时间复杂度：
最好时间复杂度：O ( 1 )
最坏时间复杂度：O ( n )
平均时间复杂度：O ( n )
指定结点的后插操作：
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
// 在结点p后插入元素e
bool InsertNextNode(LNode *p, ElemType e){
if(p==NULL){
return false;
}
LNode *s = (LNode *)malloc(sizeof(LNode));
if(s==NULL)
return false;
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
// 按位序插入的函数中可以直接调用后插操作
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1)
return False;
LNode *p;
//指针p指向当前扫描到的结点
int j=0;
//当前p指向的是第几个结点
p = L;
//循环找到第i-1个结点
while(p!=NULL && j<i-1){
//如果i>lengh, p最后会等于NULL
p = p->next;
j++;
}
return InsertNextNode(p, e)
}时间复杂度：O ( 1 )
指定结点的前插操作：
如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对q进行后插操作；
如果不传入头指针，可以在指定结点p后插入一个结点s，并交换两个结点所保存的数据，从而变相实现指定结点的前插操作。
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
// 在结点p前插入元素e
bool InsertPriorNode(LNode *p, ElemType e){
if(p==NULL)
return false;
LNode *s = (LNode *)malloc(sizeof(LNode));
// 内存不足分配失败
if(s==NULL)
return false;
// 将s插入结点p之后
s->next = p->next;
p->next = s;
// 交换两个结点中的数据
s->data = p->data;
p->data = e;
return true;
}时间复杂度：O ( 1 )
3.3.4. 单链表的删除
按位序删除：
typedef struct LNode{
ElemType data;
struct LNode *next;}LNode, *LinkList;
// 删除第i个结点并将其所保存的数据存入e
bool ListDelete(LinkList &L, int i, ElemType &e){
if(i<1)
return false;
LNode *p; //指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p = L;
//循环找到第i-1个结点
while(p!=NULL && j<i-1){
//如果i>lengh，p和p的后继结点会等于NULL
p = p->next;
j++;
}
if(p==NULL)
return false;
if(p->next == NULL)
return false;
//令q暂时保存被删除的结点
LNode *q = p->next;
e = q->data;
p->next = q->next;
free(q)
return true;
}时间复杂度：
最好时间复杂度：O ( 1 )
最坏时间复杂度：O ( n )
平均时间复杂度：O ( n )
删除指定结点：
如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对p进行删除操作；
如果不传入头指针，可以把指定结点p的后继结点q删除，并使结点p保存结点q存储的数据，从而变相实现删除指定结点的操作。但是如果指定结点p没有后继结点，这么做会报错。
// 删除指定结点p
bool DeleteNode(LNode *p){
if(p==NULL)
return false;
LNode *q = p->next; // 令q指向p的后继结点
// 如果p是最后一个结点，则q指向NULL，继续执行就会报错
p->data = q->data;
p->next = q->next;
free(q);
return true;
}时间复杂度：O ( 1 )
3.3.5. 单链表的查找
按位查找：
GetElem(L, i)：按位查找。获取表 L 中第 i 个位置的元素的值。
单列表不具备“随机访问”的特性，只能依次扫描
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
// 查找指定位序i的结点并返回
LNode * GetElem(LinkList L, int i){
if(i<0)
return NULL;
LNode *p;
int j=0;
p = L;
while(p!=NULL && j<i){
p = p->next;
j++;
}
return p;
}
// 封装后的插入操作，在第i个位置插入元素e，可以调用查询操作和后插操作
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1)
return False;
// 找到第i-1个元素
LNode *p = GetElem(L, i-1);
// 在p结点后插入元素e
return InsertNextNode(p, e)
}时间复杂度：
最好时间复杂度：O ( 1 )
最坏时间复杂度：O ( n )
平均时间复杂度：O ( n )
按值查找：
LocateElem(L, e)：按值查找。在表 L 中查找具有给定元素值的元素。
// 查找数据域为e的结点指针，否则返回NULL
LNode * LocateElem(LinkList L, ElemType e){
LNode *P = L->next;
// 从第一个结点开始查找数据域为e的结点
while(p!=NULL && p->data != e){
p = p->next;
}
return p;
}时间复杂度：
最好时间复杂度：O ( 1 )
最坏时间复杂度：O ( n )
平均时间复杂度：O ( n )
计算单链表长度：
// 计算单链表的长度
int Length(LinkList L){
int len=0; //统计表长
LNode *p = L;
while(p->next != NULL){
p = p->next;
len++;
}
return len;
}时间复杂度：O ( n )
key：三种基本操作的时间复杂度都是O ( n )
3.3.6. 单链表的建立
尾插法建立单链表：
// 使用尾插法建立单链表L
LinkList List_TailInsert(LinkList &L){
int x; //设ElemType为整型int
L = (LinkList)malloc(sizeof(LNode)); //建立头结点(初始化空表)
LNode *s, *r = L; //r为表尾指针
scanf("%d", &x); //输入要插入的结点的值
while(x!=9999){ //输入9999表示结束
s = (LNode *)malloc(sizeof(LNode));
s->data = x;
r->next = s;
r = s; //r指针指向新的表尾结点
scanf("%d", &x);
}
r->next = NULL; //尾结点指针置空
return L;
}时间复杂度：O ( n )
头插法建立单链表：
LinkList List_HeadInsert(LinkList &L){ //逆向建立单链表
LNode *s;
int x;
L = (LinkList)malloc(sizeof(LNode)); //建立头结点
L->next = NULL; //初始为空链表,这步很关键
scanf("%d", &x); //输入要插入的结点的值
while(x!=9999){ //输入9999表结束
s = (LNode *)malloc(sizeof(LNode));
s->data = x;
s->next = L->next;
L->next = s;
//将新结点插入表中，L为头指针
scanf("%d", &x);
}
return L;
}头插法实现链表的逆置：
// 将链表L中的数据逆置并返回
LNode *Inverse(LNode *L){
LNode *p, *q;
p = L->next; //p指针指向第一个结点
L->next = NULL; //头结点置空
// 依次判断p结点中的数据并采用头插法插到L链表中
while (p != NULL){
q = p;
p = p->next;
q->next = L->next;
L->next = q;
}
return L;
}4.最后🎈
看了后面忘了前面😑
4.1什么是封装？
封装是把彼此相关数据和操作包围起来，抽象成为一个对象，变量和函数就有了归属，想要访问对象的数据只能通过已定义的接口。
说封装就是将属性私有化，太过狭隘，因为封装不仅仅实现了数据的保护，还把彼此相关联的变量和函数包围了起来。
封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。在电子方面，封装是指把硅片上的电路管脚，用导线接引到外部接头处，以便与其它器件连接。
（以上解释分别来源于CSDN和百度百科）
好处:避免重复代码，简洁，易维护
4.2回文数
bool isPalindrome(int x){
if (x < 0 || (x % 10 == 0 && x != 0)) {
return false;
}
int revertedNumber = 0; //循环建立翻转一半的数字
while (x > revertedNumber) {
revertedNumber = revertedNumber * 10 + x % 10;
x /= 10;
}
return x == revertedNumber || x == revertedNumber / 10; //针对奇数位和偶数位的数字，分别判断是否
} //为回文数🚥
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
