数据结构：栈和队列

文章目录

  • 一、栈
    • 1.栈的概念及结构
      • 1.栈的概念及结构
      • 2.栈的实现
    • 2.栈的顺序表实现
      • 1.栈的结构体和实现的功能函数
      • 2.栈的初始化，入栈和出栈操作
      • 3.栈的其他操作
    • 3.栈的链表实现
      • 1.栈的结构体和实现的功能函数
      • 2.栈功能函数的实现
  • 二、队列
    • 1.队列的概念及结构
      • 1.队列的概念及结构
      • 2.队列的实现
    • 2.队列的顺序表实现（循环队列）
      • 1.循环队列分析
      • 2.循环队列的结构体和实现的功能函数
      • 2.循环队列初始化和插入
      • 2.循环队列的其他操作
    • 3.队列的链表实现
      • 1.队列的结构体和实现的功能函数
      • 2.队列功能函数的实现
  • 二、栈和队列应用实列：实现简单计算器
    • 1.问题分析
    • 1.代码实现
  • 总结

一、栈

1.栈的概念及结构

1.栈的概念及结构

栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端其称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。
在这里插入图片描述

2.栈的实现

栈的实现一般可以使用数组或者链表实现
栈的数组实现：
在这里插入图片描述
栈的链表实现：
在这里插入图片描述
对比两种方式的插入和删除：数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

2.栈的顺序表实现

1.栈的结构体和实现的功能函数

typedef int STDataType;
typedef struct Stack
{STDataType* data;int top;		// 栈顶int capacity;  // 容量 
}Stack;
void StackInit(Stack* ps);// 初始化栈 
void StackPush(Stack* ps, STDataType data);// 入栈 
void StackPop(Stack* ps);// 出栈 
STDataType StackTop(Stack* ps);// 获取栈顶元素 
int StackSize(Stack* ps);// 获取栈中有效元素个数 
bool StackEmpty(Stack* ps);// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
void StackDestroy(Stack* ps);// 销毁栈

这里我们使用动态开辟的结构，保证栈的空间足够。数组实现我们需要一个变量来保存栈顶元素。栈顶元素也是我们栈中有效元素的个数。

2.栈的初始化，入栈和出栈操作

