12.27重构二叉树，插入排序，队列（股票，模拟），后缀表达式求值，括号匹配，验证栈序列，选择题部分

news2025/1/16 21:10:22

重构二叉树

误

string in, post;
struct node {
    char a;
    node* lchild, * rchild;
    node(char x='\0') :a(x), lchild(nullptr), rchild(nullptr) {}
};
void so(node* r, int il, int ir, int pl, int pr) {
    if (il > ir)return;
    int root;
    for (root = il; root <= ir; root++) {
        if (in[root] == post[pr])break;
    }//找到根节点在中序序列中的位置
    r->a = in[root];
    int lsize = root - il;//只含一个端点，不包含根节点root
    so(r->lchild,il, root - 1, pl, pl + lsize - 1);//左子树
    so(r->rchild,root + 1, ir, pl + lsize, pr - 1);//右子树
}
void pre(node* root) {
    if (!root)return;
    cout << root->a;
    pre(root->lchild);
    pre(root->rchild);
}
cin >> in >> post;
node* root = new node;
so(root, 0, in.length() - 1, 0, in.length() - 1);
pre(root);

一点基本常识，给你一个后序遍历，那么最后一个就是根（如ABCD，则根为D） 

substr与find，由后序与中序

substr返回的是截取后的子串，第一个参数为开始截取的下标，第二个参数为截取的元素个数

find返回下标，

#include <iostream>
#include <vector>
#include <algorithm>
#include<stack>
#include<queue>
#include <map>
#include<string>
#include<cstdio>
using namespace std;
void b(string in, string a) {
    if (in.size() > 0) {//同理对后序，第k个数下标为k-1,那么第k+1个，下标为k的数，是右子树的第一个数
        char ch = a[a.size() - 1];//从0截取k个，那么最后一个的下标就是k-1,对于中序而言，下标为k的是第k+1个数，是根节点，那么右子树第一个为k+2,下标为k-1
        cout << ch;//如果没有第二个参数，就默认从这个起点截取到末尾
        int k = in.find(ch);//substr第一个参数是截取的起点，第二个参数是截取元素的个数，第二个参数不是截取的终点
        b(in.substr(0, k), a.substr(0, k));//find返回的是下标，恰好就是左子树里的元素个数
        b(in.substr(k + 1), a.substr(k, in.size() - 1 - k));//k代表的恰好是左子树里的元素个数，整个数量由一个根节点，左右子树大小构成，所以右子树大小就是减去
    }
}
int main() {
    string in, a;
    cin >> in >> a;
    b(in, a);
    return 0;
}

由中序与先序—— P1827 [USACO3.4] 美国血统 American Heritage

void so(string in, string pre) {
    if (in.size() < 1)return;
    char ch = pre[0];
    int index = in.find(ch);//index代表根节点在中序序列中的下标位置，恰好代表左子树大小,因为左子树的最后一个元素下标为index-1,中有元素数量为index-1+1
    so(in.substr(0, index), pre.substr(1, index));//左子树
    so(in.substr(index + 1, in.size() - 1 - index), pre.substr(index + 1, in.size() - 1 - index));//右子树
    cout << ch;
}//先序为根左右，中序为左根右
string in, pre;
cin >> in >> pre;
so(in, pre);
s.find(c);
//在字符串s中查找第一个字符c的位置，返回下标，如果没有返回string::npos

s.erase(it);
//在字符串中删除指针it所指向的字符

s.begin();
//返回s的首字符的指针（迭代器）
void b(string in, string a) {
    if (in.size() > 0) {
        char ch = a[a.size() - 1];
        cout << ch;//中序为左根右，后序为左右根
        int k = in.find(ch);//在中序里找根节点的下标,也代表左子树的大小
        b(in.substr(0, k), a.substr(0, k));//左子树
        b(in.substr(k + 1), a.substr(1, in.size() - 1 - k));//0是左子树的第一个元素，那么加上左子树大小，指向的是左子树后的第一个元素，即根节点，而不是左子树的最后一个元素，所以要加个1才是右子树的第一个元素
    }
}
void so(string in, string pre) {
    if (in.size() > 0) {
        char ch = pre[0];
        int index = in.find(ch);
        so(in.substr(0, index), pre(1, index));//截取第二个参数个元素，从节点开始，所以是不包含右端点的
        so(in.substr(index + 1, in.size() - 1 - index), pre.substr(1 + index, in.size() - 1 - index));
        cout << ch;
    }
}

