线性表（List）：零个或多个数据元素的有限序列。
首先它是一个序列。也就是说，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且只有一个前驱和后继。
然后，线性表强调是有限的。
顺序表与单链表是线性表的两种最基本的存储结构，而静态链表是两者的完美结合，是系统进行动态存储分配的方法基础。线性表的这三种存储结构不但是其他数据结构（如树形结构、图型结构、集合等）存储方法的重要基础，同时本身也有广泛的应用。
线性表应该有以下基本的操作
可能有人第一次见线性表的顺序存储结构的时候，不禁怀疑：“这不就数组吗？这样定义好麻烦啊。有啥用啊？”
确实，在一些小体量的程序时，这样定义使用很麻烦，不如直接用数组。
但是这样封装起来后，程序就会很规范，虽然代码看上去很臃肿。
另外要实现的功能：
下面是代码，结合注释理解
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#define maxlenglth 1000
#define OK 1
#define ERROR 0
using namespace std;
typedef int Elemtype;
typedef int Status;
typedef int Position;
struct SeqList
{
Elemtype data[maxlenglth];
int lenth;
};// 线性表的定义
Status Display(SeqList L);//打 印
SeqList InitList();// 初始化
Position End(SeqList L); // 返回最后的位置
Status Insert(Elemtype t, Position p, SeqList &L); // 在位置p插入元素t
Status Delete(Elemtype t, SeqList &L); //删除所有元素t
Status Sort(SeqList &L); //排序
Status Unique(SeqList &L); //对排完序去重
Status ReverseList(SeqList &L); //翻转（逆置）
Status Merge(SeqList &L1, SeqList L2); //合并两个排好序的
Status Move(SeqList &L, int flag, int step); //移动
int main()
{
// basic test
int n1, n2;
SeqList L1 = InitList();
SeqList L2 = InitList();
cout << "please input L1's lenth:"; cin >> n1;
cout << "please input L1's data:" << "\n";
for(int i = 1; i <= n1; i ++ )
{
int x; cin >> x;
Insert(x, L1.lenth + 1, L1);
}
Display(L1);
cout << "----Delete----" << "\n";
Elemtype temp;
cin >> temp;
Delete(temp, L1);
Display(L1);
cout << "----Sorted----" << "\n";
Sort(L1);
Display(L1);
cout << "----Uniqued----" << "\n";
Unique(L1);
Display(L1);
// merge test
cout << "please input L2's lenth:"; cin >> n2;
cout << "please input L2's data:" << "\n";
for(int i = 1; i <= n2; i ++ )
{
int x; cin >> x;
Insert(x, L2.lenth + 1, L2);
}
Display(L2);
cout << "----Merged----" << "\n";
Merge(L1, L2);
Display(L1);
// move test
int flag, step;
cout << "left(1) right(0):"; cin >> flag;
cout << "move step:"; cin >> step;
Move(L1, flag, step);
Display(L1);
cin >> n1;
return 0;
}
Status Display(SeqList L)
{
for(int i = 1; i <= L.lenth; i ++ ) cout << L.data[i] << " \n"[i == L.lenth];
}
SeqList InitList()
{
SeqList List;
List.lenth = 0;
return List;
}
Position End(SeqList L)
{
return L.lenth;
}
Status Insert(Elemtype t, Position p, SeqList &L)
{
if(L.lenth + 1 == maxlenglth)
{
cout << "Full list!" << "\n";
return 1;
}
if(p > L.lenth + 1 || p < 1)
{
cout << "Invalid Position!" << "\n";
return 1;
}
L.lenth += 1;
for(int i = L.lenth; i > p; i -- )
{
L.data[i] = L.data[i - 1];
}
L.data[p] = t;
return 0;
}
Status Delete(Elemtype t, SeqList &L)
{
Position idx = 0;
for(int i = 1; i <= L.lenth; i ++ )
{
if(L.data[i] != t)
{
idx ++;
L.data[idx] = L.data[i];
}
}
L.lenth = idx;
return 0;
}
Status Sort(SeqList &L)
{
sort(L.data + 1, L.data + L.lenth + 1);
return 0;
}
Status Unique(SeqList &L)
{
Position idx = 0;
Elemtype last = 0;
for(int i = 1; i <= L.lenth; i ++)
{
if(i == 1)
{
last = L.data[i];
idx ++;
L.data[idx] = L.data[i];
}else
{
if(last != L.data[i])
{
idx ++;
L.data[idx] = L.data[i];
last = L.data[i];
}
}
}
L.lenth = idx;
return 0;
}
Status ReverseList(SeqList &L)
{
for(int i = 1, j = L.lenth; i < j; i ++, j -- )
{
swap(L.data[i], L.data[j]);
}
return 0;
}
Status Merge(SeqList &L1, SeqList L2)
{
if(L1.lenth + L2.lenth + 1 >= maxlenglth)
{
cout << "Overflow!" << "\n";
return 1;
}
for(int i = L2.lenth + 1, j = 1; j <= L1.lenth; j ++ , i ++)
{
L2.data[i] = L1.data[j];
}
Position idx = 0;
Position i, j;
for(i = 1, j = L2.lenth + 1; i <= L2.lenth && j <= L1.lenth + L2.lenth;)
{
if(L2.data[i] <= L2.data[j])
{
idx ++;
L1.data[idx] = L2.data[i];
i ++;
}else
{
idx ++;
L1.data[idx] = L2.data[j];
j ++;
}
}
while(i <= L2.lenth)
{
idx ++;
L1.data[idx] = L2.data[i];
i ++;
}
while(j <= L2.lenth + L1.lenth)
{
idx ++;
L1.data[idx] = L2.data[j];
j ++;
}
L1.lenth += L2.lenth;
return 0;
}
Status Move(SeqList &L, int flag, int step)
{
static SeqList temp = InitList();
temp.lenth = L.lenth;
if(temp.lenth == 0)
{
return 1;
}
for(int i = 1; i <= temp.lenth; i ++ )
{
temp.data[i] = L.data[i];
}
step = step % L.lenth;
if(flag == 0)
{
flag = 1;
}else
{
flag = -1;
}
for(int i = 1; i <= temp.lenth; i ++ )
{
int j = i + flag * step;
if(j > temp.lenth)
{
j -= temp.lenth;
}
if(j < 1)
{
j += temp.lenth;
}
L.data[j] = temp.data[i];
}
return 0;
}
关于链表，有三种经典类型：单链表，双向链表，循环链表
而每种类型又有很多考法
但其核心都是指针域的用法
另外要实现的功能：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#define OK 0
#define ERROR 1
using namespace std;
typedef int Elemtype;
typedef int Status;
struct Node{
Elemtype data;
Node * next;
};//链表定义
typedef Node * Position;
typedef Node * LIST;
void Creat(LIST head,int size);//创建
void ForwardInsert(LIST head,Elemtype x);//头插
void BackInsert(LIST head,int x);//尾插
void Travel(LIST head);//遍历
Status IsEmpty(LIST head);//判空
void AllDelete(LIST head);//删除
void SomeDataDelete(LIST head,Elemtype x);//删除一个数
void SomeDataInsert(LIST head,Elemtype x,int num);//在某位置插入一个数
void Sort(LIST head, int (*cmp)(Elemtype, Elemtype));//冒泡排序
int Ascend(Elemtype x, Elemtype y);//升序
int Descend(Elemtype x, Elemtype y);//降序
Position Locate(Elemtype x, LIST head);
void Unique(LIST head);//去重
Status Reverse(LIST head);//翻转
Status Move(LIST head, int flag, int step);//循环移动
Status Merge(LIST head1, LIST head2);//合并两个排好序的链表
int Len(LIST head);//求链表长
void MergeTest();//合并的测试
int main()
{
LIST head = (LIST)malloc(sizeof(Node));//头节点
head->next = NULL;
int num, i;
Elemtype temp;
cout << "list num:";
cin >> num;
Creat(head,num);
Travel(head);
cout << "Insert forwarddata:";//头插
cin >> temp;
ForwardInsert(head,temp);
Travel(head);
cout << "Insert backdata:";//尾插
cin >> temp;
BackInsert(head,temp);
Travel(head);
cout << "Somedata delete:";//删除
cin >> temp;
SomeDataDelete(head,temp);
Travel(head);
cout << "SomeDataInsert:(data and which):"; //某一位置插入某个数（BUG不可尾插）
cin >> temp >> i;
SomeDataInsert(head,temp,i);
Travel(head);
// 排序测试
cout << "----Sorted----" << "\n";
Sort(head,Descend);
Travel(head);
//去重测试
cout << "----Uniqued----" << "\n";
Unique(head);
Travel(head);
// 翻转测试
cout << "----Reversed----" << "\n";
Reverse(head);
Travel(head);
// 循环左(右)移测试
cout << "----Move----" << "\n";
int flag ,step;
cout << "(right, left)(0,1)---(step)" << "\n";
cin >> flag >> step;
Move(head, flag, step);
Travel(head);
// 合并测试
MergeTest();
AllDelete(head);
Travel(head);
free(head);//free掉头节点
return 0;
}
void MergeTest()
{
int num;
cout << "----Merge----" << "\n";
LIST h1 = (LIST)malloc(sizeof(Node));
h1->next = NULL;
cout << "list1 num:";cin >> num;
Creat(h1,num);
Sort(h1, Descend);
LIST h2 = (LIST)malloc(sizeof(Node));
h2->next = NULL;
cout << "list2 num:";cin >> num;
Creat(h2,num);
Sort(h2, Descend);
Merge(h1, h2);
cout << "Merged list:" << "\n";
Travel(h1);
AllDelete(h1);
free(h1);
free(h2);
}
Status Merge(LIST head1, LIST head2)
{
LIST p1 = head1->next, p2 = head2->next;
LIST temp = head1;
while(p1 != NULL && p2 != NULL)
{
if(p1->data < p2->data)
{
temp->next = p1;
p1 = p1->next;
}else
{
temp->next = p2;
p2 = p2->next;
}
temp = temp->next;
}
while(p1 != NULL)
{
temp->next = p1;
p1 = p1->next;
temp = temp->next;
}
while(p2 != NULL)
{
temp->next = p2;
p2 = p2->next;
temp = temp->next;
}
temp->next = NULL;
return OK;
}
Status Move(LIST head, int flag, int step)
{
int len = Len(head);
step = step % len;
if(step == 0)
{
return OK;
}
if(flag == 0)
{
step = len - step;
}
LIST p, q, s;
p = q = s = head;
p = p->next;
int idx = 0;
while(s->next != NULL)
{
idx ++;
s = s->next;
if(idx == step)
{
q = s;
}
}
head->next = q->next;
s->next = p;
q->next = NULL;
return OK;
}
int Len(LIST head)
{
LIST p = head;
int cnt = 0;
while(p->next != NULL)
{
cnt ++;
p = p->next;
}
return cnt;
}
void Unique(LIST head)
{
Elemtype last;
LIST p, q;
p = head->next;
if(p == NULL || p->next == NULL)
{
return;
}
last = p->data;
q = p->next;
while(q != NULL)
{
if(q->data == last)
{
p->next = q->next;
free(q);
if(p->next == NULL)
{
q = NULL;
}else
{
q = p->next;
}
}else
{
last = q->data;
q = q->next;
p = p->next;
}
}
}
Status Reverse(LIST head)
{
LIST p, q, s;
p = q = s = head->next;
q = p->next;
while(q != NULL)
{
p->next = q->next;
q->next = s;
s = q;
q = p->next;
}
head->next = s;
return OK;
}
Position Locate(Elemtype x, LIST head)
{
Position p = head;
while(p->next != NULL)
{
if(p->data == x)
{
return p;
}else
{
p = p->next;
}
}
return p;/* 如果没有找到 */
}
int Descend(Elemtype x, Elemtype y)
{
return x > y;
}
int Ascend(Elemtype x, Elemtype y)
{
return x < y;
}
void Sort(LIST head, int(*cmp)(Elemtype, Elemtype))
{
if(head->next == NULL)
{
cout << "Empty Node!\n";
return;
}
if(head->next->next==NULL)
{
cout << "Only one element!\n";
return;
}
LIST p1;
LIST p2;
for (p1 = head->next; p1->next != NULL; p1 = p1->next)
{
for (p2 = p1->next; p2!=NULL; p2 = p2->next)
{
if ((*cmp)(p1->data, p2->data))
{
swap(p1->data, p2->data);
}
}
}
}
void Creat(LIST head, int size)
{
LIST p = head;
for(int i = 1;i <= size; i ++)
{
LIST newnode =(LIST)malloc(sizeof(Node));
newnode->next = NULL;
cin >> newnode->data;
p->next = newnode;
p = newnode;
}
}
void ForwardInsert(LIST head, Elemtype x)
{
LIST newhead = (LIST)malloc(sizeof(Node));
newhead->data = x;
newhead->next = head->next;
head->next = newhead;
return;
}
void Travel(LIST head)
{
LIST p = head;
while(p->next != NULL)
{
p = p->next;
cout << p->data << " ";
}
cout << "\n";
return;
}
void BackInsert(LIST head, Elemtype x)
{
LIST p = head;
LIST back = (Node*)malloc(sizeof(Node));
back->next = NULL;
back->data = x;
while(p->next != NULL)
{
p = p->next;
}
p->next = back;
return;
}
Status IsEmpty(LIST head)
{
if(head->next == NULL)
{
cout << "is Empty!" << "\n";
return OK;
}else
{
cout << "not Empty!" << "\n";
return ERROR;
}
}
void AllDelete(LIST head)
{
LIST p = head->next;
LIST temp = head;
while(p != NULL)
{
temp = p;
p = p->next;
free(temp);
}
head->next = NULL;
return;
}
void SomeDataDelete(LIST head, Elemtype x)
{
LIST p = head->next;
LIST last = head;
LIST temp = NULL;
while(p != NULL)
{
if(temp != NULL)
{
free(temp);
temp = NULL;
}
if(p->data == x)
{
last->next = p->next;
temp = p;
}else
{
last = last->next;
}
p = p->next;
}
return;
}
void SomeDataInsert(LIST head,Elemtype x,int num)
{
LIST p = head;
LIST last = head;
int idx = 0;
while(p->next != NULL)
{
p = p->next;
idx ++;
if(idx == num)
{
LIST NewNode = (LIST)malloc(sizeof(Node));
NewNode->data = x;
last->next = NewNode;
NewNode->next = p;
}
last = last->next;
}
}
静态链表其实就是将指针域用游标来代替指针。
游标： Cursor
所有它的大小也取决于最先开始建立的数组大小。
这里插入一张《大话数据结构》的图片
实现基本功能和逆置的静态链表：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#define OK 1
#define ERROR 0
#define MAXSIZE 1000
using namespace std;
typedef int Status;
typedef int ElemType;
typedef struct
{
ElemType data;
int cur; /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];
/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space)
{
for(int i = 0; i < MAXSIZE - 1; i ++ )
space[i].cur = i + 1;
space[MAXSIZE - 1].cur = 0; /* 目前静态链表为空，最后一个元素的cur为0 */
return OK;
}
/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space)
{
int i = space[0].cur; /* 当前数组第一个元素的cur存的值 */
/* 就是要返回的第一个备用空闲的下标 */
if (space[0]. cur)
space[0]. cur = space[i].cur; /* 由于要拿出一个分量来使用了， */
/* 所以我们就得把它的下一个 */
/* 分量用来做备用 */
return i;
}
/* 将下标为k的空闲结点回收到备用链表 */
void Free_SSL(StaticLinkList space, int k)
{
space[k].cur = space[0].cur; /* 把第一个元素的cur值赋给要删除的分量cur */
space[0].cur = k; /* 把要删除的分量下标赋值给第一个元素的cur */
}
/* 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
int j = 0;
int i = L[MAXSIZE-1].cur;
while(i)
{
i = L[i].cur;
j ++;
}
return j;
}
/* 在L中第i个元素之前插入新的数据元素e */
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
int j, k, l;
k = MAXSIZE - 1; /* 注意k首先是最后一个元素的下标 */
if (i < 1 || i > ListLength(L) + 1)
return ERROR;
j = Malloc_SSL(L); /* 获得空闲分量的下标 */
if (j)
{
L[j].data = e; /* 将数据赋值给此分量的data */
for(l = 1; l <= i - 1; l++) /* 找到第i个元素之前的位置 */
k = L[k].cur;
L[j].cur = L[k].cur; /* 把第i个元素之前的cur赋值给新元素的cur */
L[k].cur = j; /* 把新元素的下标赋值给第i个元素之前元素的ur */
return OK;
}
return ERROR;
}
/* 删除在L中第i个数据元素 */
Status ListDelete(StaticLinkList L, int i)
{
int j, k;
if (i < 1 || i > ListLength(L))
return ERROR;
k = MAXSIZE - 1;
for (j = 1; j <= i - 1; j++)
k = L[k].cur;
j = L[k].cur;
L[k].cur = L[j].cur;
Free_SSL(L, j);
return OK;
}
Status ListTraverse(StaticLinkList L)
{
int j = 0;
int i = L[MAXSIZE-1].cur;
while(i)
{
cout << L[i].data << " ";
i=L[i].cur;
j++;
}
cout << "\n";
return OK;
}
Status Reverse(StaticLinkList L)
{
int i = L[MAXSIZE-1].cur;
int j = 0;
int k;
while(i)
{
k = L[i].cur;
L[i].cur = j;
j = i;
i = k;
}
L[MAXSIZE-1].cur = j;
}
int main()
{
StaticLinkList L;
Status i;
i=InitList(L);
cout << "--- Creat ---" << "\n";
cout << "num: ";
int n;cin >> n;
for(int i = 1; i <= n ; i ++ )
{
int e; cin >> e;
ListInsert(L, i, e);
}
ListTraverse(L);
cout << "--- Reverse ---" << "\n";
Reverse(L);
ListTraverse(L);
return 0;
}
说到静态链表，就不得不说它的一个应用：邻接表。
邻接表可以用作图的存储，可以存储有向图或无向图
idx 游标，可认为是第idx的意思
h[N] 有N个顶点，每个点都可能会连有边，h[i]存储顶点i的所有出边指向的点的集合
e[N] 存储该节点的出边指向的顶点
ne[N] 存储该节点的下一个节点的游标
w[N] 存储该节点代表的边的权重
int h[N], e[N], ne[N], idx;
// 添加一条边a->b
void add(int a, int b) //a到b添加一条边 事实上是 头插法
{
e[idx] = b;//节点idx存储顶点b
ne[idx] = h[a];//将节点idx指向的节点 指向 a顶点所指向的节点（头节点）
h[a] = idx ++ ; //将头指针的指向为新的头节点
}
// 初始化
idx = 0;
memset(h, -1, sizeof h); //初始化 所有的头指针指向-1
//这样当遍历的时侯,因为游标不可能出现-1，就可以当作遍历终止条件
我想将html转换为纯文本。不过，我不想只删除标签，我想智能地保留尽可能多的格式。为插入换行符标签，检测段落并格式化它们等。输入非常简单，通常是格式良好的html(不是整个文档，只是一堆内容，通常没有anchor或图像)。我可以将几个正则表达式放在一起，让我达到80%，但我认为可能有一些现有的解决方案更智能。 最佳答案 首先，不要尝试为此使用正则表达式。很有可能你会想出一个脆弱/脆弱的解决方案，它会随着HTML的变化而崩溃，或者很难管理和维护。您可以使用Nokogiri快速解析HTML并提取文本:require'nokogiri'h
我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i
有时我需要处理键/值数据。我不喜欢使用数组，因为它们在大小上没有限制(很容易不小心添加超过2个项目，而且您最终需要稍后验证大小)。此外，0和1的索引变成了魔数(MagicNumber)，并且在传达含义方面做得很差(“当我说0时，我的意思是head...”)。散列也不合适，因为可能会不小心添加额外的条目。我写了下面的类来解决这个问题:classPairattr_accessor:head,:taildefinitialize(h,t)@head,@tail=h,tendend它工作得很好并且解决了问题，但我很想知道:Ruby标准库是否已经带有这样一个类？ 最佳
给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。更准确地说:我正在使用Ruby，我想解析XML和JSON数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为JSON、XML和可能的HTML。我可以为此使用Builder模式吗？在任何提到的情况下，我都有某种结构化数据-无论是在内存中还是文本中-我想用它来构建其他东西。我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种XML格式。 最佳答案 我最
我正在尝试使用Curbgem执行以下POST以解析云curl-XPOST\-H"X-Parse-Application-Id:PARSE_APP_ID"\-H"X-Parse-REST-API-Key:PARSE_API_KEY"\-H"Content-Type:image/jpeg"\--data-binary'@myPicture.jpg'\https://api.parse.com/1/files/pic.jpg用这个:curl=Curl::Easy.new("https://api.parse.com/1/files/lion.jpg")curl.multipart_form_
无论您是想搭建桌面端、WEB端或者移动端APP应用，HOOPSPlatform组件都可以为您提供弹性的3D集成架构，同时，由工业领域3D技术专家组成的HOOPS技术团队也能为您提供技术支持服务。如果您的客户期望有一种在多个平台（桌面/WEB/APP，而且某些客户端是“瘦”客户端）快速、方便地将数据接入到3D应用系统的解决方案，并且当访问数据时，在各个平台上的性能和用户体验保持一致，HOOPSPlatform将帮助您完成。利用HOOPSPlatform，您可以开发在任何环境下的3D基础应用架构。HOOPSPlatform可以帮您打造3D创新型产品，HOOPSSDK包含的技术有：快速且准确的CAD
本教程将在Unity3D中混合Optitrack与数据手套的数据流，在人体运动的基础上，添加双手手指部分的运动。双手手背的角度仍由Optitrack提供，数据手套提供双手手指的角度。 01 客户端软件分别安装MotiveBody与MotionVenus并校准人体与数据手套。MotiveBodyMotionVenus数据手套使用、校准流程参照：https://gitee.com/foheart_1/foheart-h1-data-summary.git02 数据转发打开MotiveBody软件的Streaming，开始向Unity3D广播数据；MotionVenus中设置->选项选择Unit
文章目录一、概述简介原理模块二、配置Mysql使用版本环境要求1.操作系统2.mysql要求三、配置canal-server离线下载在线下载上传解压修改配置单机配置集群配置分库分表配置1.修改全局配置2.实例配置垂直分库水平分库3.修改group-instance.xml4.启动监听四、配置canal-adapter1修改启动配置2配置映射文件3启动ES数据同步查询所有订阅同步数据同步开关启动4.验证五、配置canal-admin一、概述简介canal是Alibaba旗下的一款开源项目，Java开发。基于数据库增量日志解析，提供增量数据订阅&消费。Git地址：https://github.co
我正在尝试在Rails上安装ruby，到目前为止一切都已安装，但是当我尝试使用rakedb:create创建数据库时，我收到一个奇怪的错误:dyld:lazysymbolbindingfailed:Symbolnotfound:_mysql_get_client_infoReferencedfrom:/Library/Ruby/Gems/1.8/gems/mysql2-0.3.11/lib/mysql2/mysql2.bundleExpectedin:flatnamespacedyld:Symbolnotfound:_mysql_get_client_infoReferencedf
文章目录1.开发板选择*用到的资源2.串口通信（个人理解）3.代码分析（注释比较详细）1.主函数2.串口1配置3.串口2配置以及中断函数4.注意问题5.源码链接1.开发板选择我用的是STM32F103RCT6的板子，不过代码大概在F103系列的板子上都可以运行，我试过在野火103的霸道板上也可以，主要看一下串口对应的引脚一不一样就行了，不一样的就更改一下。*用到的资源keil5软件这里用到了两个串口资源，采集数据一个，串口通信一个，板子对应引脚如下：串口1，TX：PA9，RX：PA10串口2，TX：PA2，RX：PA32.串口通信（个人理解）我就从串口采集传感器数据这个过程说一下我自己的理解，