// 初始化
void StackInit(Stack* ps)
{ps->top = 0;//指向栈顶的位置置为数组的起始位置ps->capacity = 0;//把容量进行初始化ps->data = NULL;//把数据区进行初始化
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{assert(ps);if (ps->top == ps->capacity)//判断空间是否已满，已满就进行扩容{int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//产生新的容量Stack* p = (Stack*)realloc(ps->data, sizeof(Stack)* newcapacity);//进行扩容if (p == NULL)//判断是否扩容成功{perror("realloc");exit(-1);}ps->data = p;//指向扩容后的地址ps->capacity = newcapacity;//更新容量为新的容量}ps->data[(ps->top)++] = data;//把数据弹入栈顶
}
// 出栈 
void StackPop(Stack* ps)
{assert(ps);if (ps->top == 0)//判断是否还有元素{return;}ps->top--;//弹出栈顶元素
}

这里初始化，入栈和出栈操作和顺序表的操作没什么区别。

3.栈的其他操作

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{assert(ps);return ps->data[(ps->top) - 1];//栈顶的前一个位置为我们的栈顶元素，因为我们设置的起始位置从0开始
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{assert(ps);return ps->top;//栈顶元素就是栈中有效元素个数
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{assert(ps);return ps->top == 0;//返回判断结果，等于0则代表没有元素，则返回真。反之则为假。
}
// 销毁栈 
void StackDestroy(Stack* ps)
{assert(ps);free(ps->data);//释放掉我们开辟的数据空间ps->data = NULL;//把指向我们开辟数据的空间指向空ps->top = 0;ps->capacity = 0;
}

这里销毁注意我们的数据区的也要进行空间释放，防止造成空间泄露。
测试代码：

void test1()
{Stack ps;StackInit(&ps);StackPush(&ps, 1);StackPush(&ps, 2);StackPush(&ps, 3);StackPush(&ps, 4);StackPush(&ps, 5);printf("栈顶：%d\n", StackTop(&ps));// 获取栈顶元素 printf("个数：%d\n", StackSize(&ps));// 获取栈中有效元素个数if (!StackEmpty(&ps)){printf("Stack is not NULL\n");}StackPop(&ps);printf("栈顶：%d\n", StackTop(&ps));// 获取栈顶元素 if (!StackEmpty(&ps)){printf("Is not Empty\n");}StackDestroy(&ps);
}
int main()
{test1();//test2();//test3();//test4();//test5();return 0;
}

在这里插入图片描述

3.栈的链表实现

1.栈的结构体和实现的功能函数

typedef int STDataType;
typedef struct StackNode
{STDataType data;struct StackNode* next;  //记录下一个区域的指针
}StackNode;
typedef struct Stack//头节点
{int size;//记录元素的个数StackNode head;
}Stack;
void StackInit(Stack* ps);// 初始化栈 
void StackPush(Stack* ps, STDataType data);// 入栈 
void StackPop(Stack* ps);// 出栈 
STDataType StackTop(Stack* ps);// 获取栈顶元素 
int StackSize(Stack* ps);// 获取栈中有效元素个数 
bool StackEmpty(Stack* ps);// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
void StackDestroy(Stack* ps);// 销毁栈

我们这里和实现双链表一样，设置了一个特殊的头节点。头节点比正常节点多了一个变量用来记录栈中的元素个数，可以避免返回栈的元素个数时对栈进行遍历。

2.栈功能函数的实现

// 初始化栈 
void StackInit(Stack* ps)
{ps->size = 0;//初始元素为0ps->head.next = NULL;//无元素时头节点的下一个指向空ps->head.data = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{assert(ps);StackNode* add = (StackNode*)malloc(sizeof(StackNode));//创建节点if (add == NULL)//判断节点是否创建成功{perror("malloc");exit(-1);}add->data = data;//给节点赋上数据StackNode* pos = &(ps->head);//要取地址add->next = pos->next;//进行头插pos->next = add;ps->size++;
}
// 出栈 
void StackPop(Stack* ps)
{assert(ps);StackNode* pos = &(ps->head);if (pos->next == NULL){return;}StackNode* del = pos->next;//进行头删pos->next = del->next;free(del);ps->size--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{assert(ps);StackNode* pos = (&(ps->head))->next;if (pos == NULL)//判断头指针的下一个是否为空{return;}return pos->data;
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{assert(ps);return ps->size;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{assert(ps);return ps->size == 0;
}
// 销毁栈 
void StackDestroy(Stack* ps)
{assert(ps);StackNode* pos = &(ps->head);if (pos->next == NULL)//判断头指针的下一个是否为空{return;}StackNode* del = pos->next;while (del != NULL){pos->next = del->next;free(del);del = pos->next;}
}

这里就是沿用链表的操作，注意释放节点时避免节点丢失。
测试函数：

void test2()
{Stack ps;StackInit(&ps);StackPush(&ps, 1);StackPush(&ps, 2);StackPush(&ps, 3);StackPush(&ps, 4);StackPush(&ps, 5);printf("栈顶：%d\n", StackTop(&ps));// 获取栈顶元素 printf("个数：%d\n", StackSize(&ps));// 获取栈中有效元素个数if (!StackEmpty(&ps)){printf("Stack is not NULL\n");}StackPop(&ps);printf("栈顶：%d\n", StackTop(&ps));// 获取栈顶元素 StackDestroy(&ps);
}
int main()
{//test1();test2();//test3();//test4();//test5();return 0;
}

在这里插入图片描述

二、队列

1.队列的概念及结构

1.队列的概念及结构

队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特点。进行插入操作的一端称为队尾 ，进行删除操作的一端称为队头。
在这里插入图片描述

2.队列的实现

队列的实现一般可以使用数组或者链表实现
队列的链表实现：
在这里插入图片描述
对比两种方式的插入和删除：使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，需要频繁移动数据，效率会比较低。

2.队列的顺序表实现（循环队列）

由于队列使用数组需要扩容和频繁移动数据，这样的结构并不常用，所以我们用顺序表实现循环的队列。

1.循环队列分析

我们假设数组的大小有五个元素
我们如何判断队列中的元素是否已经满了呢？
在这里插入图片描述
用头位置等于尾位置吗？
在这里插入图片描述
上述一个元素也没有会不会直接判断为数组已满呢？
我们的解决办法是保证一个位置为空，当尾位置等于头位置时即为队列满，即队尾不存储数据。
在这里插入图片描述

2.循环队列的结构体和实现的功能函数

#define MAXNUM 5
typedef int QDataType;
typedef struct QListNode
{QDataType data[5];int head;//对头元素int end;//队尾元素
}QNode;
void QueueInit(QNode* q);// 初始化队列 
void QueuePush(QNode* q, QDataType data);// 队尾入队列 
void QueuePop(QNode* q);// 队头出队列 
QDataType QueueFront(QNode* q);// 获取队列头部元素 
QDataType QueueBack(QNode* q);// 获取队列队尾元素 
int QueueSize(QNode* q);// 获取队列中有效元素个数 
int QueueEmpty(QNode* q);// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
void QueueDestroy(QNode* q);// 销毁队列

2.循环队列初始化和插入

// 初始化队列 
void QueueInit(QNode* q)
{q->head = 0;q->end = 0;
}
// 队尾入队列 
void QueuePush(QNode* q, QDataType data)
{assert(q);if ((q->end - q->head) == (MAXNUM-1))//尾元素和首元素相差最大数量减一个元素代表队列已满{printf("队列已满，无法插入\n");return;}q->data[(q->end) % MAXNUM] = data;q->end++;
}

我们对队列进行插入时要对队尾元素进行取模运算。防止插入时造成越界。

2.循环队列的其他操作

// 队头出队列 
void QueuePop(QNode* q)
{assert(q);if (q->head == q->end)//尾元素和首元素相同证明队列中没有元素{printf("没有元素可以出队\n");return;}q->head++;
}
// 获取队列头部元素 
QDataType QueueFront(QNode* q)
{assert(q);if (q->head == q->end && q->end != 0)//尾元素和首元素相同证明队列中没有元素{printf("没有元素可以查看\n");return -1;}return q->data[(q->head) % MAXNUM];
}
// 获取队列队尾元素 
QDataType QueueBack(QNode* q)
{assert(q);if (q->head == q->end && q->end != 0)//尾元素和首元素相同证明队列中没有元素{printf("没有元素可以查看\n");return -1;}return q->data[(q->end - 1) % MAXNUM];
}
// 获取队列中有效元素个数 
int QueueSize(QNode* q)
{assert(q);return q->end - q->head;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(QNode* q)
{assert(q);return q->head == q->end;
}
// 销毁队列 
void QueueDestroy(QNode* q)
{assert(q);q->head = 0;q->end = 0;
}

我们返回队头队尾数据要看尾是否在0位置，为0代表一个元素还没插入。我们进行插入返回元素的操作都需要进行取模操作！！！
测试函数：

void test3()
{QNode qu;QueueInit(&qu);int i = 0;for(i = 0; i < 5; i++){QueuePush(&qu, i);}printf("队头：%d\n", QueueFront(&qu));printf("队尾：%d\n", QueueBack(&qu));QueuePop(&qu);printf("队头：%d\n", QueueFront(&qu));printf("个数：%d\n", QueueSize(&qu));printf("为空：%d\n", QueueEmpty(&qu));QueuePop(&qu);QueuePop(&qu);QueuePop(&qu);QueuePop(&qu);QueueDestroy(&qu);
}
int main()
{//test1();//test2();test3();//test4();//test5();return 0;
}

在这里插入图片描述

3.队列的链表实现

1.队列的结构体和实现的功能函数

typedef int QDataType;
typedef struct QListNode
{QDataType data;struct QListNode* next;
}QNode;
// 队列的结构 
typedef struct Queue
{QNode* head;QNode* end;
}Queue;
void QueueInit(Queue* q);// 初始化队列 
void QueuePush(Queue* q, QDataType data);// 队尾入队列 
void QueuePop(Queue* q);// 队头出队列 
QDataType QueueFront(Queue* q);// 获取队列头部元素 
QDataType QueueBack(Queue* q);// 获取队列队尾元素 
int QueueSize(Queue* q);// 获取队列中有效元素个数 
int QueueEmpty(Queue* q);// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
void QueueDestroy(Queue* q);// 销毁队列

我们设置了一个结构体用来存储头节点和尾节点，目的是为了减少遍历。

2.队列功能函数的实现

 //初始化队列 
void QueueInit(Queue* q)
{assert(q);q->head = NULL;q->end = NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{assert(q);QNode* pos = (QNode*)malloc(sizeof(QNode));if (pos == NULL){perror("malloc");exit(-1);}pos->data = data;pos->next = NULL;if (q->end == NULL){q->head = pos;q->end = pos;}else{q->end->next = pos;q->end = q->end->next;}
}
// 队头出队列 
void QueuePop(Queue* q)
{assert(q);QNode* del = q->head;if (q->head == q->end && q->end != NULL)//当头指针等于尾指针时证明队列中没有元素{printf("没有元素可以出队\n");return;}q->head = q->head->next;free(del);
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{assert(q);if (q->head == q->end && q->end != NULL)//当头指针等于尾指针时证明队列中没有元素{printf("没有元素可以查看\n");return -1;}return q->head->data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{assert(q);if (q->head == q->end && q->end != NULL)//当头指针等于尾指针时证明队列中没有元素{printf("没有元素可以查看\n");return -1;}return q->end->data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{assert(q);int size = 0;QNode* pos = q->head;while (pos != q->end){size++;pos = pos->next;}return size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{assert(q);return q->head == q->end;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{assert(q);QNode* del = q->head;while (del != q->end){q->head = del->next;free(del);del = q->head;}free(q->head);q->head = NULL;q->end = NULL;
}

测试函数：

void test4()
{Queue qu;QueueInit(&qu);int i = 0;for(i = 0; i < 5; i++){QueuePush(&qu, i);}printf("队头：%d\n", QueueFront(&qu));printf("队尾：%d\n", QueueBack(&qu));QueuePop(&qu);printf("队头：%d\n", QueueFront(&qu));printf("个数：%d\n", QueueSize(&qu));printf("为空：%d\n", QueueEmpty(&qu));QueuePop(&qu);QueuePop(&qu);QueuePop(&qu);QueuePop(&qu);QueueDestroy(&qu);
}
int main()
{//test1();//test2();//test3();test4();//test5();return 0;
}

在这里插入图片描述

二、栈和队列应用实列：实现简单计算器

计算10+(10+20*30)*4-50

1.问题分析

我们计算需要进行优先级比较，是否含有括号，数据的存储等，我们需要两个栈来进行存储，一个符号栈，一个数字栈。
在这里插入图片描述
思路分析：
在这里插入图片描述

1.代码实现

void Count(Stack* num, int headsign)
{int n1 = 0;//用于计算的变量1int n2 = 0;//用于计算的变量2//已经是指针了，不可以在取地址了n2 = StackTop(num);//n2先进性出栈StackPop(num);//数字出栈n1 = StackTop(num);//n2出栈是为了防止除法是顺序错乱StackPop(num);//数字出栈int sum = 0;//用来存储两个值的结果switch (headsign)//判断符号{case '+':sum = n1 + n2;break;case '-':sum = n1 - n2;break;case '*':sum = n1 * n2;break;case '/':sum = n1 / n2;break;default:exit(-1);//未知符号，程序退出}//入数字栈StackPush(num, sum);
}
void Match_Brace(Stack* sign, Stack* num)//开始匹配左括号
{int headsign = 0;//存储栈顶的元素符号headsign = StackTop(sign);//获取栈顶元素符号while(!StackEmpty(sign))//符号栈不为空则一直进行循环， 直到在左括号处结束{if (headsign == '(')//如果为左括号则直接出栈结束{StackPop(sign);//符号出栈break;}else{//计算Count(num, headsign);//计算函数StackPop(sign);//符号出栈}headsign = StackTop(sign);//获取栈顶元素符号}
}
int Priority(int symbol)
{switch (symbol)//判断符号{case '(':return 0;case '+':case '-':return 1;case '*':case '/':return 2;default:exit(-1);//未知符号，程序退出}
}
void Match_Symbols(Stack* sign, Stack* num, int symbol)
{if (StackEmpty(sign) || symbol == '(')//如果栈为空或者为左括号，则直接入栈{StackPush(sign, symbol);//入栈return;}int headsign = 0;//存储栈顶的元素符号headsign = StackTop(sign);//获取栈顶元素符号if (Priority(symbol) > Priority(headsign))//优先级比较,该符号优先级高则直接入栈{StackPush(sign, symbol);//入栈return;}while(Priority(symbol) <= Priority(headsign))//直到优先级高于栈顶元素，停止循环{//计算Count(num, headsign);//计算函数StackPop(sign);//栈顶符号出栈if (StackEmpty(sign))//栈为空则退出循环{break;}headsign = StackTop(sign);//获取栈顶元素符号}StackPush(sign, symbol);//入栈
}
void test5()
{Stack num;//存储数字所使用的栈Stack sign;//存储算数符号所用的栈StackInit(&num);//对数字栈进行初始化StackInit(&sign);//对符号栈进行初始化char* s = "10+(10+20*30)*4-50";//要计算的表达式int i = 0;//用来判断表达式是否已到结尾int sum = 0;//用来存储一个整形数据int flag = 0;//用来判断是否取完一个整形元素while (s[i] != '\0'){if (isdigit(s[i]))//判断是否为数字{sum = sum * 10 + (s[i] - '0');//更新sum的值flag = 1;//把标志位置为1，为后面判断是否入栈准备}else{if (flag == 1)//判断该数字是否以入栈{//入数字栈StackPush(&num, sum);flag = 0;//更新标志位sum = 0;//更新sum值，防止下次计算时出错}if (s[i] == ')')//开始匹配左括号{//进行出栈匹配左括号Match_Brace(&sign, &num);}else//字符为（ + - * /{//进行优先级比较Match_Symbols(&sign, &num,s[i]);}}i++;}if (flag == 1)//判断该数字是否以入栈{//入数字栈StackPush(&num, sum);flag = 0;//更新标志位sum = 0;//更新sum值，防止下次计算时出错}int headsign = 0;//存储栈顶的元素符号while (!StackEmpty(&sign))//符号栈不为空则一直进行计算{headsign = StackTop(&sign);//获取栈顶元素符号//计算Count(&num, headsign);StackPop(&sign);//符号出栈}printf("%d\n", StackTop(&num));StackDestroy(&num);//销毁数字栈StackDestroy(&sign);//销毁字符栈
}
int main()
{//test1();//test2();//test3();//test4();test5();return 0;
}

在这里插入图片描述
注意函数对指针的二次传参不需要在进行取地址，在计算机中计算机识别的是字符，所以我们需要一个字符一个字符的进行，这时间需要我们判断这个数字到底几位数，需要我们一个临时量，也可以用库函数atoi实现。其他按照思路可以轻而易举的实现。

总结

栈和队列都是含有限制的线性表。前面的知识扎实的话实现栈和队列没有一点问题。都是顺序表和链表的其中一部分。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/99733.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

java面向对象——继承以及super关键字

java面向对象——继承以及super关键字

继承的概念 1. 被继承的类称为父类&#xff08;超类&#xff09;&#xff0c;继承父类的类都称为子类&#xff08;派生类&#xff09; 2. 继承是指一个对象直接使用另一个对象的属性和方法&#xff0c;但是能继承非私有的属性和方法&#xff1b;(1) 构造方法不能被继承。(2) 但…
阅读更多...
商城-学习整理-高级-商城业务-异步线程池（十三）

商城-学习整理-高级-商城业务-异步线程池（十三）

目录 一、线程1、初始化线程的 4 种方式2、线程池的七大参数3、线程池的运行流程&#xff1a;4、例子5、常见的 4 种线程池6、开发中为什么使用线程池 二、CompletableFuture 异步编排0、业务场景&#xff1a;1、创建异步对象2、计算完成时回调方法3、handle 方法4、线程串行化…
阅读更多...
【无监督】6、SimSiam | 基于孪生网络的对比学习的成功源于梯度截断！

【无监督】6、SimSiam | 基于孪生网络的对比学习的成功源于梯度截断！

文章目录 一、背景二、方法三、效果 论文&#xff1a;Exploring Simple Siamese Representation Learning 出处&#xff1a;FAIR | 何恺明大佬 本文作者抛出了两个爆炸&#x1f4a5;性结论&#xff1a; 结论一&#xff1a;基于孪生网络的对比的学习的成功&#xff0c;不源于 …
阅读更多...
亚马逊云科技 云技能孵化营——机器学习心得

亚马逊云科技 云技能孵化营——机器学习心得

亚马逊云科技 云技能孵化营机器学习心得 前言什么是机器学习&#xff1f;机器学习如何解决业务问题&#xff1f;什么时候适合使用机器学习模型&#xff1f;总结 前言 很荣幸参加了本次亚马逊云科技云技能孵化营&#xff0c;再本期的《亚马逊云科技云技能孵化营》中&#xff0c…
阅读更多...
Leetcode-每日一题【剑指 Offer 33. 二叉搜索树的后序遍历序列】

Leetcode-每日一题【剑指 Offer 33. 二叉搜索树的后序遍历序列】

题目 输入一个整数数组&#xff0c;判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true&#xff0c;否则返回 false。假设输入的数组的任意两个数字都互不相同。 参考以下这颗二叉搜索树&#xff1a; 5 / \ 2 6 / \ 1 3 示例 1&#xff1a; 输入: […
阅读更多...
基于樽海鞘群算法优化的BP神经网络（预测应用） - 附代码

基于樽海鞘群算法优化的BP神经网络（预测应用） - 附代码

基于樽海鞘群算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码 文章目录 基于樽海鞘群算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码1.数据介绍2.樽海鞘群优化BP神经网络2.1 BP神经网络参数设置2.2 樽海鞘群算法应用 4.测试结果&#xff1a;5…
阅读更多...
Flink内核源码解析--Flink中重要的工作组件和机制

Flink内核源码解析--Flink中重要的工作组件和机制

Flink内核源码 1、掌握Flink应用程序抽象2、掌握Flink核心组件整体架构抽象3、掌握Flink Job三种运行模式4、理解Flink RPC网络通信框架Akka详解5、理解TaskManager为例子&#xff0c;分析Flink封装Akka Actor的方法和整个调用流程6、理解Flink高可用服务HighAvailabilityServ…
阅读更多...
初识网络原理（笔记）

初识网络原理（笔记）

目录 ​编辑局域网 网络通信基础 IP 地址 端口号 协议 协议分层 TCP / IP 五层网络模型 网络数据传输的基本流程 发送方的情况&#xff1a; 接收方的情况 局域网 搭建网络的时候&#xff0c;需要用到 交换机 和 路由器 路由器上&#xff0c;有 lan 口 和 wan 口 虽…
阅读更多...
基础恢复1-c语言

基础恢复1-c语言

用书&#xff1a;c primer plus 学习时间&#xff1a;21-25 重点知识&#xff1a; 1.编译-链接-运行 编译&#xff1a;编译器将源码转换为可执行代码 链接&#xff1a;编译器从c库中获取标准例程放入源码中一同编译 运行&#xff1a;运行可执行文件 2.关键字 数据类型&…
阅读更多...
Android oaid

Android oaid

官方GitHub地址 https://github.com/gzu-liyujiang/Android_CN_OAID 生成和用途介绍 https://www.jianshu.com/p/1c7ef27d6db4 图片来源于上述网站 其他关于id的介绍 https://www.cnblogs.com/chenKnowledgeConllection/p/17380960.html https://zhuanlan.zhihu.com/p/55…
阅读更多...
分享图片 | 快速浏览网页资源，批量保存、一键分享图片

分享图片 | 快速浏览网页资源，批量保存、一键分享图片

前言 小伙伴学习吉他&#xff0c;有时需要在互联网搜索曲谱资源&#xff0c;而多数曲谱均为图片&#xff0c;并且为多页&#xff0c;在电脑上显示练习很不方便&#xff0c;需要停下来点击鼠标进行翻页&#xff0c;影响练习的连贯性。 为了解决上述问题&#xff0c;通常把图片…
阅读更多...
博客系统之单元测试

博客系统之单元测试

对博客系统进行单元测试 1、测试查找已存在的用户 测试名称 selectByUsernameTest01 测试源码 //查找用户&#xff0c;存在 Test public void selectByUsernameTest01 () { UserDao userDao new UserDao(); String ret1 userDao.selectByUsername("张三").toStr…
阅读更多...
MYSQL完全卸载、安装与账号创建、权限控制

MYSQL完全卸载、安装与账号创建、权限控制

一、卸载mysql CentOS 卸载 MySQL 1. 查看安装情况 使用以下命令查看当前安装mysql情况&#xff0c;查找以前是否装有mysql rpm -qa|grep -i mysql这里显示我安装的 MySQL 服务有有&#xff1a; 2. 停止 mysql 服务、删除之前安装的 mysql 删除命令&#xff1a;rpm -e –n…
阅读更多...
Eslint error, configuration for rule “import/no-cycle“ is invalid

Eslint error, configuration for rule “import/no-cycle“ is invalid

可以参考stackoverflow.comEslint error, configuration for rule "import/no-cycle" is invalid他的意思是有个∞符号不支持&#xff0c;解决方案&#xff0c;把 eslint-plugin-import 的版本增加到 ^2.22.1&#xff0c;重新下载依赖包如&#xff1a;
阅读更多...
学习笔记230804---restful风格的接口，delete的传参方式问题

学习笔记230804---restful风格的接口，delete的传参方式问题

如果后端提供的删除接口是restful风格&#xff0c;那么使用地址栏拼接的方式发送请求&#xff0c;数据放在主体中&#xff0c;后端接受不到&#xff0c;当然也还有一种可能&#xff0c;后端在这个接口的接参设置上是req.query接参。 问题描述 今天遇到的问题是&#xff0c;de…
阅读更多...
（二）结构型模式：7、享元模式（Flyweight Pattern）（C++实例）

（二）结构型模式：7、享元模式（Flyweight Pattern）（C++实例）

目录 1、享元模式&#xff08;Flyweight Pattern&#xff09;含义 2、享元模式的UML图学习 3、享元模式的应用场景 4、享元模式的优缺点 5、C实现享元模式的简单实例 1、享元模式&#xff08;Flyweight Pattern&#xff09;含义 享元模式&#xff08;Flyweight&#xff09…
阅读更多...
常用系统命令

常用系统命令

重定向 cat aa.txt > bbb.txt 将输出定向到bbb.txt cat aaa.txt >> bbb.txt 输出并追加查看进程 ps ps -ef 显示所有进程 例⼦&#xff1a;ps -ef | grep mysql |&#xff1a;管道符 kill pid 结束进程&#xff0c; 如 kill 3732&#xff1b;根据进程名结束进程可以先…
阅读更多...
20英镑以上免费吗？英国亚马逊上调当日达订单免配送费门槛！

20英镑以上免费吗？英国亚马逊上调当日达订单免配送费门槛！

据外媒报道&#xff0c;英国亚马逊向Prime会员发送了一封电子邮件&#xff0c;通知他们从下个月开始必须为小额当日达订单支付运费。 亚马逊在向Prime用户发送的电子邮件中称&#xff0c;目前&#xff0c;其向符合条件的邮政编码内的Prime会员提供免费当日送达服务。 不过&am…
阅读更多...
vue 实现图片懒加载

vue 实现图片懒加载

一&#xff1a;懒加载的目的 有些页面可能展示的是大量的图片&#xff0c;如果我们一次性加载所有图片就会浪费性能&#xff0c;影响用户体验&#xff0c;所以我们就会懒加载这些图片。即可视区域之外的图片不加载&#xff0c;随着页面的滚动&#xff0c;图片进入可视区域&…
阅读更多...
Appium Desktop安装

Appium Desktop安装

【提示&#xff1a;官方已不再维护&#xff0c;建议命令行方式安装&#xff0c;但可以学习了解一下】 Appium Desktop是一款适用于Mac、Windows和Linux的应用程序&#xff0c;它以漂亮灵活的UI为您提供Appium自动化服务器的强大功能。它基本上是Appium Server的图形界面。您可…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023