mylib

最新推荐文章于 2024-05-09 21:35:25 发布
最新推荐文章于 2024-05-09 21:35:25 发布
阅读量284 收藏
点赞数
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawn_yc/article/details/120536881
版权 
#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
#include <map>
#include <algorithm>
#include <math.h>
#include <stack>
using namespace std;

//字符串分割
void SplitString(const std::string &s, std::vector<std::string> &vs, const std::string &patten)
{
    std::string::size_type pos1, pos2;
    pos2 = s.find(patten);
    pos1 = 0;
    while (std::string::npos != pos2)
    {
        vs.push_back(s.substr(pos1, pos2 - pos1));

        pos1 = pos2 + patten.size();
        pos2 = s.find(patten, pos1);
    }
    if (pos1 != s.length())
        vs.push_back(s.substr(pos1));
}

//单例模式
class Singleton
{
public:
    ~Singleton() { std::cout << "destructor called!" << std::endl; }
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
    static Singleton &get_instance()
    {
        static Singleton instance;
        return instance;
    }

    int main()
    {
        Singleton &instance_1 = Singleton::get_instance();
        Singleton &instance_2 = Singleton::get_instance();
        return 0;
    }
private:
    Singleton() { std::cout << "constructor called!" << std::endl; }
};

//使用数组实现栈
class mystack
{
private:
    typedef int ElementType; /*栈元素类型*/
    #define SUCCESS 1
    #define FAILURE -1
    #define STACK_SIZE 64 /*栈大小*/
    #define TOP_OF_STACK -1 /*栈顶位置*/
    int topOfStack ; /*记录栈顶位置*/
    ElementType stack[STACK_SIZE]; /*栈数组，也可以使用动态数组实现*/

public:
    /*构造函数*/
    mystack()
    {
        topOfStack = TOP_OF_STACK;//初始化栈顶
    }

    /*入栈，0表示成功，-1表示出错*/
    int push(ElementType value)
    {
        if(this->full())
            return FAILURE;
        /*先增加topOfStack，再赋值*/
        topOfStack++;
        stack[topOfStack] = value;
        return SUCCESS;
    }

    /*出栈*/
    int pop()
    {
        /*首先判断栈是否为空*/
        if(this->empty())
            return FAILURE;        
        topOfStack--;
        return SUCCESS;
    }

    /*访问栈顶元素*/
    ElementType top()
    {
        /*首先判断栈是否为空*/
        if(this->empty()){
            std::cerr << "stack is empty! can't get top element" << '\n';
            return FAILURE;
        }        
        ElementType value = stack[topOfStack];
        return value;
    }

    /*判断栈是否已满，满返回1，未满返回0*/
    int full()
    {
        return topOfStack == STACK_SIZE - 1;
    }

    /*判断栈是否为空，空返回1，非空返回0*/
    int empty()
    {
        return topOfStack ==  - 1;
    }
};

//使用数组实现队列（实际使用循环队列）
class myqueue
{
private:
    typedef int ElementType;
    #define MAX_SIZE 5    
    #define SUCCESS 1
    #define FAILURE -1

    /*定义队列结构*/
    int front; //队头位置
    int rear;  //队尾位置
    ElementType queueArr[MAX_SIZE]={};//队列数组

public:
    myqueue()
    {
        front = 1;
        rear = 0;
    }

    /*判断队列是否已满*/
    bool full()
    {
        if((rear + 2) % MAX_SIZE == front)
        {
            printf("queue is full\n");
            return true;
        }
        else 
            return false;
    }

    /*判断队列是否为空*/
    bool empty()
    {
        if((rear + 1) % MAX_SIZE == front)
        {
            printf("queue is empty\n");
            return true;
        }
        else 
            return false;
    }

    /*出队*/
    int pop()
    {
        if(this->empty())
            return FAILURE;
        front = (front + 1) % MAX_SIZE;
        return SUCCESS;
    }

