2024重生之回溯数据结构与算法系列学习(11)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丟脸好嘛?】

本文涉及的产品
视觉智能开放平台,视频资源包5000点
视觉智能开放平台,图像资源包5000点
视觉智能开放平台,分割抠图1万点
简介: 数据结构王道第3章之IKUN和I原达人之数据结构与算法系列学习栈与队列精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊-除了会黑我家鸽鸽还会干嘛?!!!

欢迎各位彦祖与热巴畅游本人专栏与博客

你的三连是我最大的动力

以下图片仅代表专栏特色 [点击箭头指向的专栏名即可闪现]

专栏跑道一

➡️网络空间安全——全栈前沿技术持续深入学习

image.gif

专栏跑道二

➡️ 24 Network Security -LJS

image.gif

image.gif

image.gif

专栏跑道三


➡️ MYSQL REDIS Advance operation

image.gif

专栏跑道四

➡️HCIP;H3C-SE;CCIP——LJS[华为、华三、思科高级网络]

image.gif

专栏跑道五

➡️RHCE-LJS[Linux高端骚操作实战篇]

image.png

专栏跑道六

➡️数据结构与算法[考研+实际工作应用+C程序设计]

image.gif

专栏跑道七

➡️RHCSA-LJS[Linux初级及进阶骚技能]

image.gif

image.gif

上节回顾





回溯数据结构与算法系列学习之栈和队列精题汇总

(6)题目:三角矩阵Q按行存储

  • image.gif

解题思路:

TwoMapOneDim 函数将下三角矩阵的元素存储在一维数组中。
OneDimIndex 函数用于根据行列索引从一维数组中获取对应的值,但为了正确性,需确保处理上三角的情况。
PrintTwoDim  PrintOneDim 函数用于分别打印二维和一维数组的内容。
 main 函数中,首先定义了并打印了一个下三角矩阵,然后调用转换函数,将其存储到一维数组中并打印,最后获取特定位置的值并打印
  • image.gif

代码实现:

#include <iostream>
using namespace std;
// 将下三角矩阵按行存储在一维数组中
void TwoMapOneDim(int arr[][3], int array[], int row, int col)
{
    int k = 0; // 用于一维数组的索引
    // 遍历二维数组的每一行
    for (int i = 0; i < row; i++)
    {
        // 遍历当前行的有效列(即下三角部分)
        for (int j = 0; j <= i; j++)
        {
            array[k++] = arr[i][j]; // 将下三角元素存入一维数组
        }
    }
    // 在一维数组的最后一个位置存储该二维数组的右上角元素(示例中为999)
    array[k] = arr[0][col - 1];
}
// 按照索引从一维数组取值
int OneDimIndex(int *array, int i, int j)
{
    // 如果 i 大于等于 j,说明在下三角区域
    if (i >= j)
    {
        return array[i * (i - 1) / 2 + j - 1]; // 根据公式计算下三角矩阵的一维索引
    }
    else
    {
        // 如果不在下三角区域,返回上三角部分的某个值(此处逻辑有误,应该是返回错误处理)
        return array[3 * (3 + 1) / 2]; // 这里应该是返回无效值,实际可能需要调整
    }
}
// 打印二维数组
void PrintTwoDim(int arr[][3], int row, int col)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            cout << arr[i][j] << '\t'; // 按行打印每个元素
        }
        cout << endl; // 每行结束后换行
    }
}
// 打印一维数组
void PrintOneDim(int *arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << '\t'; // 打印每个元素
    }
    cout << endl; // 打印结束后换行
}
int main()
{
    // 初始化一个3x3的下三角矩阵
    int arr[3][3] = {{1, 999, 999}, {4, 2, 999}, {5, 6, 3}};
    // 创建一维数组以存储下三角矩阵的元素
    int array[3 * (3 + 1) / 2 + 1];
    
    // 打印原始二维数组
    PrintTwoDim(arr, 3, 3);
    
    // 将二维数组的下三角部分存储到一维数组中
    TwoMapOneDim(arr, array, 3, 3);
    
    // 打印存储下三角元素的一维数组
    PrintOneDim(array, 3 * (3 + 1) / 2 + 1);
    
    // 从一维数组中获取给定索引的值并输出(示例:获取坐标(1, 3)的值)
    cout << OneDimIndex(array, 1, 3); // 输出结果应该是999
}
  • image.gif

