【LeetCode】通用操作总结

二维矩阵_转置

// 二维数组
// 二维数组可以通过嵌套vector<vector<int>> vec构建出来
vector<vector<int>> vec(2, vector<int>(2, 0)); // 2 * 2的矩阵，全部初始化为0

// 注意嵌套的下标
string Transpose(const string& str)
{
    
    int len = str.size();
    int side = sqrt(len);
    if (len != side * side) {
    
        return "ERROR";
    }
    
    int count = 0;
    char arry[side][side];
    for (int i = 0; i < side; i++) {
    
        for (int j = 0; j < side; j++) {
     // 写错了，这个起始点坐标应该是0，错误写成j = i
            arry[i][j] = str[count++];
        }
    }

    for (int i = 0; i < side; i++) {
    
        for (int j = i + 1; j < side; j++) {
    
            char temp = arry[i][j];
            arry[i][j] = arry[j][i];
            arry[j][i] = temp;
        }
    }

    string res = "";
    for (int i = 0; i < side; i++) {
    
        for (int j = 0; j < side; j++) {
    
            res += arry[i][j];
        }
    }
    return res;
}

find

int firstIndex = str.find_first_of(cha);
int lastIndex = str.find_last_of(cha);

str.find("4") != string::npos ||str.find("18") != string::npos

string str = "45618";
int i = str.find("4"); // 0
int j = str.find("18"); // 3

// vector
vector<string> vec2 = {
    "time","me","bell"};
if (find(vec2.begin(), vec2.end(), "time") != vec2.end()) {
    
    
}

// map
auto iter = find(mp.begin(), mp.end(), value);
if (iter == mp.end()) {
    
    int first = iter.first;
    int second = iter.second;   
}

// set
if (st.find(cal) != st.end()) {
    
    res++;
}

pow

// 次方运算
pow(numSet.size(), 4);

queue 优先队列priority_queue

queue<int> q;

int tmp = q.front(); // 队头元素

q.pop();
q.push(tmp);


// 插入元素后需要动态变化，更新最大值和最小值，可以考虑用优先队列
// 更新方式：取出队头元素存入临时变量，更新结果，再存入队列

//升序队列
priority_queue <int,vector<int>,greater<int>> q; // 队头开始从小到大排列
// 队头最大：降序队列
priority_queue <int,vector<int>,less<int>>q; // 不写默认队头最大，队头开始从大到小排列

// 队头最小：多个元素的优先队列，按照第一个元素排序
priority_queue<tuple<int, int>, vector<tuple<int, int>>, greater<>> queServer; // 每次将最小的放在队头（默认按照第一个元素排列！！！）

rand

// 随机数：取出map中任意一个元素 
int randomIndex = rand()%mp.size();

reverse

// 字符串
reverse(str.begin(), str.end());

// 数组
reverse(vec.begin(), vec.end());

set

// set插入元素
st.insert(a);

//删除元素
st.erase(a);

// 清空元素
st.clear();

// vector必须按照索引删除元素
// set可以直接删除指定元素，如删除set res中子字符串
https://leetcode.cn/problems/short-encoding-of-words/submissions/
// set删除重复元素
// 删除相同元素，优先考虑用set，先把数组中的元素过滤一遍，重复的删除
set <"time", "me", "bell">
for (auto& str : res) {
    
    for (int i = 1; i < str.size(); i++) {
    
        res.erase(str.substr(i)); // 遍历每一个元素，删除子字符串（下次比那里res已被更新，只有bell元素）
    }
}


// set的查找(vector map相同，set直接找元素就行)
int Proc(vector<int>& arr, int diff)
{
    
    // 在此添加你的代码
    set<int> st;
    for (auto a : arr) {
    
        st.insert(a);
    }

    int res = 0;
    for (auto value : arr) {
    
        int cal = value + diff;
        if (st.find(cal) != st.end()) {
    
            res++;
        }
    }
    return res;
}

vector

vector<map<int, int>>
map<int, vector<int>>

//初始化
vector<tuple<int, int>> roomSytem(1000); // 1、长度初始化
vector<tuple<int, int>> roomSytem(1000, make_tuple(0, 0)); //2、初始化长度，并附初值
vector<int> res(2, 0); // 初始化固定长度2，元素全为0

// 合并两个数组（不需要用两个for循环）
vector<int> merge;
merge.insert(merge.end(), arr.begin(), arr.end());
merge.insert(merge.end(), arr.begin(), arr.end());

// 求vector中的最大值和最小值
// 进阶1：排序取首尾元素
// 进阶2：直接用系统函数
vector<int> words = {
     1,2,1 };
int max = *max_element(words.begin(), words.end());
int min = *min_element(words.begin(), words.end());

// 取vector尾部元素
vector<int> res;
int end = res.back(); 

// 判断两个数组是否相等，直接if判断
if (vec1 == vec2)

// vector删除元素（迭代器对应索引）
num.erase(num.begin() + i); // vector中删除一个元素

vector<int> num = {
     5,4,3,2,1 };
num.erase(num.begin(), num.begin() + 3); // 2 1 // 如果是中间不包含最后一个元素
num.erase(num.begin() + 3, num.end()); // 5 4 3 // 如果是end，直接删除到最后

// vector清空元素
vec.clear();

// vector是否有序
if (is_sorted(num.begin(), num.end()) || is_sorted(num.begin(), num.end(), greater<>()))

// 删除数组元素后是否有序
int SortByDeleteOne(const vector<int> &Nums)
{
    
    int res = INT_MAX;
    for (int i = 0; i < Nums.size(); i++) {
    
        vector<int> num = Nums;
        int tmp = num[i];
        num.erase(num.begin() + i);
        if (is_sorted(num.begin(), num.end()) || is_sorted(num.begin(), num.end(), greater<>())) {
    
            res = min(res, tmp);
        }
    }
    return res == INT_MAX ? -1 : res;
}

// 统计vector中字符个数
vector<string> vec2 = {
    "time","me","bell", "time"};
int num = count(vec2.begin(), vec2.end(), "time");

// 只取vector前3个元素（先把遍历长度确定，再遍历vector取指定长度的元素）
int len = res.size() >= 10 ? 10 : res.size();