    /*入队*/
    int push(ElementType value)
    {
        if(this->full())
            return FAILURE;
        rear = (rear + 1) % MAX_SIZE;
        queueArr[rear] = value;   
        return SUCCESS;
    }

    ElementType getfront(){
        return queueArr[front];
    }

};

//归并排序
class mergeSort
{
public:
    // 构造函数 参数为要排序的vector
    mergeSort(std::vector<int> &arr){
        dfs(arr, 0, arr.size() - 1);
    }

    // 合并过程
    void merge__(vector<int> &arr, int l, int mid, int r) {
        vector<int> tmp(r - l + 1);
        int i = l, j = mid + 1, k = 0;

        while (i <= mid && j <= r) {
            if (arr[i] >= arr[j]) {
                tmp[k++] = arr[j++];
            }
            else {
                tmp[k++] = arr[i++];
            }
        }

        while (i <= mid) {
            tmp[k++] = arr[i++];
        }
        while (j <= r) {
            tmp[k++] = arr[j++];
        }

        for (k = 0, i = l; i <= r; ++i, ++k) {
            arr[i] = tmp[k];
        }
    }

    // 递归划分过程
    void dfs(vector<int> &arr, int l, int r) {
        // 只有一个数字，则停止划分
        if (l >= r) {
            return;
        }
        int mid = l + ((r - l) >> 1);
        dfs(arr, l, mid);      //划分左
        dfs(arr, mid + 1, r);  //划分右
        // 合并两个有序区间
        merge__(arr, l, mid, r);
    }
};

//快排
class quick_sort
{
public:
    int partition(vector<int> &A, int left, int right)
    {
        int i = left;
        for (int j = left; j <= right - 1; j++)
        {
            if (A[j] <= A[right])
            {
                swap(A[i], A[j]);
                i++;
            }
        }
        swap(A[i], A[right]);
        return i;
    }
    void quicksort(vector<int> &A, int left, int right)
    {
        if (right <= left)
            return;
        int q = partition(A, left, right);
        quicksort(A, left, q - 1);
        quicksort(A, q + 1, right);
    }
    quick_sort(vector<int> &A, int left, int right)
    {
        quicksort(A, left, right);
    }
};

//最小的k个数 使用快排
class Solution
{
public:
    int partition(vector<int> &A, int left, int right)
    {
        int i = left;
        for (int j = left; j <= right - 1; j++)
        {
            if (A[j] <= A[right])
            {
                swap(A[i], A[j]);
                i++;
            }
        }
        swap(A[i], A[right]);
        return i;
    }
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k)
    {
        vector<int> ret;
        if (k == 0 || k > input.size())
            return ret;
        int left = 0, right = input.size() - 1;
        while (left <= right)
        {
            int p = partition(input, left, right);
            if (p + 1 == k) //p为第k小的数
                return vector<int>({input.begin(), input.begin() + k});
            else if (p + 1 < k)
                left = p;
            else
                right = p - 1;
        }
        return ret;
    }
};

//寻找第K大 使用快排思路
class Solution
{
public:
    int partition(vector<int> &A, int left, int right)
    {
        int i = left;
        for (int j = left; j <= right - 1; j++)
        {
            if (A[j] >= A[right])
            { //从大到小排列
                swap(A[i], A[j]);
                i++;
            }
        }
        swap(A[i], A[right]);
        return i;
    }
    int findKth(vector<int> input, int n, int k)
    {
        if (k == 0 || k > input.size())
            return 0;
        int left = 0, right = input.size() - 1;
        while (left <= right)
        {
            int p = partition(input, left, right);
            if (p + 1 == k) //p为第k大的数
                return input[p];
            else if (p + 1 < k) //p在K前面,从p开始继续排序
                left = p;
            else
                right = p - 1; //p在k后面,从之前到p-1排序
        }
        return 0;
    }
};