image.gif 编辑

(7)题目:二维数组按行存储

  • image.gif 编辑

解题思路:

TwoMapOneDim 函数:
输入参数:二维数组 arr、一维数组 array、行数 row 和列数 col。
目的是将二维数组的所有元素按行存储到一维数组中。
使用嵌套循环逐行逐列遍历二维数组,将每个元素赋值给一维数组。
OneDimIndex 函数:
输入参数:一维数组 array 和索引 i, j(表示二维数组的行和列)。
目的是根据给定的行列索引计算在一维数组中的位置,并返回该位置的值。
计算公式为 (i - 1) * 3 + (j - 1),其中 3 是列数,考虑到数组索引从0开始。
PrintTwoDim 函数:
输入参数:二维数组 arr、行数 row 和列数 col。
目的是打印整个二维数组,每个元素之间用制表符分隔,行末换行。
PrintOneDim 函数:
输入参数:一维数组 arr 和元素个数 n。
目的是打印一维数组的所有元素,元素之间用制表符分隔,最后换行。
main 函数:
定义了一个3x3的二维数组并初始化。
创建了一维数组 array 存储元素。
调用 PrintTwoDim 打印原始二维数组。
调用 TwoMapOneDim 将二维数组元素存入一维数组。
调用 PrintOneDim 打印一维数组的内容。
最后调用 OneDimIndex 获取并打印一维数组在行3列2位置的值(应该为6)
  • image.gif

代码实现:

#include <iostream>
using namespace std;
// 将二维数组按行存储到一维数组中
void TwoMapOneDim(int arr[][3], int array[], int row, int col)
{
    int k = 0; // 用于一维数组的索引
    // 遍历二维数组的每一行
    for (int i = 0; i < row; i++)
    {
        // 遍历当前行的每一列
        for (int j = 0; j < col; j++)
        {
            array[k++] = arr[i][j]; // 将二维数组的元素存入一维数组
        }
    }
}
// 按照索引从一维数组取值
int OneDimIndex(int *array, int i, int j)
{
    return array[(i - 1) * 3 + j - 1]; // 根据行列索引计算一维数组的索引并返回对应的值
}
// 打印二维数组
void PrintTwoDim(int arr[][3], int row, int col)
{
    for (int i = 0; i < row; i++) // 遍历每一行
    {
        for (int j = 0; j < col; j++) // 遍历当前行的每一列
        {
            cout << arr[i][j] << '\t'; // 打印当前元素,使用制表符分隔
        }
        cout << endl; // 每行结束后换行
    }
}
// 打印一维数组
void PrintOneDim(int *arr, int n)
{
    for (int i = 0; i < n; i++) // 遍历一维数组的每个元素
    {
        cout << arr[i] << '\t'; // 打印当前元素,使用制表符分隔
    }
    cout << endl; // 打印结束后换行
}
int main()
{
    // 初始化一个3x3的二维数组
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int array[9]; // 创建一维数组以存储9个元素(3x3)
    
    // 打印原始二维数组
    PrintTwoDim(arr, 3, 3);
    
    // 将二维数组的元素存储到一维数组中
    TwoMapOneDim(arr, array, 3, 3);
    
    // 打印存储在一维数组中的元素
    PrintOneDim(array, 9);
    
    // 获取并打印一维数组中指定位置的值(行3,列2)
    cout << OneDimIndex(array, 3, 2); // 输出结果应该是6
}
  • image.gif

(8)题目:栈的应用Q——中缀表达式转成后缀表达式

解题思路:

