嵌入式设备采集的信息怎么存到mysql 嵌入式数据

转载

footballboy 2024-05-14 11:35:10

文章标签 嵌入式设备采集的信息怎么存到mysql 嵌入式数据结构 c语言 c++ 文章分类 MySQL 数据库

0 引言
1 线性表

1.1 顺序表

1.1.1 定义类型
1.1.2 相关操作
1.1.3 相关操作的实现

1.2 链表

1.2.1 定义类型
1.2.2 相关操作
1.2.3 相关操作的实现

2 栈

2.1 顺序栈

2.1.1 定义类型
2.1.2 相关操作
2.1.3 相关操作的实现

2.2 链栈

2.2.1 定义类型
2.2.2 相关操作
2.2.3 相关操作的实现

3 队列

3.1 顺序队列

3.1.1 定义类型
3.1.2 相关操作
3.1.3 相关操作的实现

3.2 链队列

3.2.1 定义类型
3.2.2 相关操作
3.2.3 相关操作的实现

0 引言

嵌入式对数据结构要求到不是特别的高，但是在学习操作系统时往往需要理解一些常见的数据结构，并且在面试的时候也会进行适当的考察。因此，本文对嵌入式常见的数据结构进行介绍。
文章主要分为三部分：线性表，栈，队列。按照这三种数据类型的存储形式又能各自分为两部分：顺序存储结构，链式存储结构。有的数据结构在顺序存储结构中还能分出顺序型和环形（如队列）。有的数据结构在链式存储结构中还能分出单链，双链，循环链（如链表）。
通过C/C++语言实现上述数据结构的创建，初始化，插入，删除等等基本运算，并将代码贴出以供学习查阅。

1 线性表

1.1 顺序表

1.1.1 定义类型

//以Student举例
typedef struct Student
{
	int Num;
	char Sex;
	char * Name;
}Student;

typedef struct StudentList
{
	Student Stu[5];
	int Length;
}StudentList;

1.1.2 相关操作

void CreatList(StudentList * & L, Student Stu[], int n);
void InitList(StudentList * & L);
void DestroyList(StudentList * L);
bool ListEmpty(StudentList * L);
int ListLength(StudentList * L);
void ListDisp(StudentList * L);
int LocateElem(StudentList * L, Student E);
bool GetElem(StudentList * L, int i, Student & E);
bool InsertList(StudentList * L, int i, Student E);
bool DeleteList(StudentList * L, int i, Student & E);

1.1.3 相关操作的实现

//0建立顺序表
void CreatList(StudentList * & L, Student Stu[], int n)
{
	int i;
	L = (StudentList *)malloc(sizeof(StudentList));
	for (i = 0; i < n; i++)
		L->Stu[i] = Stu[i];
	L->Length = n;
}

//1初始化顺序表
void InitList(StudentList * & L)
{
	L = (StudentList *)malloc(sizeof(StudentList));
	L->Length = 0;
}

//2销毁顺序表
void DestroyList(StudentList * L)
{
	free(L);
	L = NULL;
}

//3判断顺序表是否为空
bool ListEmpty(StudentList * L)
{
	return (L->Length == 0);
}

//4输出顺序表长度
int ListLength(StudentList * L)
{
	return L->Length;
}

//5输出顺序表内容
void ListDisp(StudentList * L)
{
	printf("Length:%d\n\n", ListLength(L));
	for (int i = 0; i < L->Length; i++)
	{
		printf("Name:%s\n", L->Stu[i].Name);
		printf("Num:%d\n", L->Stu[i].Num);
		printf("Sex:%c\n\n", L->Stu[i].Sex);
	}
}

//6按值搜索顺序表，输出索引
int LocateElem(StudentList * L, Student E)
{
	int i = 0;
	while (i < L->Length && !((L->Stu[i].Name == E.Name) && (L->Stu[i].Num == E.Num) && (L->Stu[i].Sex == E.Sex)))
		i++;
	if (i == L->Length)
		return 0;
	else
		return i+1;
}