另一种风格 

前序和后序构建

必要条件为左右子树里都得有元素或者都没有，如果孩子里只有一个元素，因为前序后序的左右孩子都在根节点的一侧，所以就无法区分出这个孩子到底是左孩子还是右孩子，就会产生两种情况，有多少个只有一个孩子的情况，就会有1<<n的情况。即有多少个度为1的节点，就会有1<<n的情况

如果每个节点都有左右孩子或者没有，就不会有其它的情况，情况就是唯一的

重构二叉树干的就几件事，第一件是确定本层的节点，本层的根节点；然后划分出左右子树区间，递归解决

int nfind(char* inorder, int size, char v) {
    for (int i = 0; i < size; i++) {
        if (inorder[i] == v)return i;
    }
}
node* build(char* preorder, char* inorder, int size) {//用char*的话，就是数组，只传数组名，即首个元素的下标接口
    if (!size)return nullptr;
    char rd = preorder[0];
    int leftsize = nfind(inorder, size, rd);
    node* root = new node(rd);
    root->lchild = build(preorder + 1, inorder, leftsize);
    root->rchild = build(preorder + 1 + leftsize, inorder + 1 + leftsize, size - 1 - leftsize);
    return root;
}
node* buildpre(char* inorder, char* postorder, int size) {
    if (!size)return nullptr;
    char rd = postorder[size - 1];
    int leftsize = nfind(inorder, size, rd);
    node* root = new node(rd);
    root->lchild = buildpre(inorder, postorder, leftsize);//加上的数代表差距，从头位置加上左子树的大小，那么最后指向的恰好是左子树后的第一个数，而不是左子树的最后一个数，因为起点不是0，而是1，是左子树里的第一个数
    root->rchild = buildpre(inorder + 1 + leftsize, postorder + leftsize, size - 1 - leftsize);
    return root;
}
node* buildin(char* preorder, char* postorder, int size) {
    if (!size)return nullptr;
    char rd = preorder[0];
    node* root = new node(rd);//其它不用特判，因为可以构建出度为1的节点
    if (size == 1)return root;//由于为满二叉树，此时每个序列要么为叶子节点，要么为出度为2的节点，这里检测前一种情况，即此时序列被拆的都只剩一个元素,不然序列里根本就不存后面的元素
    int leftsize = nfind(postorder, size, preorder[1]);//由于根节点的位置在前序后序里的位置都是确定的，所以去找左子树的根节点
    root->lchild = buildin(preorder + 1, postorder, leftsize);
    root->rchild = buildin(preorder + 1 + leftsize, postorder, size - 1 - leftsize);//这里前一个参数要加1才是右子树的起点，因为要越过根节点和左子树，起点为左子树第一个元素，只加左子树大小时，指向根节点位置，再加1才是右子树的第一个元素位置
    return root;//这里第一个为根节点，不是左子树的第一个元素，所以加完后指向的是左子树的最后一个元素，再加1就是右子树的第一个元素
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& postorder, int preStart, int preEnd, int postStart, int postEnd) {
    // 递归终止条件
    if (preStart > preEnd) {
        return nullptr;
    }
    
    // 创建当前节点
    TreeNode* root = new TreeNode(preorder[preStart]);
    
    // 在后序序列中找到当前节点的位置
    int index = postStart;
    while (postorder[index] != preorder[preStart]) {
        index++;
    }
    
    // 计算左子树的节点个数
    int leftCount = index - postStart;
    
    // 构建左子树
    root->left = buildTree(preorder, postorder, preStart + 1, preStart + leftCount, postStart, index - 1);
    
    // 构建右子树
    root->right = buildTree(preorder, postorder, preStart + leftCount + 1, preEnd, index, postEnd - 1);
    
    return root;
}

TreeNode* buildTree(vector<int>& preorder, vector<int>& postorder) {
    int preStart = 0;
    int preEnd = preorder.size() - 1;
    int postStart = 0;
    int postEnd = postorder.size() - 1;
    
    return buildTree(preorder, postorder, preStart, preEnd, postStart, postEnd);
}