>遇到操作数,将其直接加入后缀表达式
>遇到界限符:如果是(,直接入栈
           如果是),则依次弹出栈内运算符将其加入后缀表达式直到遇到左括号
>遇到运算符,依次弹出优先级高于或等于当前运算符的所有运算符,并加入后缀表达式
直到遇到左括号或者是栈空
>将栈中剩余运算符依次弹出,并加入后缀表达式
  • image.gif

代码实现:

#include <iostream>
using namespace std;
#define MAXSIZE 100  // 定义栈的最大容量
// 定义栈的结构体
typedef struct
{
    char data[MAXSIZE];  // 存放栈元素的数组
    int top1 = -1;       // 栈顶指针,初始值为-1表示栈为空
} Stack;
// 判断栈是否为空
bool StackEmpty(Stack s)
{
    return s.top1 == -1;  // 如果栈顶指针为-1,说明栈为空
}
// 判断栈是否溢出
bool StackOverflow(Stack s)
{
    return s.top1 >= MAXSIZE;  // 如果栈顶指针大于等于最大容量,说明栈已满
}
// 压栈操作
void Push(Stack &s, char x)
{
    if (!StackOverflow(s))  // 检查栈是否溢出
    {
        s.data[++s.top1] = x;  // 将元素压入栈中,并更新栈顶指针
    }
    else
    {
        cout << "当前栈已满" << endl;  // 如果栈满,输出提示信息
    }
}
// 弹栈操作
char Pop(Stack &s)
{
    if (StackEmpty(s))  // 检查栈是否为空
    {
        return '\0';  // 返回'\0'表示栈为空
    }
    else
    {
        return s.data[s.top1--];  // 返回栈顶元素并更新栈顶指针
    }
}
// 将中缀表达式转为后缀表达式
string InfixToSuffix(string infix)
{
    Stack s;               // 创建一个栈用于存放运算符
    string suffix = "";    // 用于存放后缀表达式
    char op;               // 临时变量用于存放弹出的运算符
    // 遍历中缀表达式中的每个字符
    for (int i = 0; i < infix.length(); i++)
    {
        // 遇到操作数(A-Z)直接加入后缀表达式
        if (infix[i] >= 'A' && infix[i] <= 'Z')
        {
            suffix += infix[i];
        }
        // 遇到左括号,直接入栈
        else if (infix[i] == '(')
        {
            Push(s, infix[i]);
        }
        // 遇到右括号,依次弹出运算符直至遇到左括号
        else if (infix[i] == ')')
        {
            while (!StackEmpty(s))
            {
                op = Pop(s);
                if (op != '(')  // 如果不是左括号,将运算符加入后缀表达式
                {
                    suffix += op;
                }
                else
                {
                    break;  // 遇到左括号,停止弹栈
                }
            }
        }
        else
        {
            // 如果是乘号或者除号,只弹出优先级相同或更高的运算符
            if (infix[i] == '*' || infix[i] == '/')
            {
                while (!StackEmpty(s))
                {
                    op = Pop(s);
                    if (op == '(')  // 遇到左括号,停止弹栈
                    {
                        break;
                    }
                    else
                    {
                        // 碰到低级运算符(+ 或 -),弹出后再压回去
                        if (op == '+' || op == '-')
                        {
                            Push(s, op);  // 将低级运算符压回栈中
                            break;
                        }
                        else
                        {
                            suffix += op;  // 将高优先级运算符加入后缀表达式
                        }
                    }
                }
            }
            // 遇到加号或减号,将所有运算符弹出
            else if (infix[i] == '+' || infix[i] == '-')
            {
                while (!StackEmpty(s))
                {
                    op = Pop(s);
                    if (op == '(')  // 遇到左括号,停止弹栈
                    {
                        break;
                    }
                    else
                    {
                        suffix += op;  // 将运算符加入后缀表达式
                    }
                }
            }
            // 将当前运算符压入栈中
            Push(s, infix[i]);
        }
    }
    // 将栈中剩余的运算符依次弹出
    while (!StackEmpty(s))
    {
        suffix += Pop(s);
    }
    return suffix;  // 返回生成的后缀表达式
}
int main()
{
    string infix = "A+B*(C-D)-E/F";  // 示例中缀表达式
    cout << InfixToSuffix(infix);     // 输出转换后的后缀表达式
}
  • image.gif


