数据结构与算法c++常用函数 | 总结上

数据结构与算法C++

Constant

INT_MIN  -2147483648
INT_MAX  2147483647
LONG_LONG_MAX
LONG_LONG_MIN

Math

#include <cmath>

int a = pow(4,2);    //4的平方
int b = pow(4,0.5);  //4的平方根
int c = sqrt(4);     //4的平方根
int c = abs(b-c);    //整数绝对值
double d = fabs(b-c);//浮点数绝对值

最大公约数和最小公倍数

int gcd(int a, int b) //最大公约数,辗转相除
{
    while (a%b != 0) 
    {
        int tmp = a;
        a = b;
        b = tmp % a;
    }
    return b;
}
int gcd(int a,int b)//最大公约数，递归
{
    if(b==0) return a;
    else return gcd(b,a%b);
}
//两个数互质判断：最大公约数为1
int lcm(int a, int b) //最小公倍数
{
    return a * b / gcd(a, b);
}

判断素数

//判断素数1
bool is_prime(long long n){
    if(n==1) return false;
    for(long long i=2;i<=sqrt(n);i++)
        if(n%i==0) return false;
    return true;
}
//判断素数2
int main() {
    const int maxnum = 100;
    int isPrime[maxnum];
    int i, x;
    for (i = 0; i < maxnum; i++) 
        isPrime[i] = 1;//把数组所有元素初始为1
    //元素的下标代表判断的数字，值为1表示素数，值为0不是
    for (x = 2; x < maxnum; x++) {
        if (isPrime[x]) 
            for (i = 2; i * x < maxnum; i++) 
                isPrime[i * x] = 0; //从2开始，把每个数的倍数都挨个排除掉
    }
    for (i = 2; i < maxnum; i++) printf("%d\t", i);
    return 0;
}
//判断素数3
int isPrime(int x, int knownPrimes[], int count) {
    int ret = 1;
    int i;
    for (i = 0; i < count; i++) {
        if (x % knownPrimes[i] == 0) {
            ret = 0;
            break;
        }
    }
    return ret;
}
int main() {
    const int number = 100;
    int knownPrimes[number] = { 2 };
    int count = 1;//Number of known primes
    int i = 3;
    while (i<number){
        if (isPrime(i, knownPrimes, count)) 
            knownPrimes[count++] = i;
        i++;
    }
    for (i = 0; i < number; i++) 
        printf("%d ", knownPrimes[i]);
    return 0;
}

十进制转任意进制函数

void dex_to_x(int n, int r) {//n是数，r是要转化的进制
    if (n < 0){
        printf("-"); n = -n;
    }
    if (n == 0)  printf("0");
    int c = 0, a[10000];
    while (n){
        a[c] = (n % r);
        c++;
        n /= r;
    }
    for (int i = c - 1; i >= 0; i--){
        if (a[i] >= 10)
            printf("%c", a[i] - 10 + 'A') ;
        else printf("%d",a[i]);
    }
 }

int char2int(char x) {
	if (x >= '0' && x <= '9') return x - '0';
	return x - 'A' + 10;
}
char int2char(int x) {
	if (x >= 0 && x <= 9) return x + '0';
	return x - 10 + 'A';
}

同余性质

//边乘边取模的思想，而不是算完再取模
//(x + y) = ((x mod m) + (ymod m))(mod m)
(x * y) % m = ((x % m) * (y % m)) % m;
(x + y) % m = ((x % m) + (y % m)) % m;
//减法表达式略有不同，考虑到减完会有负数
(x - y) % m = ((x % m) - (y % m) + m) % m;
    
//例子：求n!(mod m)
long long fac_mod(int n, long long m){
    long long ans=1;
    for(int i=1;i<=n;i++){
        ans*=i;
        ans%=m;
    }
    return ans%m;
}

//快速幂：x^y(mod m) = (x mod m)^y mod m
	//如果y是偶数，x^y(mod m) = ((x^2)^(y/2))(mod m)
	//如果y是偶数，x^y(mod m) = ((x^2)^(y/2)*x)(mod m)
long long power_int(long long a,long long b,long long c){
    long long ans=1;
    a=a%c;
    while(b>0){
        if(b%2==1)
            ans=(ans*a)%c;
        b=b/2;
        a=(a*a)%c;
    }
    return ans%c;
}