//重建二叉树（前序和中序）
class Solution
{
private:
    struct TreeNode
    {
        int val;
        TreeNode *left;
        TreeNode *right;
        TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    };

public:
    int p = 0;
    TreeNode *rebuild(vector<int> preorder, vector<int> inorder, int vleft, int vright)
    {
        for (int i = vleft; i < vright; i++)
        {
            if (inorder[i] == preorder[p])
            {
                int root = i;
                p++;
                TreeNode *tree = new TreeNode(inorder[root]);

                tree->left = rebuild(preorder, inorder, vleft, root);
                tree->right = rebuild(preorder, inorder, root, vright);
                return tree;
            }
        }
        return NULL;
    }
    TreeNode *reConstructBinaryTree(vector<int> preorder, vector<int> inorder)
    {
        TreeNode *res = rebuild(preorder, inorder, 0, inorder.size());
        return res;
    }
};

//重建二叉树（中序和后序）
class Solution
{
    int post_idx;
    unordered_map<int, int> idx_map;
    struct TreeNode
    {
        int val;
        TreeNode *left;
        TreeNode *right;
        TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    };

public:
    TreeNode *rebuild( vector<int> inorder, vector<int> postorder,int in_left, int in_right)
    {
        // 如果这里没有节点构造二叉树了，就结束
        if (in_left > in_right)
            return nullptr;        

        // 选择 post_idx 位置的元素作为当前子树根节点
        int root_val = postorder[post_idx];
        TreeNode *root = new TreeNode(root_val);

        // 根据 root 所在位置分成左右两棵子树
        int index = idx_map[root_val];

        // 下标减一
        post_idx--;
        // 构造右子树
        root->right = rebuild( inorder, postorder,index + 1, in_right);
        // 构造左子树
        root->left = rebuild(inorder, postorder,in_left, index - 1);
        return root;
    }
    TreeNode *buildTree(vector<int> inorder, vector<int> postorder)
    {
        // 从后序遍历的最后一个元素开始
        post_idx = (int)postorder.size() - 1;

        // 建立（元素，下标）键值对的哈希表
        int idx = 0;
        for (auto &val : inorder)
        {
            idx_map[val] = idx++;
        }
        return rebuild( inorder, postorder,0, (int)inorder.size() - 1);
    }
};

//素数筛法
vector<bool> eratosthenes(int num)
{
    vector<bool> flag(num + 1, true);
    flag[0] = flag[1] = false; //exclude 0 and 1
    for (int i = 2; i * i <= num; ++i)
    {
        if (flag[i])
        {
            for (int j = i * i; j <= num; j += i)
                flag[j] = false;
        }
    }
    return flag;
}


#include <iostream> 
using namespace std;
 
// int main() 
// { 
//     int a,b; 
//     freopen("in.txt","r",stdin); //输入重定向，输入数据将从in.txt文件中读取
//     freopen("out.txt","w",stdout); //输出重定向，输出数据将保存在out.txt文件中
//     while(cin>> a >> b) 
//         cout<< a+b <<endl; // 注意使用endl
//     fclose(stdin);//关闭文件
//     fclose(stdout);//关闭文件
//     return 0; 
// }

struct node
{
    int x;
    int y;
    int step;
    node():x(0),y(0),step(0){}
    node(int xx,int yy,int st){
        x=xx;
        y=yy;
        step=st;
    }
};

class myqueue
{
private:
    typedef node ElementType;
    #define MAX_SIZE 10000    
    #define SUCCESS 1
    #define FAILURE -1

    /*定义队列结构*/
    int front; //队头位置
    int rear;  //队尾位置
    ElementType queueArr[MAX_SIZE]={};//队列数组

public:
    myqueue()
    {
        front = 1;
        rear = 0;        
    }

    /*判断队列是否已满*/
    bool full()
    {
        if((rear + 2) % MAX_SIZE == front)
        {
            printf("queue is full\n");
            return true;
        }
        else 
            return false;
    }

    /*判断队列是否为空*/
    bool empty()
    {
        if((rear + 1) % MAX_SIZE == front)
        {
            printf("queue is empty\n");
            return true;
        }
        else 
            return false;
    }