层序重构树

void level(node*& t) {
    queue<node*>q;
    int x;
    cin >> x;
    if (!x)return;
    node* t = new node(x);
    q.push(t);
    while (!q.empty()) {
        node* cur = q.front();
        q.pop();
        cin >> x;
        if (x) {
            cur->lchild = new node(x);
            q.push(cur->lchild);
        }
        cin >> x;
        if (x) {
            cur->rchild = new node(x);
            q.push(cur->rchild);
        }
    }
}
void create(node& tree) {
    char t;
    cin >> t;
    if (t == '#') { tree = nullptr; }
    else {
        tree = new node;
        tree->data = t;
        create(tree->lchild);
        create(tree->rchild);
    }
}

 P3884 [JLOI2009] 二叉树问题

这个距离，就是说先向上找最近公共祖先，找的路径乘2，然后找到公共祖先再下来，就不用乘2

#include<bits/stdc++.h>

排序

插入排序

    for (int i = 2; i <= n; i++) {
        int temp = arr[i], j;
        for ( j = i - 1; arr[j] > temp && j >= 1; j--) {
            arr[j + 1] = arr[j];//向后移动这张牌
        }
        arr[j + 1] = temp;
    }
    for (int i = 2; i <= n; i++) {
        int temp = arr[i], j;
        for (j = i - 1; arr[j] > temp && j >= 1; j--) {//j代表的是此时比对的位置，从插入的牌的后面第一个开始
            arr[j + 1] = arr[j];//向后移动这张牌
        }//由于终止时要么不满足j<1,要么不满足arr[j]>temp,即arr[j]<temp或者已越界，所以此时j所指的是这张牌应在的后一个位置
        arr[j + 1] = temp;//此一步比这张牌小，后一步就比这张牌大,但是后一步的牌已经覆盖住了后后一步，所以直接覆盖掉它即可
    }//主要就是因为此时j指向的是，要么比它小的牌，要么越界的第一个，后一步是一定比这张牌大的，所以可以直接赋给下一个指针

归并排序

快速排序

 冒泡排序就是在一个序列当中，从起点开始，不断地往后冒泡交换，每次迭代确定一个最大值，随着冒泡次数的增多，然后最大值确定的也越来越多，需要相邻交换的次数越来越少

即外层循环n次，内层循环n-i次，整体是个n^2的复杂度

选择排序是从0开始保证序列的有序性，每次扩张序列的后一个数，然后和序列的最后一个数作比较，如果比序列的最后一个数大，那么就直接放着；不然，就往前移动，直到前一个数比它小，后一个数比它大，这个数就在有序序列中找到了自己的位置。

队列

7-1 模拟队列 分数 15

要么直接用queue,要么用数组模拟，用数组的话，一个指针表示队头指针，一个指针表示队尾，添加元素时，队尾增加，所以队尾指针增加；出队时，队头出，队头指针++

int p = 1, l = 0;
void push(int num) {
    q[++l] = num;
}
void pop() {
    p++;
}
bool empty() {
    if (l >= p) {
        return false;
    }
    else {
        return true;
    }
}
int query() {
    return q[p];
}

7-3 大師と仙人との奇遇 分数 20

就是队列里记录已经加入的每支股票的价格，然后先比较队头，直到队列为空或者不大于今天的价格就停止，操作完成后再入队今天的

    priority_queue<int, vector<int>, greater<int>>q;
    int n, num, ans = 0;
    cin >> n;
    for (int i = 1; i < n; i++) {
        cin >> num;
        if (q.empty()) {
            q.push(num);
        }
        else {
            while (!q.empty() && q.top() < num) {
                ans += (num - q.top());
                q.pop();
            }
            q.push(num);
        }
    }
    cin >> num;
    while (!q.empty()) {
        int cur = q.top();
        q.pop();
        ans += (num - cur);
    }
    priority_queue<int, vector<int>, greater<int>>q;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> num;
        int cnt = 0;
        if (i != n) {
            while (!q.empty()) {
                if (num > q.top()) {
                    q.pop();
                    cnt++;
                }
                else {
                    break;
                }
            }
        }
        else {
            cnt = q.size();
        }
        pin += cnt * num;
        if (i != n) {
            pout += num;
            q.push(num);
        }
    }
    cout << pin - pout << endl;

 

