其他分享
首页 > 其他分享> > mylib

mylib

作者:互联网

#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;
}


标签:arr,right,return,mylib,int,vector,left
来源: https://blog.csdn.net/Dawn_yc/article/details/120536881