    /*出队*/
    int pop()
    {
        if(this->empty())
            return FAILURE;
        front = (front + 1) % MAX_SIZE;
        return SUCCESS;
    }

    /*入队*/
    int push(ElementType value)
    {
        if(this->full())
            return FAILURE;
        rear = (rear + 1) % MAX_SIZE;
        queueArr[rear] = value;   
        return SUCCESS;
    }

    ElementType getfront(){
        return queueArr[front];
    }

};

int main(void)
{
    /*队列初始化*/
    myqueue queue;
    int dirx[4]={0,0,1,-1};
    int diry[4]={1,-1,0,0};
    int used[8][8]={0};
    int arr[8][8]={
        {0,0,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,0},
        {0,0,0,1,0,0,0,0},
        {1,1,0,1,0,1,1,0},
        {0,0,0,1,0,0,1,1},
        {0,0,1,1,0,0,0,0},
        {0,0,0,0,0,1,1,0},
        {0,0,0,0,0,1,0,0}
    };
    
    used[0][0]=1;
    queue.push(node(0,0,1));
    while(!queue.empty()){
        node now = queue.getfront();
        queue.pop();
        if(now.x==7 && now.y==7){
            cout<<now.step;
            break;
        }
        for(int i=0;i<4;i++){
            int dx = now.x + dirx[i];
            int dy = now.y + diry[i];
            if(dx<0||dy<0||dx>=8||dy>=8||used[dx][dy]==1||arr[dx][dy]==1)
                continue;
            used[dx][dy] = 1;
            int v = now.step;
            if(arr[dx][dy]==0)v++;
            queue.push(node(dx,dy,v));

        }
    }
    return 0;
}
Dawn_yc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mylib使用说明
u014594609的博客
08-17 1344
//mylib命名空间定义 namespace mylib { extern "C" { #include "mylib/mylib.h" #include "mylib/array.h" #include "mylib/image.h" #include "mylib/histogram.h" } }; 以下主要说明使用array.h,image.h的方式 array的结构 typ
MyLib
03-18
MyLib
【Linux】C语言动态库和静态库的制作和使用
凉开水白菜的博客
05-24 951
静态库 mylib.c #include <stdio.h> void mylib_api(void); void mylib_api(void) { printf("mylib printf\r\n"); } main.c #include <stdio.h> void mylib_api(void); int main() { mylib_api(); return 0; } 编译静态库 gcc -c mylib.c ar cr libmylib.a myli
翻译QT使用手册：将库添加到项目
thanklife的专栏
11-29 1249
除了 Qt 库之外，您还可以将其他库添加到您的项目中。您可以添加系统库、您自己的库或第三方库。除了 Qt 库之外，您还可以将其他库添加到您的项目中。您可以添加系统库、您自己的库或第三方库。对于您自己的库和第三方库，您需要指定路径。Windows 上的默认约定是库的调试版本和发布版本具有相同的名称，但放在不同的子目录中，通常称为。一旦您的项目成功构建并链接到它们，Qt Creator 就支持添加库的代码完成和语法突出显示。因为系统库通常不会更改并且通常默认找到，所以在添加库时不需要指定库路径或包含库的路径。
JavaScript函数
weixin_41684949的博客
05-22 250
为了以后方便查找，现简单罗列JavaScript中常用的函数。 alert(str) escape(str)和unescape(str)，是一对编解码函数，注意escape()不会对ASCII字母和数字进行编码，也不会对@ - _ + . /等ASCII标点符号进行编码。 eval(str) isNaN() parseFloat(str)，parseInt(str,radix)：用于将字...
python解决导入自定义库失败： ModuleNotFoundError: No module named 'MyLib'
weixin_30821731的博客
02-05 982
python安装目录：...\python_3_6_1_64bit 新建文件：chenyeubai.pth，写入库所在的绝对路径E:\workSpace\my_code\learn\myLib 安装路径下的.pth文件会在运行时将文件中路径写入path 转载于:https://www.cnblogs.com/chenyuebai/p/8416706.html...
探索Chat-mylib：一款创新的个人知识库与聊天集成平台
gitblog_00085的博客
04-22 351
探索Chat-mylib：一款创新的个人知识库与聊天集成平台 项目地址:https://gitcode.com/sunmh207/chat-mylib 项目简介 Chat-mylib 是一个开源项目，旨在将个人的知识库与实时聊天功能相结合，打造一个高效的知识管理和协作工具。通过它，你可以构建自己的知识体系，并与他人进行即时交流，共享智慧。 技术分析 基于Markdown的内容管理 Chat-myl...
Python库 | mylib_maureen-1.2.5.tar.gz
04-11
资源分类：Python库 所属语言：Python 资源全名：mylib_maureen-1.2.5.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
my lib [各种用途的C语言库]
06-14
1. 各种线程间通信 [跨平台]: 消息队列， 以及虚拟port；<br>2. 有限状态机 [跨平台]：适应中、大型状态机，并实现了状态机远程监视； 由于该有限状态机按照嵌入式规则实现，同样可以用于各种嵌入式环境。该状态机还支持快速查找，克隆。<br>3. 线程间各种同步机制、各种线程间/进程间通信机制，以及跨平台支持<br>4. 内存检测机制，支持内存泄漏发现定位，多次释放内存，释放空内存，非法内存操作，内存越界；
mylib工具依赖包
02-04
py_innodb_page_info.py py_innodb_page_info.pypy_innodb_page_info.py
C++ | Leetcode C++题解之第78题子集
Ddddddd_158的博客
05-09 251
C++ | Leetcode C++题解之第78题子集
C语言 | Leetcode C语言题解之第69题x的平方根
m0_59237910的博客
05-05 508
C语言 | Leetcode C语言题解之第69题x的平方根
解密SSL/TLS：密码套件扫描仪的深度解析(C/C++代码实现)
chen1415886044的博客
05-06 797
SSL/TLS协议是网络安全中不可或缺的一部分，它们为网络通信提供了传输层的数据安全。 首先，来了解一下SSL和TLS的概念。SSL（安全套接字层）是一种早期的安全协议，它的主要目的是在Web服务器和Web浏览器之间创建加密连接。而TLS（传输层安全性）是SSL的后继者，它在SSL的基础上进行了改进和标准化，目前被广泛使用以确保互联网通信的私密性和数据安全性。 接下来，深入探讨一下SSL/TLS协议的基础构成。SSL/TLS协议主要分为两层，底层是记录协议，负责使用对称密码对消息进行加密。
【C++ list所有函数举例如何使用】
m0_45463480的博客
05-09 223
类中一些常用函数的示例用法。您可以使用这些示例来操作列表，例如添加、删除、访问元素等。请记住，在实际应用中，应该根据具体情况选择合适的函数来操作。，以确保数据结构的正确性和高效性。希望这些示例对您有所帮助。如果您有任何疑问，请随时提出。是一个双向链表，提供了在列表中添加、删除、访问元素等操作的方法。
c++ 查看线程状态
xie__jin__cheng的博客
05-06 247
c++ 查看线程状态
【C++】多态 — 多态的细节补充（下篇）
最新发布
weixin_42976474的博客
05-09 172
我们学习了多态的形式和如何使用多态，这一章我们将来讲一讲多态的原理…
C++ 字符串补充（二）
weixin_56362288的博客
05-06 110
在C++中，可以使用std::getline(std::cin,变量名)函数来实现包含空格的字符串输入。单引号直接按文本要求输出即可，双引号需要在前面加“\”。
cl /c /EHsc /DMYLIB_EXPORTS mylib.cpplink /DLL /OUT:mylib.dll mylib.obj该命令的含义
06-03
综上，这个命令的作用是将`mylib.cpp`源文件编译为目标文件`mylib.obj`，然后将`mylib.obj`文件链接为动态库`mylib.dll`。在编译时定义`MYLIB_EXPORTS`宏，以便编译器在生成动态库时导出函数。这个命令可以用于生成...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值