线性表、链表

7-2 后缀表达式求值

    string s1;
    stack<int>s;
    int sum, top = 0, num1, num2;
    getline(cin, s1);//getline函数可以保证输入空格时不中断
    for (int i = 0; s1[i] != '#'; i++) {
        if (s1[i] >= '0' && s1[i] <= '9') {
            sum = s1[i] - '0';//字符数字减去字符0，即可得到正常数字，因为在ASC里是连续的
            int j;
            for (j = i + 1; s1[i] != '#'; j++) {
                if (s1[j] >= '0' && s1[j] <= '9') {
                    sum = sum * 10 + (s1[j] - '0');
                }
                else { break; }
            }
            if (i > 0 && s1[i - 1] == '-') {
                sum = -sum;
            }
            i = j - 1;
            s.push(sum);
            top++;
        }
        else if (s1[i] == ' ') { continue; }
        else if (s1[i] == '-' && s1[i + 1] != ' ') { continue; }
        else {
            if (top < 2) {
                cout << "Expression Error" << s.top() << endl;
                return 0;
            }
            num1 = s.top();
            s.pop();
            top--;
            num2 = s.top();
            s.pop();
            top()--;
            switch (s1[i]) {
            case '+':s.push(num2 + num1); top++; break;
            case'-':s.push(num2 - num1); top++; break;
            case'*':s.push(num2 * num1); top++; break;
            case'/':
                if (num1 == 0) {
                    cout << "Error: " << num2 << "/0" << endl;
                }
                s.push(num2 / num1);
                top++;
                break;
            }
        }
    }
    if (top != 1) {
        cout << "Expression Error: " << s.top() << endl;
    }
    else {
        cout << s.top();
    }
    string s;
    stack<int>st;
    int sum, top = 0, num1, num2;
    getline(cin, s);
    for (int i = 0; s[i] != '#'; i++) {
        if (s[i] >= '0' && s[i] <= '9') {
            sum = s[i] - '0';
            int j;
            for (j = i + 1; s[i] != '#'; j++) {
                if (s[j] >= '0' && s[j] <= '9') {
                    sum = sum * 10 + (s[j] - '0');
                }
                else { break; }
            }
            if (i > 0 && s[i - 1] == '-') {
                sum = -sum;
            }
            i = j - 1;
            st.push(sum);
            top++;
        }
        else if (s[i] == ' ')continue;
        else if (s[i] == '-' && s[i + 1] != ' ')continue;
        else {
            if (top < 2) {
                cout << "E:" << st.top() << endl;
                return 0;
            }
            num1 = st.top();
            st.pop();
            top--;
            num2 = st.top();
            st.pop();
            top--;
            switch (s[i]) {
            case'+':s.push(num2 + num1); top++; break;
            case'-':s.push(num2 - num1); top++; break;
            case'*':s.push(num2 * num1); top++; break;
            case'/':if (num1 == 0) { cout << "E" << num2 << "/0" << endl; return 0; }
                   s.push(num2 / num1);
                   top++;
                   break;
            }
        }
    }
    if (top != 1)cout << "E" << s.top() << endl;
    else cout << s.top();

7-1 字符串匹配问题(strs)

遇到左括号入栈，遇到右括号出栈，

还有就是要注意括号的次序问题，就是把括号

    char a[] = { '{','[','(','<','}',']',')','>' };
    int b[300], n;
    cin >> n;
    while (n--) {
        string s;
        cin >> s;
        stack<int>st;
        bool flag = true;
        for (int i = 0; i < s.size(); i++) {
            for (int j = 0; j < 8; j++) {
                if (s[i] == a[j]) {
                    b[i] = j;
                    break;//就是把原来的括号字符串转换为B里的数字数组
                }
            }
        }
        for (int i = 0; i < s.size(); i++) {
            if (b[i] <= 3) {
                if (!st.empty() && b[i] < st.top()) {//用数字代表括号的优先次序，那么能不能继续插入，就是看堆顶的元素的编号和此时自己的关系
                    flag = false;//也就是必须要保证一个递增的顺序，不然就不能继续插入
                    break;
                }
                else {
                    st.push(b[i]);
                }//正常插入
            }
            else if (b[i] >= 4) {
                if (st.empty() || (st.top() + 4) != b[i]) {
                    flag = false;
                    break;
                }
                else {
                    st.pop();//正常的匹配，删除
                }
            }
        }
        if (!st.empty())cout << "no" << endl;
        else if (flag)cout << "yes" << endl;
        else cout << "no" << endl;
    }