(9)题目:利用栈实现斐波那契数列Q

  • image.gif 编辑

解题思路:

斐波那契数列两种实现:
>利用递归,无需多说
>利用栈,就是找二叉树的叶子结点个数,不断将子节点压入栈中
  • image.gif

代码实现:

#include <iostream>
using namespace std;
#define MAXSIZE 100  // 定义栈的最大容量
// 定义栈的结构体
typedef struct
{
    int data[MAXSIZE];  // 存储栈元素的数组
    int top1 = -1;      // 栈顶指针,初始值为-1表示栈为空
} Stack;
// 判断栈是否为空
bool StackEmpty(Stack s)
{
    return (s.top1 == -1);  // 如果栈顶指针为-1,说明栈为空
}
// 判断栈是否溢出
bool StackOverflow(Stack s)
{
    return (s.top1 >= MAXSIZE);  // 如果栈顶指针大于等于最大容量,说明栈已满
}
// 压栈操作
void Push(Stack &s, int x)
{
    if (!StackOverflow(s))  // 检查栈是否溢出
    {
        s.data[++s.top1] = x;  // 将元素压入栈中,并更新栈顶指针
    }
    else
    {
        cout << "当前栈已满" << endl;  // 如果栈满,输出提示信息
    }
}
// 弹栈操作
int Pop(Stack &s)
{
    if (StackEmpty(s))  // 检查栈是否为空
    {
        cout << "当前栈已空" << endl;  // 输出提示信息
        return '\0';  // 返回'\0'表示栈为空
    }
    else
    {
        return s.data[s.top1--];  // 返回栈顶元素并更新栈顶指针
    }
}
// 利用递归实现斐波那契数列
int FibRecursion(int n)
{
    if (n == 1 || n == 2)  // 基本情况:当 n 为 1 或 2 时,返回 1
    {
        return 1;
    }
    return FibRecursion(n - 1) + FibRecursion(n - 2);  // 递归调用计算斐波那契数
}
// 利用栈实现斐波那契数列
int FibStack(int n)
{
    Stack s;  // 初始化栈
    int result = 0;  // 用于存放结果
    Push(s, n);  // 将根节点压入栈中
    while (!StackEmpty(s))  // 当栈不为空时循环
    {
        int value = Pop(s);  // 将栈顶元素弹出
        // 计算叶子节点个数
        if (value == 1 || value == 2)  // 如果是基本情况
        {
            result += 1;  // 结果加一
        }
        // 将根节点的两个子节点压入栈中
        else
        {
            Push(s, value - 1);  // 将 n-1 压入栈
            Push(s, value - 2);  // 将 n-2 压入栈
        }
    }
    return result;  // 返回计算的结果
}
int main()
{
    cout << FibRecursion(7) << endl;  // 输出递归方式计算的第 7 个斐波那契数
    cout << FibStack(7) << endl;       // 输出栈方式计算的第 7 个斐波那契数
}
  • image.gif

(10)题目:栈的应用Q—后缀表达式的计算

解题思路:

>从左往右扫描下一个元素,直到处理完所有元素
>若扫描到操作数则压入栈,并回到操作1,否则执行3
>若扫描到运算符,则弹出两个栈顶元素,执行相应计算,运算结果压回栈顶,回到1


代码实现:

#include <iostream>
using namespace std;
#define MAXSIZE 100  // 定义栈的最大容量
// 定义栈的结构体
typedef struct
{
    double data[MAXSIZE] = {0.0};  // 存储栈元素的数组,初始值为0.0
    int top1 = -1;                  // 栈顶指针,初始值为-1表示栈为空
} Stack;
// 判断栈是否为空
bool StackEmpty(Stack s)
{
    return (s.top1 == -1);  // 如果栈顶指针为-1,说明栈为空,返回true
}
// 判断栈是否溢出
bool StackOverflow(Stack s)
{
    return (s.top1 >= MAXSIZE);  // 如果栈顶指针大于等于最大容量,说明栈已满,返回true
}
// 压栈操作
void Push(Stack &s, double x)
{
    if (!StackOverflow(s))  // 检查栈是否溢出
    {
        s.data[++s.top1] = x;  // 将元素压入栈中,并更新栈顶指针
    }
    else
    {
        cout << "当前栈已满" << endl;  // 如果栈满,输出提示信息
    }
}
// 弹栈操作
double Pop(Stack &s)
{
    if (StackEmpty(s))  // 检查栈是否为空
    {
        return '\0';  // 返回'\0'表示栈为空
    }
    else
    {
        return s.data[s.top1--];  // 返回栈顶元素并更新栈顶指针
    }
}
// 计算后缀表达式
void CalSuffix(string suffix[])
{
    Stack s;  // 创建栈,用于保存操作数
    for (int i = 0; i < 15; i++)  // 遍历后缀表达式中的每个元素
    {
        // 如果是运算数,将其压入栈
        if (suffix[i] != "+" && suffix[i] != "-" && suffix[i] != "*" && suffix[i] != "/")
        {
            Push(s, atoi(suffix[i].c_str()));  // 将字符串转换为整数并压入栈
        }
        // 如果是操作符,依次弹出两个操作数
        else
        {
            double oper1 = Pop(s); // 右操作数
            double oper2 = Pop(s); // 左操作数
            // 执行相应运算,将运算结果压入栈中
            if (suffix[i] == "+")
            {
                Push(s, oper2 + oper1);  // 加法
            }
            else if (suffix[i] == "-")
            {
                Push(s, oper2 - oper1);  // 减法
            }
            else if (suffix[i] == "*")
            {
                Push(s, oper2 * oper1);  // 乘法
            }
            else if (suffix[i] == "/")
            {
                Push(s, oper2 / oper1);  // 除法
            }
        }
    }
    // 最终栈顶元素即为结果
    cout << "最终结果为:" << Pop(s) << endl;  // 输出计算结果
}
int main()
{
    // 待计算的后缀表达式
    string suffix[] = {"15",
                       "7",
                       "1",
                       "1",
                       "+",
                       "-",
                       "/",
                       "3",
                       "*",
                       "2",
                       "1",
                       "1",
                       "+",
                       "+",
                       "-"};
    CalSuffix(suffix);  // 调用计算后缀表达式的函数
}
  • image.gif

(11)题目:将对称矩阵压缩保存到一维数组

  • image.gif 编辑
  • 解题思路:
将二维数组转换为一维数组:
TwoMapOneDim 函数接收一个二维数组,将其下三角矩阵的元素存储到传入的一维数组中。
根据索引从一维数组获取值:
OneDimIndex 函数根据行和列的索引计算出在一维数组中的位置,并返回该位置的值。
打印二维数组:
PrintTwoDim 函数用于打印传入的二维数组,格式化输出每个元素。
打印一维数组:
PrintOneDim 函数用于打印传入的一维数组,输出所有元素。
主函数:
在 main 中定义了一个 3x3 的二维数组,并创建一个足够大的数组来存储下三角矩阵的元素。
调用打印函数展示二维数组,调用转换函数将下三角元素存入一维数组,再打印一维数组。
最后,通过 OneDimIndex 函数输出特定位置的值。
  • image.gif

代码实现:

#include <iostream>
using namespace std;
// 将二维数组按行存储在一维数组中,保存下三角矩阵
void TwoMapOneDim(int arr[][3], int array[], int row, int col)
{
    int k = 0;  // 一维数组的索引
    for (int i = 0; i < row; i++)  // 遍历行
    {
        for (int j = 0; j <= i; j++)  // 遍历列,j的范围是从0到i(包括i),以获取下三角元素
        {
            array[k++] = arr[i][j];  // 将下三角元素存入一维数组中
        }
    }
}
// 按照索引从一维数组取值
int OneDimIndex(int *array, int i, int j)
{
    // 根据行和列的索引计算一维数组中的位置并返回该值
    if (i >= j)
    {
        return array[i * (i - 1) / 2 + j - 1];  // 当i >= j时,使用这个公式
    }
    else
    {
        return array[j * (j - 1) / 2 + i - 1];  // 当i < j时,使用这个公式
    }
}
// 打印二维数组
void PrintTwoDim(int arr[][3], int row, int col)
{
    for (int i = 0; i < row; i++)  // 遍历每一行
    {
        for (int j = 0; j < col; j++)  // 遍历每一列
        {
            cout << arr[i][j] << '\t';  // 输出当前元素
        }
        cout << endl;  // 换行
    }
}
// 打印一维数组
void PrintOneDim(int *arr, int n)
{
    for (int i = 0; i < n; i++)  // 遍历一维数组
    {
        cout << arr[i] << '\t';  // 输出当前元素
    }
    cout << endl;  // 换行
}
int main()
{
    int arr[3][3] = {{1, 4, 5}, {4, 2, 6}, {5, 6, 3}};  // 定义一个3x3的二维数组
    int array[3 * (3 + 1) / 2];  // 定义一维数组,大小为下三角矩阵的元素个数
    PrintTwoDim(arr, 3, 3);  // 打印二维数组
    TwoMapOneDim(arr, array, 3, 3);  // 将下三角矩阵元素存入一维数组
    PrintOneDim(array, 3 * (3 + 1) / 2);  // 打印一维数组
    cout << OneDimIndex(array, 1, 3);  // 输出一维数组中(1, 3)对应的值
}