//7按索引搜索顺序表，得到元素
bool GetElem(StudentList * L, int i, Student & E)
{
	if (i<1 || i>L->Length)
		return false;
	else
	{
		E = L->Stu[i - 1];
		return true;
	}
}

//8顺序表插入元素
bool InsertList(StudentList * L, int i, Student E)
{
	if (i<1 || i>L->Length + 1)
		return false;
	else
	{
		i--;
		for (int j = (L->Length-1); j >= i; j--)
			L->Stu[j + 1] = L->Stu[j];
		L->Stu[i] = E;
		L->Length++;
		return true;
	}
}

//9顺序表删除元素
bool DeleteList(StudentList * L, int i, Student & E)
{
	if (i<1 || i>L->Length + 1)
		return false;
	else
	{
		i--;
		E = L->Stu[i];
		for (int j = i; j < (L->Length - 1); j++)
			L->Stu[j] = L->Stu[j + 1];
		L->Length--;
		return true;
	}
}

1.2 链表

1.2.1 定义类型

/*************************单链表*************************/
//以Student举例
typedef struct Student
{
	int Num;
	char Sex;
	char * Name;
}Student;

typedef struct StudentList
{
	Student Stu;
	StudentList * next;
}StudentList;
/*************************单链表*************************/


/*************************双链表*************************/
//以Student举例
typedef struct Student
{
	int Num;
	char Sex;
	char * Name;
}Student;

typedef struct StudentList
{
	Student Stu;
	StudentList * next;
	StudentList * prior;
}StudentList;
/*************************双链表*************************/

1.2.2 相关操作

void CreatListR(StudentList * & L, Student Stu[], int n);
void InitList(StudentList * & L);
void DestroyList(StudentList * L);
bool ListEmpty(StudentList * L);
int ListLength(StudentList * L);
void ListDisp(StudentList * L);
int LocateElem(StudentList * L, Student E);
bool GetElem(StudentList * L, int i, Student & E);
bool InsertList(StudentList * L, int i, Student E);
bool DeleteList(StudentList * L, int i);

1.2.3 相关操作的实现

/*************************单链表*************************/
//0尾插法建立单链表
void CreatListR(StudentList * & L, Student Stu[], int n)
{
	StudentList * pre = NULL;
	StudentList * p = NULL;
	int i;
	L = (StudentList *)malloc(sizeof(StudentList));
	pre = L;
	for (i = 0; i < n; i++)
	{
		p = (StudentList *)malloc(sizeof(StudentList));
		p->Stu = Stu[i];
		pre->next = p;
		pre = pre->next;
	}
	p->next = NULL;
}

//1初始化单链表
void InitList(StudentList * & L)
{
	L = (StudentList *)malloc(sizeof(StudentList));
	L->next = NULL;
}

//2销毁单链表
void DestroyList(StudentList * L)
{
	StudentList * pre = L, * p = L->next;
	while (p != NULL)
	{
		free(pre);
		pre = p;
		p = p->next;
	}
	free(pre);
}

//3判断单链表是否为空
bool ListEmpty(StudentList * L)
{
	return(L->next == NULL);
}

//4输出单链表长度
int ListLength(StudentList * L)
{
	StudentList * p = L->next;
	int i = 0;
	while (p != NULL)
	{
		i++;
		p = p->next;
	}
	return i;
}

//5输出单链表内容
void ListDisp(StudentList * L)
{
	StudentList * p = L->next;
	printf("Length:%d\n\n", ListLength(L));
	while (p != NULL)
	{
		printf("Name:%s\n", p->Stu.Name);
		printf("Num:%d\n", p->Stu.Num);
		printf("Sex:%c\n\n", p->Stu.Sex);
		p = p->next;
	}
	printf("\n");
}