Stack

#include <stack>

stack<type>s;     //定义
s.empty();        //如果栈空则返回true, 否则返回false
s.size();         //返回栈中元素的个数
s.top();          //返回栈顶元素, 但不删除该元素
s.pop();          //弹出栈顶元素, 但不返回其值
s.push();         //将元素压入栈顶

//判断两个栈是否相等
int stackcmp(stack<int>s1,stack<int>s2)
{
	if (s1.size() != s2.size()) return 0;
	while (!s1.empty() && !s2.empty())
	{
		if (s1.top() == s2.top())
		{
			s1.pop();
			s2.pop();
		}
		else return 0;
	}
	return 1;
}

Queue

#include <queue>

queue<type>s;      //定义
q.empty();         //如果队列为空返回true, 否则返回false     
q.size();          //返回队列中元素的个数
q.front();         //返回队首元素但不删除该元素
q.pop();           //弹出队首元素但不返回其值
q.push();          //将元素压入队列
q.back();          //返回队尾元素的值但不删除该元素

#include <queue>

//优先级队列
priority_queue<int,vector<int>,less<int> > a;    //大根堆
priority_queue<int,vector<int>,greater<int> > a; //小顶堆
priority_queue<int> a;   //默认是大根堆
priority_queue<string> a;//字符序大的排在前面
priority_queue<pair<int, int> > a;//先比较第一个元素，第一个相等比较第二个，大的排在前

//常用操作
a.push(x);
a.empty();
a.top();
a.pop();

//对于自己定义的类型的优先级队列比较方法
struct tmp1 
{
    int x;
    tmp1(int a) {x = a;}
    bool operator<(const tmp1& a) const  //方法1：运算符重载<
    {return x < a.x;} //大顶堆
};
struct tmp2 //方法2：重写仿函数
{
    bool operator() (tmp1 a, tmp1 b) 
    {return a.x < b.x;} //大顶堆
};

int main() 
{
    tmp1 a(1),b(2),c(3);
    //方法1
    priority_queue<tmp1> d;
    //方法2
    priority_queue<tmp1, vector<tmp1>, tmp2> f;
}

Deque

#include <deque>

deque<type>c;            //定义
c.push_front('a');       //在队首加入元素
c.push_back('a');        //在队尾加入元素
c.pop_front();           //删除队首元素
c.pop_back();            //删除队尾元素
c.front();               //返回队首元素
c.back();                //返回队首元素
c.insert(pos, elem);     //在pos的位置插入元素elem
c.insert(pos, n, elem);  //在pos的位置插入n个elem
c.empty();               //判断是否为空

Vector

#include <vector>

//初始化
vector<int> a(10);        //定义了10个整型元素的向量
vector<int> a(10,1);      //定义了10个整型元素的向量,且每个元素的初值为1
vector<int> a(b);         //用b向量来创建a向量，整体复制性赋值
vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素

int b[7]={1,2,3,4,5,9,8};
vector<int> a(b,b+7);     //从数组中获得初值

//重要操作
a.assign(b.begin(), b.begin()+3); //将b的0~2个元素构成的向量赋给a
a[i];           //返回a的第i个元素
a.back();       //返回a的最后一个元素
a.front();      //返回a的第一个元素
a.size();       //返回a中元素的个数；
a.clear();      //清空a中的元素
a.empty();      //判断a是否为空，空则返回ture,不空则返回false
a.pop_back();   //删除a向量的最后一个元素
a.push_back(5); //在a的最后一个向量后插入5
a.insert(a.begin()+1,5);          //在a的第1个元素（从第0个算起）的前面插入数值5
a.insert(a.begin()+1,3,5);        //在a的第1个元素（从第0个算起）的位置插入3个5
a.erase(a.begin()+1,a.begin()+3); //删除从a.begin()+1（包括）到a.begin()+3（不包括）
a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

#include <algorithm>
#include <vector>

//一些需要头文件algorithm的操作，以下a.begin()（包括它），a.end()（不包括它）
sort(a.begin(),a.end());             //对a中的元素进行从小到大排列
reverse(a.begin(),a.end());          //对a中的元素倒置，但不排列
copy(a.begin(),a.end(),b.begin()+1); //把a中的元素复制到b中，从b.begin()+1的位置（包括）开始复制，覆盖掉原有元素
find(a.begin(),a.end(),10);          //在a中的元素中查找10，若存在返回其在向量中的位置