检验栈序列

    cin >> q;
    while (q--) {
        cin >> n;
        stack<int>s;
        int cnt = 1;
        for (int i = 1; i <= n; i++)cin >> push[i];
        for (int i = 1; i <= n; i++)cin >> pop[i];
        for (int i = 1; i <= n; i++) {
            s.push(push[i]);//先入
            while (!s.empty() && s.top() == pop[cnt]) {//然后一直出队列，要求队列不空而且栈顶元素和Pop此时指向元素相同
                s.pop();
                cnt++;
            }
        }
        if (s.empty())cout << "Yes" << endl;
        else cout << "No" << endl;
    }

6-2 寻找链表元素的前驱结点

ptr pre(ptr h,int x){
    ptr res=new node();
    if(h==nullptr||h->data==x){return NULL;}
    else{
        res->next=h;
        while(h!=NULL){
            if(h->data==x){return res;}
            res=h;
            h=h->next;
        }
    }
    return NULL;
    /*if(h==NULL){return nullptr;}else{
        return res;
    }*/
  
}

线性表删除

List Delete( List &L, ElementType minD, ElementType maxD ){
        int left=0;
    int length=L.last;
        for(int i=0;i<=length;i++){
            if(L.Data[i]<minD||L.Data[i]>maxD){
                //L.last--;
                continue;//这样就表示删掉了
            }
            L.Data[left++]=L.Data[i];
        }
    L.last=left;
    return L;
}

栈 

7-3 胡同

    cin >> t;
    while (t--) {
        cin >> n;
        for (int i = 1; i <= n; i++)cin >> a[i];
        for (int i = 1; i <= n; i++)cin >> b[i];
        stack<int>st;
        int cnt = 1;
        for (int i = 1; i <= n; i++) {
            st.push(a[i]);
            while (!st.empty() && st.top() == b[cnt]) {
                st.pop();
                cnt++;
            }
        }
        if (st.empty())cout << "yes";
        else cout << "no";
    }

括弧匹配，弱化版

    string s;
    stack<char>ch;
    bool flag = true;
    cin >> s;
    for (int i = 0; i < s.length(); i++) {
        if (s[i] == '(')ch.push(')');
        if (s[i] == '[')ch.push(']');
        if (s[i] == ']') {
            if (ch.empty()||ch.top()!=']') {
                flag = false;
                break;
            }
            else {
                ch.pop();
            }
        }
        if (s[i] == ')') {
            if (ch.empty() || ch.top() != ')') {
                flag = false;
                break;
            }
            else {
                ch.pop();
            }
        }
    }
    if (ch.empty() && flag) { cout << "ok" << endl; }
    else {
        cout << "no" << endl;
    }

选择题复习

Ologn

看重复执行次数，为1+2+4+……+n，那么最后就是等比数列求和，N可以被视为2的指数次，用等比求和公式算，算完是On的复杂度

链表结点定义为(data,next},在P指向的结点之后插入结点S的代码是 S->next=P->next; P->next=S;

即遍历一次数组，但不需要做任何操作

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

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

相关文章

C++day2作业

C++day2作业

把课上strcut的练习&#xff0c;尝试着改成class #include <iostream>using namespace std; class Stu { private:int age;string sex;int hign; public:int soce;void get_information();void set_information(); }; void Stu::set_information() {static Stu s1;cout …
阅读更多...
C语言KR圣经笔记 5.1指针和地址 5.2指针和函数参数

C语言KR圣经笔记 5.1指针和地址 5.2指针和函数参数

第五章 指针和数组 指针是包含变量地址的变量。在 C 语言中&#xff0c;指针被大量使用&#xff0c;部分原因是有时只能用指针来表达某种计算&#xff0c;而部分原因是相比其他方式&#xff0c;指针通常能带来更紧凑和高效的代码。指针和数组是紧密关联的&#xff1b;本章也讲…
阅读更多...
抓包工具Charles安装及使用

