数据结构期末复习（3）栈和队列

堆栈（stack）

在这里插入图片描述

在这里插入图片描述

堆栈（stack）是一种基于后进先出（LIFO，Last In First Out）原则的数据结构。它模拟了现实生活中的堆栈，类似于一摞盘子或一堆书。

堆栈有两个基本操作：入栈（push）和出栈（pop）。

  1. 入栈（push）：将新元素添加到堆栈的顶部。新元素成为当前堆栈的最上面一个元素。
  2. 出栈（pop）：从堆栈的顶部移除最上面的元素，并返回该元素的值。

除了这两个基本操作外，堆栈还可以支持其他常用操作，例如：

  • 栈顶（top）：获取堆栈的顶部元素，但不移除它。
  • 判空（isEmpty）：检查堆栈是否为空。
  • 获取大小（size）：获取堆栈中元素的数量。

实际上，堆栈可以通过数组或链表来实现。

使用数组实现的堆栈称为顺序堆栈（array-based stack）。在顺序堆栈中，数组的末尾被用作栈顶，每次入栈操作都会将元素放置在数组末尾，而出栈操作则会从数组末尾移除元素。
在这里插入图片描述

使用链表实现的堆栈称为链式堆栈（linked stack）。在链式堆栈中，每个节点包含一个元素和一个指向下一个节点的引用。入栈操作将在链表头部插入新节点，而出栈操作则会移除链表头部的节点。

堆栈在计算机科学中有广泛的应用。例如，在编程中，堆栈常用于函数调用的过程中，每当一个函数被调用时，其相关信息（如参数、局部变量等）都会被压入堆栈中，当函数执行完毕后，这些信息又会被弹出堆栈。这种方式使得程序可以追踪函数的嵌套调用，并正确恢复执行状态。

堆栈还被用于解决许多其他问题，如括号匹配、表达式求值、深度优先搜索算法、回溯算法等。其简单性和高效性使得堆栈成为一种重要的数据结构。

在这里插入图片描述

后缀表达式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

堆栈的抽象数据描述

堆栈（stack）是一种抽象数据类型（ADT），用于描述具有后进先出（LIFO，Last In First Out）特性的数据结构。它定义了以下操作：

  1. 初始化（Initialize）：创建一个空的堆栈。
  2. 入栈（Push）：将一个新元素添加到堆栈的顶部。
  3. 出栈（Pop）：从堆栈的顶部移除最上面的元素，并返回该元素的值。
  4. 栈顶（Top）：获取堆栈的顶部元素，但不移除它。
  5. 判空（IsEmpty）：检查堆栈是否为空。
  6. 获取大小（Size）：获取堆栈中元素的数量。

这些操作定义了堆栈的基本行为和特点。使用这些操作，可以实现各种具体的堆栈实现，如基于数组或链表的实现。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
[例] 如果三个字符按ABC顺序压入堆栈
• ABC的所有排列都可能
是出栈的序列吗？
• 可以产生CAB这样的序
列吗？

在递归的过程中，我们维护一个栈和一个指向原始字符序列的指针。如果当前栈顶元素与指针指向的元素相同，则可以将其出栈；否则，需要将指针指向的元素入栈。当原始字符序列中的所有元素都已经被入栈后，我们可以逐步将栈中的元素出栈，从而得到一种可能的出栈序列。

使用上述方法，我们可以得到所有可能的出栈序列。如果其中包含了以CAB为开头的序列，那么就说明CAB是一种可能的出栈序列。否则，就不能产生CAB这样的序列。

总结：按照ABC的顺序依次压入堆栈，其所有可能的出栈序列有6种，分别是ABC、ACB、BAC、BCA、CBA和CAB。因此，CAB是一种可能的出栈序列。

栈的顺序存储实现

在这里插入图片描述

在这里插入图片描述