String

#include <string>
//构造
string s1;
string s2(10,'a');
string s3(s2);//拷贝构造
const char*str="hello world";
string s4(str);
//赋值
string str,str0;
str="hello world";
str.assign("hello world");
str.assign("hello world",4);//把“hello world”前4个赋值
str.assign(s0);             //也可以直接写成s=s0;
str.assign(10,'a');
//拼接
string str='a',str0="loveyou";
str += "love you";
str.append(str0);
srt.append("love");
str1.append(5,"love");  //在后面拼接5个“love”
str.append(str0,1,3);   //从第0个位置开始，截取3个字符,包括第1个
//查找
string str="abcedfg",str2="de";
str.find(str0);         //如果找到返回起始pos=3，不存在返回string::npos(-1)
str.rfind(str2);        //从右往左查找
//其他常用操作
str.size();
str.length();
str.insert(1,"111");    //在位置1（前面）插入字符
str.erase(1,3);         //从位置1（包括1）删除3个字符
str.replace(1,3,"111"); //从第1个位置开始（包括），替换三个字符
str.compare(str0);      //0:相等 -1:str<str0  1:str>str0
str.substr(1,3);        //从位置1（包括）截取3个字符
ch=toupper(ch);
ch=tolower(ch);
//string与不同类型数据的转换
int i = atoi(s.c_str());        //sting转int
long long i = atoll(s.c_str()); //sting转long long
string s = to_string(i);        //int转string
char t[maxl];      //char*转string
strcpy(t,"abcd");
string s=t;
char t[maxl];      //string转char*
t=s.c_str();
//string输入
getline(cin,str);  //可以有空格
cin>>str;          //不读入'\n'和' '
//string迭代器
reverse(s.begin(),s.end());//反转
    

#include <string>
#include <algorithm>

//全部转换为大写/小写
transform(str.begin(), str.end(), str.begin(), ::toupper); 
transform(str.begin(), str.end(), str.begin(), ::tolower);

Set

#include <set>

//初始化
set<int>s;
set<int>s2(s);  
set<int>s2(s.begin(),s.end())
   
int myints[]= {10,20,30,40,50};
set<int>s(myints,myints+5); 

//常用操作
s.begin();            // 返回指向第一个元素的迭代器
s.end();              // 返回指向迭代器的最末尾处（即最后一个元素的下一个位置）
s.clear();            // 清除所有元素
s.count();            // 返回某个值元素的个数
s.empty();            // 如果集合为空，返回true
s.insert(x);          //向set中插入元素

Sort

#include <algorithm>
//数组排序
int a[11]={0,1,2,3,4,5,6,7,8,9,10};
sort(a,a+11);
sort(a+4,a+11);
//倒序
bool cmp(int a,int b)
{
    return a>b;
}
sort(a,a+11，cmp);
//重载cmp函数例子
bool cmp(string a,string b)
{
    return a>b;
}
bool cmp(struct Dog a,struct Dog b)
{
    if(a.age==b.age){
        return a.weight<b.weight;//体重升序
    }
    else return a.age>b.age;//年龄降序
}

Search

//二分查找，版本1
int BinarySearch1(int a[], int value, int n)
{
    int low, high, mid;
    low = 0;
    high = n-1;
    while(low<=high)
    {
        mid = (low+high)/2;
        if(a[mid]==value)
            return mid;
        if(a[mid]>value)
            high = mid-1;
        if(a[mid]<value)
            low = mid+1;
    }
    return -1;
}
 
//二分查找，递归版本
int BinarySearch2(int a[], int value, int low, int high)
{
    int mid = low+(high-low)/2;
    if(a[mid]==value)
        return mid;
    if(a[mid]>value)
        return BinarySearch2(a, value, low, mid-1);
    if(a[mid]<value)
        return BinarySearch2(a, value, mid+1, high);
}

Tree

层次遍历

//二叉树
struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode() : val(0), left(nullptr), right(nullptr) {}
     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

//N叉树
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}
    Node(int _val) {val = _val;}
    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};