相关文章
|
3天前
|
弹性计算 双11 开发者
阿里云ECS“99套餐”再升级!双11一站式满足全年算力需求
11月1日,阿里云弹性计算ECS双11活动全面开启,在延续火爆的云服务器“99套餐”外,CPU、GPU及容器等算力产品均迎来了全年最低价。同时,阿里云全新推出简捷版控制台ECS Lite及专属宝塔面板,大幅降低企业和开发者使用ECS云服务器门槛。
|
21天前
|
存储 弹性计算 人工智能
阿里云弹性计算_通用计算专场精华概览 | 2024云栖大会回顾
阿里云弹性计算产品线、存储产品线产品负责人Alex Chen(陈起鲲)及团队内多位专家,和中国电子技术标准化研究院云计算标准负责人陈行、北京望石智慧科技有限公司首席架构师王晓满两位嘉宾,一同带来了题为《通用计算新品发布与行业实践》的专场Session。本次专场内容包括阿里云弹性计算全新发布的产品家族、阿里云第 9 代 ECS 企业级实例、CIPU 2.0技术解读、E-HPC+超算融合、倚天云原生算力解析等内容,并发布了国内首个云超算国家标准。
阿里云弹性计算_通用计算专场精华概览 | 2024云栖大会回顾
|
3天前
|
人工智能 弹性计算 文字识别
基于阿里云文档智能和RAG快速构建企业"第二大脑"
在数字化转型的背景下,企业面临海量文档管理的挑战。传统的文档管理方式效率低下,难以满足业务需求。阿里云推出的文档智能(Document Mind)与检索增强生成(RAG)技术,通过自动化解析和智能检索,极大地提升了文档管理的效率和信息利用的价值。本文介绍了如何利用阿里云的解决方案,快速构建企业专属的“第二大脑”,助力企业在竞争中占据优势。
|
1天前
|
人工智能 自然语言处理 安全
创新不设限,灵码赋新能:通义灵码新功能深度评测
自从2023年通义灵码发布以来,这款基于阿里云通义大模型的AI编码助手迅速成为开发者心中的“明星产品”。它不仅为个人开发者提供强大支持,还帮助企业团队提升研发效率,推动软件开发行业的创新发展。本文将深入探讨通义灵码最新版本的三大新功能:@workspace、@terminal 和 #team docs,分享这些功能如何在实际工作中提高效率的具体案例。
|
7天前
|
负载均衡 算法 网络安全
阿里云WoSign SSL证书申请指南_沃通SSL技术文档
阿里云平台WoSign品牌SSL证书是由阿里云合作伙伴沃通CA提供,上线阿里云平台以来,成为阿里云平台热销的国产品牌证书产品,用户在阿里云平台https://www.aliyun.com/product/cas 可直接下单购买WoSign SSL证书,快捷部署到阿里云产品中。
1850 6
阿里云WoSign SSL证书申请指南_沃通SSL技术文档
|
10天前
|
Web App开发 算法 安全
什么是阿里云WoSign SSL证书?_沃通SSL技术文档
WoSign品牌SSL证书由阿里云平台SSL证书合作伙伴沃通CA提供,上线阿里云平台以来,成为阿里云平台热销的国产品牌证书产品。
1789 2
|
19天前
|
编解码 Java 程序员
写代码还有专业的编程显示器?
写代码已经十个年头了, 一直都是习惯直接用一台Mac电脑写代码 偶尔接一个显示器, 但是可能因为公司配的显示器不怎么样, 还要接转接头 搞得桌面杂乱无章,分辨率也低,感觉屏幕还是Mac自带的看着舒服
|
26天前
|
存储 人工智能 缓存
AI助理直击要害,从繁复中提炼精华——使用CDN加速访问OSS存储的图片
本案例介绍如何利用AI助理快速实现OSS存储的图片接入CDN,以加速图片访问。通过AI助理提炼关键操作步骤,避免在复杂文档中寻找解决方案。主要步骤包括开通CDN、添加加速域名、配置CNAME等。实测显示,接入CDN后图片加载时间显著缩短,验证了加速效果。此方法大幅提高了操作效率,降低了学习成本。
5386 15
|
13天前
|
人工智能 关系型数据库 Serverless
1024,致开发者们——希望和你一起用技术人独有的方式,庆祝你的主场
阿里云开发者社区推出“1024·云上见”程序员节专题活动,包括云上实操、开发者测评和征文三个分会场,提供14个实操活动、3个解决方案、3 个产品方案的测评及征文比赛,旨在帮助开发者提升技能、分享经验,共筑技术梦想。
1139 152
|
21天前
|
存储 缓存 关系型数据库
MySQL事务日志-Redo Log工作原理分析
事务的隔离性和原子性分别通过锁和事务日志实现,而持久性则依赖于事务日志中的`Redo Log`。在MySQL中,`Redo Log`确保已提交事务的数据能持久保存,即使系统崩溃也能通过重做日志恢复数据。其工作原理是记录数据在内存中的更改,待事务提交时写入磁盘。此外,`Redo Log`采用简单的物理日志格式和高效的顺序IO,确保快速提交。通过不同的落盘策略,可在性能和安全性之间做出权衡。
1585 14

热门文章

最新文章

  • 1
    2024重生之回溯数据结构与算法系列学习之串(12)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丟脸好嘛?】
    12
  • 2
    2024重生之回溯数据结构与算法系列学习(11)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丟脸好嘛?】
    6
  • 3
    2024重生之回溯数据结构与算法系列学习之栈和队列精题汇总(10)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
    9
  • 4
    2024重生之回溯数据结构与算法系列学习之单双链表精题详解(9)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
    10
  • 5
    2024重生之回溯数据结构与算法系列学习(8)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
    10
  • 6
    2024重生之回溯数据结构与算法系列学习(7)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
    7
  • 7
    2024重生之回溯数据结构与算法系列学习之王道第2.3章节之线性表精题汇总二(5)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
    7
  • 8
    23
    6
  • 9
    2024重生之回溯数据结构与算法系列学习之单双链表精题(4)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
    9
  • 10
    2024重生之回溯数据结构与算法系列学习之单双链表【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
    6