#define MAXSIZE 100 // 定义栈的最大容量typedef struct {ElementType data[MAXSIZE]; // 用数组存储栈元素int top; // 栈顶指针，指向当前栈顶元素的位置
} Stack;// 初始化栈
void InitStack(Stack *S) {S->top = -1; // 初始化栈顶指针为-1，表示空栈
}// 判断栈是否为空
int IsEmpty(Stack *S) {return (S->top == -1);
}// 判断栈是否已满
int IsFull(Stack *S) {return (S->top == MAXSIZE - 1);
}// 入栈操作
void Push(Stack *S, ElementType item) {if (IsFull(S)) {printf("Stack is full. Cannot push element %d.\n", item);} else {S->data[++(S->top)] = item;}
}// 出栈操作
ElementType Pop(Stack *S) {if (IsEmpty(S)) {printf("Stack is empty. Cannot pop element.\n");return ERROR; // ERROR可以是一个预定义的错误值} else {return S->data[(S->top)--];}
}// 获取栈顶元素
ElementType GetTop(Stack *S) {if (IsEmpty(S)) {printf("Stack is empty. No top element.\n");return ERROR;} else {return S->data[S->top];}
}

在这里插入图片描述
在这里插入图片描述

堆栈的链式存储实现

在这里插入图片描述
在这里插入图片描述

typedef struct StackNode {ElementType data; // 数据域struct StackNode *next; // 指针域，指向下一个节点
} StackNode;typedef struct {StackNode *top; // 栈顶指针，指向当前栈顶元素
} LinkedStack;// 初始化栈
void InitStack(LinkedStack *S) {S->top = NULL; // 初始化栈顶指针为空，表示空栈
}// 判断栈是否为空
int IsEmpty(LinkedStack *S) {return (S->top == NULL);
}// 入栈操作
void Push(LinkedStack *S, ElementType item) {StackNode *newNode = (StackNode *)malloc(sizeof(StackNode)); // 创建新节点newNode->data = item; // 设置新节点的数据域为要入栈的元素newNode->next = S->top; // 将新节点插入到栈顶S->top = newNode; // 更新栈顶指针
}// 出栈操作
ElementType Pop(LinkedStack *S) {if (IsEmpty(S)) {printf("Stack is empty. Cannot pop element.\n");return ERROR; // ERROR可以是一个预定义的错误值} else {StackNode *temp = S->top; // 保存当前栈顶节点ElementType item = temp->data; // 获取栈顶元素的值S->top = temp->next; // 更新栈顶指针free(temp); // 释放原栈顶节点return item;}
}// 获取栈顶元素
ElementType GetTop(LinkedStack *S) {if (IsEmpty(S)) {printf("Stack is empty. No top element.\n");return ERROR;} else {return S->top->data;}
}

在这里插入图片描述

堆栈应用：表达式求值

当涉及到表达式求值时，我们可以考虑使用堆栈的应用。以下是一个更复杂的例子来演示如何使用堆栈进行中缀表达式的求值。

假设我们要求解的表达式为中缀表达式：(3 + 4) * 5 - 6 / 2

  1. 创建一个空栈和运算符优先级字典。
  2. 从左到右遍历中缀表达式中的每个元素。
  3. 如果当前元素是数字，则将其转换为整数并直接入栈。
  4. 如果当前元素是运算符，进行以下操作：
    • 如果栈为空或者栈顶元素是左括号"("，则将当前运算符入栈。
    • 如果栈不为空，并且当前运算符的优先级大于栈顶运算符的优先级，则将当前运算符入栈。
    • 如果栈不为空，并且当前运算符的优先级小于等于栈顶运算符的优先级，则弹出栈顶运算符并进行计算，并将计算结果入栈。重复此步骤直到满足条件，然后将当前运算符入栈。
    • 如果当前元素是右括号")“，则弹出栈顶运算符并进行计算，直到遇到左括号”(“。左括号”("从栈中弹出，但不进行计算。
  5. 当遍历完中缀表达式后，将栈中剩余的运算符依次弹出并进行计算。
  6. 栈中仅剩下一个元素，即为表达式的计算结果。

以下是对中缀表达式(3 + 4) * 5 - 6 / 2求值的具体步骤：

  1. 创建一个空栈和运算符优先级字典（加法和减法优先级为1，乘法和除法优先级为2）。
  2. 遍历到"("，将其入栈。
  3. 遍历到3，将其转换为整数并入栈。
  4. 遍历到"+“，栈顶是”(“，将”+"入栈。
  5. 遍历到4，将其转换为整数并入栈。
  6. 遍历到")“，弹出栈顶运算符”+"并进行计算，得到3+4=7，并将计算结果7入栈。
  7. 遍历到"“，栈顶元素是7，优先级大于”“，将”*"入栈。
  8. 遍历到5，将其转换为整数并入栈。
  9. 遍历到"-“，栈顶元素是”“，优先级小于等于”-“，弹出栈顶运算符”"并进行计算，得到7*5=35，并将计算结果35入栈。
  10. 遍历到6，将其转换为整数并入栈。
  11. 遍历到"/“，栈顶元素是6，优先级小于等于”/“，弹出栈顶运算符”/"并进行计算，得到6/2=3，并将计算结果3入栈。
  12. 遍历完中缀表达式后，栈中仅剩下一个元素35-3，即为表达式的计算结果。

因此，中缀表达式(3 + 4) * 5 - 6 / 2的值为32。

中缀表达式如何转换为后缀表达式

将中缀表达式转换为后缀表达式的一种常用方法是使用栈。

以下是转换过程的步骤：

  1. 创建一个空栈和一个空列表，用于存储后缀表达式。
  2. 从左到右遍历中缀表达式中的每个元素。
  3. 如果当前元素是数字或字母，则直接添加到后缀表达式列表的末尾。
  4. 如果当前元素是左括号"("，则将其入栈。
  5. 如果当前元素是右括号")“，则将栈中的元素弹出并添加到后缀表达式列表，直到遇到左括号”("。然后将左括号从栈中弹出，但不将其添加到后缀表达式列表中。
  6. 如果当前元素是运算符（如"+", “-”, “*”, "/"等），则进行以下操作：
    • 如果栈为空，则将当前运算符入栈。
    • 如果栈不为空，并且栈顶元素是左括号"("，则将当前运算符入栈。
    • 如果栈不为空，并且当前运算符的优先级小于等于栈顶运算符的优先级，则将栈顶运算符弹出并添加到后缀表达式列表，重复此步骤直到满足条件，然后将当前运算符入栈。
    • 如果栈不为空，并且当前运算符的优先级大于栈顶运算符的优先级，则将当前运算符入栈。
  7. 当遍历完中缀表达式后，将栈中剩余的运算符依次弹出并添加到后缀表达式列表。
  8. 后缀表达式列表即为转换后的后缀表达式。

以下是一个示例：

中缀表达式：2 + 3 * 4

转换过程：

  1. 遍历到2，直接添加到后缀表达式列表。
  2. 遍历到+，栈为空，将其入栈。
  3. 遍历到3，直接添加到后缀表达式列表。
  4. 遍历到*，栈不为空，栈顶是+，将*入栈。
  5. 遍历到4，直接添加到后缀表达式列表。
  6. 遍历完中缀表达式，将栈中剩余的运算符+和*依次弹出并添加到后缀表达式列表。

转换后的后缀表达式：2 3 4 * +

因此，中缀表达式2 + 3 * 4可以转换为后缀表达式2 3 4 * +。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

队列

队列（Queue）是一种线性数据结构，它具有先进先出（FIFO）的特性。队列可以看作是一个有头有尾的队伍，新元素被添加到队尾，而删除元素则从队头进行。在队列中，数据元素的插入操作叫做入队（enqueue），删除操作则叫做出队（dequeue）。队列常用于操作系统调度、消息传递、任务处理等场景。

队列可以使用数组或者链表来实现。使用数组实现时，需要维护队头和队尾指针，以便快速进行入队和出队操作；使用链表实现时，则只需要维护队头和队尾节点即可。

在队列中，还有一些其他的操作，例如获取队头元素（peek）、判断队列是否为空（isEmpty）等。同时，队列还可以分为普通队列和优先级队列，后者可以根据元素的优先级来进行出队操作。
在这里插入图片描述
在这里插入图片描述

队列的基本操作

在这里插入图片描述
详细的队列操作如下：

  1. 初始化队列（initQueue）：创建一个空队列，并进行必要的初始化工作，例如设置队头和队尾指针为 NULL。
void initQueue(Queue *q) {q->front = q->rear = NULL;
}
  1. 入队操作（enqueue）：将新元素插入到队列的队尾，使其成为新的队尾元素。
void enqueue(Queue *q, int data) {Node *newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if (q->front == NULL) { // 如果队列为空，新节点同时也成为队头节点q->front = q->rear = newNode;} else {q->rear->next = newNode; // 将新节点插入到队尾q->rear = newNode; // 更新队尾指针}
}
  1. 出队操作（dequeue）：删除队列的队头元素，并返回该元素的值。如果队列为空，则出队操作失败。
int dequeue(Queue *q) {if (q->front == NULL) { // 如果队列为空，出队失败printf("Queue is empty!\n");return -1;}int data = q->front->data; // 获取队头元素的值Node *temp = q->front;q->front = temp->next; // 将队头指针指向下一个节点free(temp); // 释放原队头节点的内存空间if (q->front == NULL) { // 如果队列为空，更新队尾指针q->rear = NULL;}return data;
}
  1. 获取队头元素（front）：返回队列的队头元素的值，但不删除该元素。
int front(Queue *q) {if (q->front == NULL) { // 如果队列为空，返回错误值printf("Queue is empty!\n");return -1;}return q->front->data; // 返回队头元素的值
}
  1. 判断队列是否为空（isEmpty）：检查队列是否为空，即判断队列的队头指针是否为 NULL。
bool isEmpty(Queue *q) {return (q->front == NULL); // 如果队头指针为空，则队列为空
}
  1. 清空队列（clearQueue）：释放队列中所有节点的内存空间，并将队头和队尾指针设置为 NULL，使队列变为空队列。
void clearQueue(Queue *q) {Node *temp;while (q->front != NULL) {temp = q->front;q->front = temp->next;free(temp);}q->rear = NULL; // 将队尾指针置为 NULL
}

这些是队列的详细操作，可以根据实际需求进行使用和扩展。注意，在使用完队列后，需要调用清空队列的函数来释放内存空间。

队列的存储结构

在这里插入图片描述
队列有两种常见的存储结构：数组（顺序队列）和链表（链式队列）。

  1. 数组实现的顺序队列：
    顺序队列使用数组作为底层存储结构，通过数组的下标来表示元素在队列中的位置。需要两个指针，分别指向队头和队尾元素。队头指针指向队列的第一个元素，队尾指针指向队列最后一个元素的下一个位置。

优点：简单、易于实现和理解，占用连续的内存空间，访问元素方便。
缺点：如果队列长度不固定，会浪费一部分空间。

  1. 链表实现的链式队列：
    链式队列使用链表作为底层存储结构，每个节点包含数据元素和指向下一个节点的指针。需要两个指针，分别指向队头和队尾节点。

优点：没有长度限制，可以动态地分配内存，节省空间。
缺点：访问元素时需要遍历链表，稍微复杂一些。

无论是顺序队列还是链式队列，它们都支持队列的基本操作，如入队、出队、获取队头元素、判断队列是否为空等。选择使用哪种存储结构取决于具体的需求和使用场景。

队列的假溢出

在这里插入图片描述

队列的假溢出（False Overflow）是指当队列未满时，仍然无法插入新元素的情况。这通常发生在使用数组实现的循环队列中，当队列尾指针 rear 指向数组的最后一个位置后，如果队头指针 front 也指向数组的最后一个位置，则队列被认为已满。

举个例子，假设有一个长度为5的循环队列，初始时 front = rear = 0，队列中已经存在3个元素。此时，队列的状态如下：

[1, 2, 3, _, _]^           ^front       rear

如果此时要入队一个新元素，即使队列中还有空闲位置，也无法插入新元素，因为 rear 指针已经指向数组的最后一个位置，而 front 也指向了同样的位置，导致假溢出。

解决假溢出问题的方法是使用循环队列。当 rear 指针到达数组末尾时，将其重新指向数组的起始位置，使得队列能够循环利用数组空间。

在上述的例子中，如果要入队一个新元素，可以将 rear 指针从数组末尾位置移到数组起始位置，然后插入新元素：

[_, _, 3, 4, _]^     ^rear   front

这样，假溢出的问题就得到了解决。循环队列的实现可以通过取模运算来实现，以保证 rear 和 front 指针始终在合法范围内。

循环队列

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
循环队列是一种使用数组实现的队列，通过循环利用数组的空间来解决假溢出的问题。循环队列的关键是要使用取模运算来计算队列的下标，以保证队列的循环性质。

循环队列通常由以下几个属性组成：

  • 一个固定大小的数组，用于存储队列元素。
  • 两个指针，分别指向队头和队尾元素在数组中的位置。
  • 一个计数器，用于记录当前队列中元素的个数。

下面是循环队列的一些基本操作：

  1. 初始化队列（initQueue）：创建一个空队列，并进行必要的初始化工作，例如设置队头和队尾指针为初始位置，计数器为零。
void initQueue(CircularQueue *q) {q->front = 0;q->rear = 0;q->count = 0;
}
  1. 入队操作（enqueue）：将新元素插入到队列的队尾，并更新队尾指针和计数器。
void enqueue(CircularQueue *q, int data) {if (q->count == MAX_SIZE) { // 队列已满，无法插入新元素printf("Queue is full!\n");return;}q->data[q->rear] = data; // 插入新元素到队尾位置q->rear = (q->rear + 1) % MAX_SIZE; // 更新队尾指针q->count++; // 增加计数器
}
  1. 出队操作（dequeue）：删除队列的队头元素，并返回该元素的值。如果队列为空，则出队操作失败。
int dequeue(CircularQueue *q) {if (q->count == 0) { // 队列为空，无法删除元素printf("Queue is empty!\n");return -1;}int data = q->data[q->front]; // 获取队头元素的值q->front = (q->front + 1) % MAX_SIZE; // 更新队头指针q->count--; // 减少计数器return data;
}
  1. 获取队头元素（front）：返回队列的队头元素的值，但不删除该元素。
int front(CircularQueue *q) {if (q->count == 0) { // 队列为空，返回错误值printf("Queue is empty!\n");return -1;}return q->data[q->front]; // 返回队头元素的值
}
  1. 判断队列是否为空（isEmpty）：检查队列是否为空，即判断计数器是否为零。
bool isEmpty(CircularQueue *q) {return (q->count == 0); // 如果计数器为零，则队列为空
}

循环队列的实现通过使用取模运算来循环利用数组空间，使得队列能够重复使用数组中的位置。这种实现方式可以有效地解决假溢出问题，并且在时间复杂度上具有较好的性能。

队伍的链式存储结构

在这里插入图片描述

队列的链式存储结构使用链表来实现队列的基本操作。每个节点包含一个数据元素和一个指向下一个节点的指针。队列的头部指向链表的第一个节点，队列的尾部指向链表的最后一个节点。

链式存储结构的队列相比于数组实现的循环队列，具有更灵活的空间管理和动态扩展的能力。下面是队列链式存储结构的一些基本操作：

  1. 定义队列节点结构体：
typedef struct Node {int data;struct Node* next;
} Node;
  1. 初始化队列（initQueue）：创建一个空队列，并进行必要的初始化工作，例如设置头部和尾部指针为空。
void initQueue(LinkedQueue* q) {q->front = NULL;q->rear = NULL;
}
  1. 入队操作（enqueue）：创建一个新节点，并将其插入到队列的尾部。更新尾部指针。
void enqueue(LinkedQueue* q, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if (isEmpty(q)) { // 队列为空，更新头部指针q->front = newNode;} else { // 队列不为空，更新尾部指针q->rear->next = newNode;}q->rear = newNode; // 更新尾部指针
}
  1. 出队操作（dequeue）：删除队列的头部节点，并返回该节点的值。更新头部指针。
int dequeue(LinkedQueue* q) {if (isEmpty(q)) { // 队列为空，出队操作失败printf("Queue is empty!\n");return -1;}Node* temp = q->front; // 保存头部节点int data = temp->data; // 获取头部节点的值q->front = q->front->next; // 更新头部指针free(temp); // 释放头部节点的内存if (isEmpty(q)) { // 队列为空，更新尾部指针q->rear = NULL;}return data;
}
  1. 获取队头元素（front）：返回队列的头部节点的值，但不删除该节点。
int front(LinkedQueue* q) {if (isEmpty(q)) { // 队列为空，返回错误值printf("Queue is empty!\n");return -1;}return q->front->data; // 返回头部节点的值
}
  1. 判断队列是否为空（isEmpty）：检查队列是否为空，即判断头部指针是否为空。
bool isEmpty(LinkedQueue* q) {return (q->front == NULL);
}

需要注意的是，在使用链式存储结构的队列时，需要小心内存管理，确保在不需要的节点时进行及时的释放操作，以防止内存泄漏。

当使用链式存储结构实现队列时，可以根据需要进行进一步的扩展和优化。下面是一些可能的操作和注意事项：

  1. 判断队列是否已满（isFull）：由于链式存储结构没有固定大小的限制，所以一般情况下不需要判断队列是否已满。但如果你想设置一个最大长度，可以通过计数器或者限制节点数量来判断队列是否已满。

  2. 清空队列（clearQueue）：释放所有节点的内存，并将头部和尾部指针都置为空。

void clearQueue(LinkedQueue* q) {while (!isEmpty(q)) {dequeue(q);}// 重置头部和尾部指针q->front = NULL;q->rear = NULL;
}
  1. 遍历队列（traverseQueue）：从队列的头部开始，依次访问每个节点的值。
void traverseQueue(LinkedQueue* q) {if (isEmpty(q)) {printf("Queue is empty!\n");return;}Node* current = q->front;while (current != NULL) {printf("%d ", current->data);current = current->next;}printf("\n");
}

  1. 动态扩展队列：链式存储结构的队列天然具备动态扩展的能力。当队列需要存储更多元素时，只需创建新的节点并添加到尾部即可。这样可以避免数组存储结构中固定大小的限制。

  2. 内存管理：在使用链式存储结构时，需要注意及时释放不再需要的节点的内存，以防止内存泄漏。在出队操作时，需要释放被删除节点的内存。在清空队列或销毁队列时，需要释放所有节点的内存。

下面是一个完整的链式存储结构的队列示例（使用C语言实现）：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>typedef struct Node {int data;struct Node* next;
} Node;typedef struct {Node* front;Node* rear;
} LinkedQueue;void initQueue(LinkedQueue* q) {q->front = NULL;q->rear = NULL;
}void enqueue(LinkedQueue* q, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if (isEmpty(q)) {q->front = newNode;} else {q->rear->next = newNode;}q->rear = newNode;
}int dequeue(LinkedQueue* q) {if (isEmpty(q)) {printf("Queue is empty!\n");return -1;}Node* temp = q->front;int data = temp->data;q->front = q->front->next;free(temp);if (isEmpty(q)) {q->rear = NULL;}return data;
}int front(LinkedQueue* q) {if (isEmpty(q)) {printf("Queue is empty!\n");return -1;}return q->front->data;
}bool isEmpty(LinkedQueue* q) {return (q->front == NULL);
}void clearQueue(LinkedQueue* q) {while (!isEmpty(q)) {dequeue(q);}q->front = NULL;q->rear = NULL;
}void traverseQueue(LinkedQueue* q) {if (isEmpty(q)) {printf("Queue is empty!\n");return;}Node* current = q->front;while (current != NULL) {printf("%d ", current->data);current = current->next;}printf("\n");
}int main() {LinkedQueue queue;initQueue(&queue);enqueue(&queue, 1);enqueue(&queue, 2);enqueue(&queue, 3);enqueue(&queue, 4);printf("Front: %d\n", front(&queue));traverseQueue(&queue);dequeue(&queue);dequeue(&queue);printf("Front: %d\n", front(&queue));traverseQueue(&queue);clearQueue(&queue);return 0;
}

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

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

相关文章

2.3物理层下面的传输媒体

2.3物理层下面的传输媒体

目录 2.3物理层下面的传输媒体2.3.1导引型传输媒体1.双绞线2.同轴电缆3.光纤 2.3.2非导引型传输媒体无线电微波通信 2.3物理层下面的传输媒体 传输媒体是数据传输系统中在发送器和接收器之间的物理通路 两大类&#xff1a; 导引型传输媒体&#xff1a;电磁波被导引沿着固体媒体…
阅读更多...
开放原子训练营（第四季）TobudOS——TobudOS内核移植（keil版）

开放原子训练营（第四季）TobudOS——TobudOS内核移植（keil版）

前言 12月份参加了开放原第四季线下活动&#xff0c;觉得很有意义。通过这篇博文&#xff0c;记录一下这次活动进行的移植TobudOS内核的过程&#xff0c;下面就让我们开始吧。 开发板介绍 本次使用的开发板型号为STM32H750&#xff0c;当然了&#xff0c;其他型号的开发版也…
阅读更多...
Angular进阶之六：Progressive rendering

Angular进阶之六：Progressive rendering

简介 Progressive Rendering 是一种提高 Web 应用性能的方法&#xff0c;允许页面在加载过程中逐步呈现&#xff0c;以提高用户体验。在本文中&#xff0c;我们将探讨如何在 Angular 中通过自定义指令实现 Progressive Rendering&#xff0c;特别是处理从服务器获取大量数据的…
阅读更多...
Java开发过程中的幂等性问题

Java开发过程中的幂等性问题

幂等性问题&#xff1a; 1. 有时我们在填写某些 form表单 时&#xff0c;保存按钮不小心快速点了两次&#xff0c;表中竟然产生了两条重复的数据&#xff0c;只是id不一样。 2. 我们在项目中为了解决 接口超时 问题&#xff0c;通常会引入了 重试机制 。第一次请求接口超时了…
阅读更多...
【揭秘】如何使用LinkedHashMap来实现一个LUR缓存？

【揭秘】如何使用LinkedHashMap来实现一个LUR缓存？

LRU&#xff08;Least Recently Used&#xff09;缓存是一种常用的缓存淘汰策略&#xff0c;用于在有限的缓存空间中存储数据。其基本思想是&#xff1a;如果数据最近被访问过&#xff0c;那么在未来它被访问的概率也更高。因此&#xff0c;LRU缓存会保留最近访问过的数据&…
阅读更多...
Python编程新技能：如何优雅地实现水仙花数？

Python编程新技能：如何优雅地实现水仙花数？

水仙花数&#xff08;Narcissistic number&#xff09;也被称为阿姆斯特朗数&#xff08;Armstrong number&#xff09;或自恋数等&#xff0c;它是一个非负整数&#xff0c;其特性是该数的每个位上的数字的n次幂之和等于它本身&#xff0c;其中n是该数的位数。简单来说&#x…
阅读更多...
00-开篇导读：学习分库分表开源框架的正确方法

00-开篇导读：学习分库分表开源框架的正确方法

1 前言 互联网高速发展带来海量的信息化数据&#xff0c;也带来更多的技术挑战。各种智能终端设备&#xff08;比如摄像头或车载设备等&#xff09;以每天千万级的数据量上报业务数据&#xff0c;电商、社交等互联网行业更不必说。这样量级的数据处理&#xff0c;已经远不是传…
阅读更多...
SELinux 安全模型——MLS

SELinux 安全模型——MLS

首发公号&#xff1a;Rand_cs BLP 模型&#xff1a;于1973年被提出&#xff0c;是一种模拟军事安全策略的计算机访问控制模型&#xff0c;它是最早也是最常用的一种多级访问控制模型&#xff0c;主要用于保证系统信息的机密性&#xff0c;是第一个严格形式化的安全模型 暂时无…
阅读更多...
机器学习三要素与拟合问题

机器学习三要素与拟合问题

1.如何构建机器学习模型&#xff1f; 机器学习工作流程总结 1.获取数据 2.数据基本处理 3.特征工程 4.机器学习(模型训练) 5.模型评估 结果达到要求&#xff0c;上线服务&#xff0c;没有达到要求&#xff0c;重新上面步骤 我们使用机器学习监督学习分类预测模型的工作流…
阅读更多...
Qt5 安装教程 - 跳过登录界面

Qt5 安装教程 - 跳过登录界面

Qt5 安装教程 - 跳过登录界面 引言一、下载二、安装三、使用四、修改、维护、卸载 引言 Qt5.14.2及以前的版本有离线安装包&#xff0c;无需登录 (老版本连登录界面也无)。之后的版本需登录进行在线安装。 本文以Qt5.12.2版本为例&#xff0c;说明如何跳过登录界面&#xff0c…
阅读更多...
Android Context在四大组件及Application中的表现

Android Context在四大组件及Application中的表现

文章目录 Android Context在四大组件及Application中的表现Context是什么Context源码Activity流程分析Service流程分析BroadcastReceiver流程分析ContentProvider流程分析Application流程分析 Android Context在四大组件及Application中的表现 Context是什么 Context可以理解…
阅读更多...
Java技术栈 —— Redis的雪崩、穿透与击穿

Java技术栈 —— Redis的雪崩、穿透与击穿

Java技术栈 —— Redis的雪崩、穿透与击穿 〇、实验的先导条件&#xff08;NginxJmeter&#xff09;一、Redis缓存雪崩、缓存穿透、缓存击穿1.1 雪崩1.2 穿透1.3 击穿 二、Redis应用场景——高并发2.1 单机部署的高并发问题与解决&#xff08;JVM级别锁&#xff09;2.2 集群部署…
阅读更多...
Redis7.2.3（Windows版本）

Redis7.2.3（Windows版本）

1、解压 &#xfeff; &#xfeff; 2、设置密码 &#xff08;1&#xff09; 右击编辑redis.conf文件&#xff1a; &#xfeff; &#xff08;2&#xff09; 设置密码。 &#xfeff; 3、测试密码是否添加成功 &#xfeff; 如上图所示&#xff0c;即为成功。 4、设置…
阅读更多...
spring创建与使用

spring创建与使用

spring创建与使用 创建 Spring 项⽬创建⼀个 Maven 项⽬添加 Spring 框架⽀持添加启动类 存储 Bean 对象创建 Bean将 Bean 注册到容器 获取并使⽤ Bean 对象创建 Spring 上下⽂获取指定的 Bean 对象获取bean对象的方法 使⽤ Bean 总结 创建 Spring 项⽬ 接下来使⽤ Maven ⽅式…
阅读更多...
010、切片

010、切片

除了引用&#xff0c;Rust还有另外一种不持有所有权的数据类型&#xff1a;切片&#xff08;slice&#xff09;。切片允许我们引用集合中某一段连续的元素序列&#xff0c;而不是整个集合。 考虑这样一个小问题&#xff1a;编写一个搜索函数&#xff0c;它接收字符串作为参数&a…
阅读更多...
12.29最小生成数K算法复习（注意输入输出格式），校园最短路径（通过PRE实现路径输出，以及输入输出格式注意）

12.29最小生成数K算法复习（注意输入输出格式），校园最短路径（通过PRE实现路径输出，以及输入输出格式注意）

7-2 最小生成树-kruskal算法 分数 15 const int maxn 1000; struct edge {int u, v, w; }e[maxn]; int n, m, f[30]; bool cmp(edge a, edge b) {return a.w < b.w; } int find(int x) {if (f[x] x) {return x;}else {f[x] find(f[x]);return f[x];} } //int arr[100…
阅读更多...
vue脚手架安装

vue脚手架安装

1、安装&#xff1a; npm i vue/cli -g(-g全局安装,全名global) vue --version 查看版本号 2、使用 vue create 项目名称 3、安装选择项 最后一个选N
阅读更多...
【Redis-03】Redis数据结构与对象原理 -下篇

【Redis-03】Redis数据结构与对象原理 -下篇

承接上篇【Redis-02】Redis数据结构与对象原理 -上篇 8. type-字符串string 8.1 字符串的三种encoding编码&#xff08;int embstr raw&#xff09; 如果保存的是整型&#xff0c;并且可以用long类型标识&#xff08;-9223372036854775808到9223372036854775807&#xff09…
阅读更多...
IO进程线程 day1 IO基础+标准IO

IO进程线程 day1 IO基础+标准IO

1、使用fgets统计一个文件的行号 #include <stdio.h> #include<string.h> #include<stdlib.h> int main(int argc, const char *argv[]) {FILE *fpNULL;if((fpfopen("1.c","r"))NULL){return -1;}int count0;char buf;while(buf!EOF){b…
阅读更多...
C++多态性——(1)初识多态

C++多态性——(1)初识多态

归纳编程学习的感悟&#xff0c; 记录奋斗路上的点滴&#xff0c; 希望能帮到一样刻苦的你&#xff01; 如有不足欢迎指正&#xff01; 共同学习交流&#xff01; &#x1f30e;欢迎各位→点赞 &#x1f44d; 收藏⭐ 留言​&#x1f4dd; 苦难和幸福一样&#xff0c;都是生命盛…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023