//6按值搜索单链表，输出索引
int LocateElem(StudentList * L, Student E)
{
	StudentList * p = L;
	int i = 0;
	while (p != NULL && (!((p->Stu.Name == E.Name) && (p->Stu.Num == E.Num) && (p->Stu.Sex == E.Sex))))
	{
		i++;
		p = p->next;
	}
	if (p == NULL)
		return 0;
	else
		return i;
}

//7按索引搜索单链表，得到元素
bool GetElem(StudentList * L, int i, Student & E)
{
	StudentList * p = L;
	int n = 0;
	while ((p != NULL) && (n < i))
	{
		n++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else
	{
		E = p->Stu;
		return true;
	}
}

//8单链表插入元素
bool InsertList(StudentList * L, int i, Student E)
{
	StudentList * p = L;
	StudentList * q = NULL;
	int n = 0;
	while ((p != NULL) && (n < i - 1))
	{
		n++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else
	{
		q = (StudentList *)malloc(sizeof(StudentList));
		q->Stu = E;
		q->next = p->next;
		p->next = q;
		return true;
	}
}

//9单链表删除元素
bool DeleteList(StudentList * L, int i)
{
	StudentList * p = L;
	StudentList *q = NULL;
	int n = 0;
	while ((p != NULL) && (n < i - 1))
	{
		n++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else
	{
		q = p->next;
		if (q == NULL)
			return false;
		else
		{
			p->next = p->next->next;
			free(q);
			return true;
		}
	}
}
/*************************单链表*************************/


/*************************双链表*************************/
//0尾插法建立双链表
void CreatListR(StudentList * & L, Student Stu[], int n)
{
	StudentList * pre = NULL;
	StudentList * p = NULL;
	int i;
	L = (StudentList *)malloc(sizeof(StudentList));
	pre = L;
	pre->prior = NULL;
	for (i = 0; i < n; i++)
	{
		p = (StudentList *)malloc(sizeof(StudentList));
		p->Stu = Stu[i];
		pre->next = p;
		p->prior = pre;
		pre = pre->next;
	}
	p->next = NULL;
}

//1初始化双链表
void InitList(StudentList * & L)
{
	L = (StudentList *)malloc(sizeof(StudentList));
	L->next = NULL;
	L->prior = NULL;
}

//8双链表插入元素
bool InsertList(StudentList * L, int i, Student E)
{
	StudentList * p = L;
	StudentList * q = NULL;
	int n = 0;
	while ((p != NULL) && (n < i - 1))
	{
		n++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else
	{
		q = (StudentList *)malloc(sizeof(StudentList));
		q->Stu = E;
		q->next = p->next;
		if (p->next != NULL)
			p->next->prior = q;
		p->next = q;
		q->prior = p;
		return true;
	}
}

//9双链表删除元素
bool DeleteList(StudentList * L, int i)
{
	StudentList * p = L;
	StudentList *q = NULL;
	int n = 0;
	while ((p != NULL) && (n < i - 1))
	{
		n++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else
	{
		q = p->next;
		if (q == NULL)
			return false;
		else
		{
			p->next = q->next;
			if (q->next != NULL)
				q->next->prior = p;
			free(q);
			return true;
		}
	}
}
/*************************双链表*************************/

2 栈

2.1 顺序栈

2.1.1 定义类型

#define MaxSize 5

//以Student举例
typedef struct Student
{
	int Num;
	char Sex;
	char * Name;
}Student;

typedef struct StudentStack
{
	Student Stu[MaxSize];
	int top;
}StudentStack;

2.1.2 相关操作

void InitStack(StudentStack * & S);
void DestroyStack(StudentStack * S);
bool StackEmpty(StudentStack * S);
bool PushStack(StudentStack * &S, Student E);
bool PopStack(StudentStack * &S, Student & E);
bool GetTop(StudentStack * S, Student & E);

2.1.3 相关操作的实现

//1初始化栈
void InitStack(StudentStack * & S)
{
	S = (StudentStack *)malloc(sizeof(StudentStack));
	S->top = -1;
}

//2销毁栈
void DestroyStack(StudentStack * S)
{
	free(S);
}

//3判断栈是否为空
bool StackEmpty(StudentStack * S)
{
	return(S->top == -1);
}

//4压栈
bool PushStack(StudentStack * &S, Student E)
{
	if (S->top == (MaxSize - 1))
		return false;
	else
	{
		S->top++;
		S->Stu[S->top] = E;
		return true;
	}
}

//5退栈
bool PopStack(StudentStack * &S, Student &E)
{
	if (S->top == -1)
		return false;
	else
	{
		E = S->Stu[S->top];
		S->top--;
		return true;
	}
}

//6取栈顶元素
bool GetTop(StudentStack *S, Student &E)
{
	if (S->top == -1)
		return false;
	else
	{
		E = S->Stu[S->top];
		return true;
	}
}

2.2 链栈

2.2.1 定义类型

//以Student举例
typedef struct Student
{
	int Num;
	char Sex;
	char * Name;
}Student;

typedef struct StudentStack
{
	Student Stu;
	StudentStack * next;
}StudentStack;

2.2.2 相关操作

void InitStack(StudentStack * & S);
void DestroyStack(StudentStack * S);
bool StackEmpty(StudentStack * S);
void PushStack(StudentStack * &S, Student E);
bool PopStack(StudentStack * &S, Student & E);
bool GetTop(StudentStack * S, Student & E);

2.2.3 相关操作的实现

//1初始化栈
void InitStack(StudentStack * & S)
{
	S = (StudentStack *)malloc(sizeof(StudentStack));
	S->next = NULL;
}

//2销毁栈
void DestroyStack(StudentStack * S)
{
	StudentStack * pre = S, *p = S->next;
	while (p != NULL)
	{
		free(pre);
		pre = p;
		p = p->next;
	}
	free(pre);
}

//3判断栈是否为空
bool StackEmpty(StudentStack * S)
{
	return(S->next == NULL);
}

//4压栈
void PushStack(StudentStack * &S, Student E)
{
	StudentStack * p = NULL;
	p = (StudentStack *)malloc(sizeof(StudentStack));
	p->Stu = E;
	p->next = S->next;
	S->next = p;
}

//5退栈
bool PopStack(StudentStack * &S, Student &E)
{
	StudentStack * p = NULL;
	if (S->next == NULL)
		return false;
	else
	{
		p = S->next;
		E = p->Stu;
		S->next = p->next;
		free(p);
		return true;
	}
}

//6取栈顶元素
bool GetTop(StudentStack * S, Student & E)
{
	if (S->next == NULL)
		return false;
	else
	{
		E = S->next->Stu;
		return true;
	}
}

3 队列

3.1 顺序队列

3.1.1 定义类型

#define MaxSize 5

//以Student举例
typedef struct Student
{
	int Num;
	char Sex;
	char * Name;
}Student;

typedef struct StudentQueue
{
	Student Stu[MaxSize];
	int front;
	int rear;
}StudentQueue;

3.1.2 相关操作

void InitQueue(StudentQueue * & Q);
void DestroyQueue(StudentQueue * & Q);
bool QueueEmpty(StudentQueue * Q);
bool EnQueue(StudentQueue *Q, Student E);
bool DeQueue(StudentQueue *Q, Student &E);

3.1.3 相关操作的实现

/*************************顺序队列*************************/
//1初始化队列
void InitQueue(StudentQueue * & Q)
{
	Q = (StudentQueue *)malloc(sizeof(StudentQueue));
	Q->front = -1;
	Q->rear = -1;
}

//2销毁队列
void DestroyQueue(StudentQueue * & Q)
{
	free(Q);
}

//3判断队列是否为空
bool QueueEmpty(StudentQueue * Q)
{
	return(Q->rear == Q->front);
}

//4进队列
bool EnQueue(StudentQueue *Q, Student E)
{
	if ((Q->rear + 1) == (MaxSize - 1))
		return false;
	else
	{
		Q->rear++;
		Q->Stu[Q->rear] = E;
		return true;
	}
}

//5出队列
bool DeQueue(StudentQueue *Q, Student &E)
{
	if (Q->rear == Q->front)
		return false;
	else
	{
		Q->front++;
		E = Q->Stu[Q->front];
		return true;
	}
}
/*************************顺序队列*************************/



/*************************环形队列*************************/
//1初始化队列
void InitQueue(StudentQueue * & Q)
{
	Q = (StudentQueue *)malloc(sizeof(StudentQueue));
	Q->front = 0;
	Q->rear = 0;
}

//2销毁队列
void DestroyQueue(StudentQueue * & Q)
{
	free(Q);
}

//3判断队列是否为空
bool QueueEmpty(StudentQueue * Q)
{
	return(Q->rear == Q->front);
}

//4进队列
bool EnQueue(StudentQueue *Q, Student E)
{
	if ((Q->rear + 1) % MaxSize == Q->front)
		return false;
	else
	{
		Q->rear = (Q->rear + 1) % MaxSize;
		Q->Stu[Q->rear] = E;
		return true;
	}
}

//5出队列
bool DeQueue(StudentQueue *Q, Student &E)
{
	if (Q->rear == Q->front)
		return false;
	else
	{
		Q->front = (Q->front + 1) % MaxSize;
		E = Q->Stu[Q->front];
		return true;
	}
}
/*************************环形队列*************************/

3.2 链队列

3.2.1 定义类型

#define MaxSize 5

//以Student举例
typedef struct Student
{
	int Num;
	char Sex;
	char * Name;
}Student;

typedef struct StudentNode
{
	Student Stu;
	StudentNode * next;
}StudentNode;

typedef struct StudentQueue
{
	StudentNode * front;
	StudentNode * rear;
}StudentQueue;

3.2.2 相关操作

void InitQueue(StudentQueue * & Q);
void DestroyQueue(StudentQueue * & Q);
bool QueueEmpty(StudentQueue * Q);
void EnQueue(StudentQueue *Q, Student E);
bool DeQueue(StudentQueue *Q, Student &E);

3.2.3 相关操作的实现

//1初始化队列
void InitQueue(StudentQueue * & Q)
{
	Q = (StudentQueue *)malloc(sizeof(StudentQueue));
	Q->front = NULL;
	Q->rear = NULL;
}

//2销毁队列
void DestroyQueue(StudentQueue * & Q)
{
	StudentNode *pre = Q->front;
	StudentNode *p;
	if (pre != NULL)
	{
		p = pre->next;
		while (p != NULL)
		{
			free(pre);
			pre = p;
			p = p->next;
		}
		free(pre);
	}
	free(Q);
	Q = NULL;
}

//3判断队列是否为空
bool QueueEmpty(StudentQueue * Q)
{
	return(Q->rear == NULL);
}

//4进队列
void EnQueue(StudentQueue *Q, Student E)
{
	StudentNode *p = NULL;
	p = (StudentNode *)malloc(sizeof(StudentNode));
	p->Stu = E;
	p->next = NULL;
	if (Q->rear == NULL)
	{
		Q->front = p;
		Q->rear = p;
	}
	else
	{
		Q->rear->next = p;
		Q->rear = p;
	}
}

//5出队列
bool DeQueue(StudentQueue *Q, Student &E)
{
	StudentNode *p = NULL;

	if (Q->rear == NULL)
		return false;
	else
	{
		p = Q->front;
		if (Q->rear == Q->front)
		{
			Q->rear = NULL;
			Q->front = NULL;
		}
		else
			Q->front = p->next;
		E = p->Stu;
		free(p);
		return true;
	}
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。