抓包工具Charles安装及使用

Charles 介绍 Charles 是在 Mac 下常用的网络封包截取工具&#xff0c;在做 移动开发时&#xff0c;我们为了调试与服务器端的网络通讯协议&#xff0c;常常需要截取网络封包来分析。 Charles 通过将自己设置成系统的网络访问代理服务器&#xff0c;使得所有的网络访问请求都…
阅读更多...
VScode——下载、安装、配置C/C++环境（windows）

VScode——下载、安装、配置C/C++环境（windows）

一.快速下载 还在因为vscode官方下载慢而头疼嘛&#xff0c;按这个步骤来直接起飞兄弟萌 首先进入vscode官方网站然后选择对应版本下载然后进入浏览器下载页面复制下载链接粘贴到地址栏 将地址中的/stable前换成vscode.cdn.azure.cn 即可实现超速下载 下面是一个国内镜像的下…
阅读更多...
删除数据后， redis 内存占用还是很高怎么办？

删除数据后， redis 内存占用还是很高怎么办？

现象&#xff1a; reids 做了数据删除&#xff0c;数据量不大&#xff0c;使用 top 命令看&#xff0c;发现还是占用大量内存 原因&#xff1a; 1.redis 底层内存根据内存分配器分配&#xff0c;不会立刻释放 2.redis 释放的内存空间不是连续的&#xff0c;存在碎片 内存碎…
阅读更多...
DP进阶之路——整数拆分

DP进阶之路——整数拆分

343. 整数拆分 给定一个正整数 n &#xff0c;将其拆分为 k 个 正整数 的和&#xff08; k > 2 &#xff09;&#xff0c;并使这些整数的乘积最大化。 返回 你可以获得的最大乘积 。 示例 1: 输入: n 2 输出: 1 解释: 2 1 1, 1 1 1。 示例 2: 输入: n 10 输出: 36 解释…
阅读更多...
YOLOv8训练自定义数据集和运行参数解读

YOLOv8训练自定义数据集和运行参数解读

1、YOLOv8深度学习环境搭建及安装 1.1. Yolov8介绍 设置操作类型 YOLOv8模型可用于各种任务&#xff0c;包括检测、分割和分类。这些任务的不同之处在于它们产生的输出类型和它们要解决的特定问题。 **检测:**检测任务涉及识别和定位图像或视频中感兴趣的对象或区域。YOLO模…
阅读更多...
任务调度-hangfire

任务调度-hangfire

目录 一、Hangfire是什么&#xff1f; 二、配置服务 1.配置Hangfire服务 2.添加中间件 3.权限控制 三、配置后台任务 1.在后台中调用方法 2.调用延时方法 3.执行周期性任务 四、在客户端上配置任务 1.在AddHangfire添加UseHangfireHttpJob方法 2.创建周期任务 3.创建只读面板 总…
阅读更多...
【《设计模式之美》】如何取舍继承与组合

【《设计模式之美》】如何取舍继承与组合

文章目录 什么情况下不推荐使用继承&#xff1f;组合相比继承有哪些优势&#xff1f;使用组合、继承的时机 本文主要想了解&#xff1a; 为什么组合优于继承&#xff0c;多用组合少用继承。如何使用组合来替代继承哪些情况适用继承、组合。有哪些设计模式使用到了继承、组合。 …
阅读更多...
腾讯云轻量应用服务器和云服务器有什么不同?

腾讯云轻量应用服务器和云服务器有什么不同?

腾讯云轻量服务器和云服务器CVM该怎么选&#xff1f;不差钱选云服务器CVM&#xff0c;追求性价比选择轻量应用服务器&#xff0c;轻量真优惠呀&#xff0c;活动 https://curl.qcloud.com/oRMoSucP 轻量应用服务器2核2G3M价格62元一年、2核2G4M价格118元一年&#xff0c;540元三…
阅读更多...
linux ext3/ext4文件系统（part1格式化）

linux ext3/ext4文件系统（part1格式化）

ext4文件系统结构 ext3的代码已经在v4.3被删除掉了&#xff08;ARM: tegra: Rebuild default configuration on v4.3-rc1 torvalds/linux241e077 GitHub&#xff09; ext4格式化的代码可以参考e2fsprogs的实现&#xff1a;mke2fs.c 格式化后的文件系统结构如下图&#xf…
阅读更多...
AI绘图软件，科技之旅绘画

AI绘图软件，科技之旅绘画

科技与艺术的碰撞总能产生令人惊叹的火花&#xff0c;现在小编要给大家介绍一款引领未来艺术潮流的AI绘图软件——首助编辑高手。这是一款将人工智能与创意绘画完美结合的软件&#xff0c;它将为你打开一扇全新的创意之门。 所需工具&#xff1a; 一个【首助编辑高手】软件 …
阅读更多...
mysql原理---InnoDB统计数据是如何收集的

mysql原理---InnoDB统计数据是如何收集的

以下聚焦于 InnoDB 存储引擎的统计数据收集策略。 1.两种不同的统计数据存储方式 InnoDB 提供了两种存储统计数据的方式&#xff1a; (1). 永久性的统计数据 这种统计数据存储在磁盘上&#xff0c;也就是服务器重启之后这些统计数据还在。 (2). 非永久性的统计数据 这种统计数…
阅读更多...
❀My学习小记录之算法❀

❀My学习小记录之算法❀

目录 算法:) 一、定义 二、特征 三、基本要素 常用设计模式 常用实现方法 四、形式化算法 五、复杂度 时间复杂度 空间复杂度 六、非确定性多项式时间&#xff08;NP&#xff09; 七、实现 八、示例 求最大值算法 求最大公约数算法 九、分类 算法:) 一、定义 …
阅读更多...
Smartbi获工信部旗下赛迪网“2023行业信息技术应用创新产品”奖

Smartbi获工信部旗下赛迪网“2023行业信息技术应用创新产品”奖

近日&#xff0c;由工信部旗下的赛迪网、《数字经济》杂志共同主办的2023行业信息技术应用创新大会上&#xff0c;“信息技术应用创新成果名单”重磅揭晓&#xff0c;思迈特软件凭借“Smartbi 自然语言分析引擎”斩获“2023行业信息技术应用创新产品”大奖。 据了解&#xff0c…
阅读更多...
codellama模型部署（待补充）

codellama模型部署（待补充）

codellama介绍 Code Llama 是一个基于Llama 2的大型代码语言模型系列&#xff0c;在开放模型、填充功能、对大输入上下文的支持以及编程任务的零样本指令跟踪能力中提供最先进的性能。我们提供多种风格来覆盖广泛的应用程序&#xff1a;基础模型 (Code Llama)、Python 专业化 …
阅读更多...
【String str = new String(“AAA“) 创建了几个对象？】

【String str = new String(“AAA“) 创建了几个对象？】

✅典型解析 创建的对象数应该是1个或者2个。 首先要清楚什么是对象? Java是一种面向对象的语言&#xff0c;而Java对象在JVM中的存储也是有一定的结构的&#xff0c;在HotSpot虚机中&#xff0c;存储的形式就是oop-klass model&#xff0c;即ava对象模型。我们在Java代码中&am…
阅读更多...
Vue框架引入Axios

Vue框架引入Axios

首先已经创建好了 Vue 框架&#xff0c;安装好了 node.js。 没有完成的可按照此博客搭建&#xff1a;搭建Vue项目 之后打开终端&#xff0c;使用命令。 1、命令安装 axios 和 vue-axios npm install axios --save npm install vue-axios --save2、package.json 查看版本 在 p…
阅读更多...
Binder系列-service_manager.c

Binder系列-service_manager.c

1. service_manager的任务 open 驱动告诉驱动&#xff0c;它是“servicemanager”在一个循环里 从驱动读取数据 解析数据 调用&#xff0c;根据code执行注册服务或者获取服务 &#xff08;图来自韦老师的视频&#xff09; 2.代码流程 2.1.open驱动 //framework…
阅读更多...
elasticsearch列一：索引模板的使用

elasticsearch列一：索引模板的使用

概述 近期一直在负责es这块&#xff0c;就想着和大家分享一些使用经验&#xff0c;我们从存储、查询、优化、备份、运维等几个方面来做分享。今天咱们先看下如何更加合理的存储数据。 初见索引模板 记得刚接触es还是18年那会&#xff0c;项目上线后因一些原因导致日志这部分的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023