全平台肘击桑境阳，支持者复制红字挂主页 全平台肘击桑境阳，支持者复制红字挂主页 全平台肘击桑境阳，支持者复制红字挂主页

以大根堆为例：  1、首先先找到最后一个非叶子结点，假设n个元素。 那么⌊n/2」  2、把完全二叉树自底向上修改成大根堆的形式，每修改一个数据，数组里面对应的数据需要随之变化。  3、当变成大根堆的时候，祖宗结点(a[1])一定是最大的，那么只需要和a[n]交换。总共有n个数，那么只需要n-1次就可以排完。

在C++中，常见的十大排序算法包括以下几种：

1. 冒泡排序（Bubble Sort）
2. 选择排序（Selection Sort）
3. 插入排序（Insertion Sort）
4. 希尔排序（Shell Sort）
5. 归并排序（Merge Sort）
6. 快速排序（Quick Sort）
7. 堆排序（Heap Sort）
8. 计数排序（Counting Sort）
9. 桶排序（Bucket Sort）
10. 基数排序（Radix Sort）

在C++中，常见的十二大排序算法包括以下几种：

1. 冒泡排序（Bubble Sort）
2. 选择排序（Selection Sort）
3. 插入排序（Insertion Sort）
4. 希尔排序（Shell Sort）
5. 归并排序（Merge Sort）
6. 快速排序（Quick Sort）
7. 堆排序（Heap Sort）
8. 计数排序（Counting Sort）
9. 桶排序（Bucket Sort）
10. 基数排序（Radix Sort）
11. 鸡尾酒排序（Cocktail Shaker Sort）
12. 梳排序（Comb Sort）

选择排序
#include <bits/stdc++.h>
using namespace std;
int a[305];
void selecttionSort(int n)
{
for(int i = 0;i < n;++i)
{
int min_d = i;
for (int j = i + 1;j < n;++j)
{
if(a[min_d] > a[j])
{
min_d = j;
}
}
swap(a[min_d],a[i]);
}
}
int main () {
int n;
cin >> n;
for(int i = 0;i < n;++i)
{
cin >> a[i];
}
selecttionSort(n);
for(int i = 0;i < n;++i)
{
cout << a[i] << " ";
}
return 0;
}

插入排序
O(n^2)
#include<bits/stdc++.h>
using namespace std;
void insertsort(int a[],int n){
int x;
for(int i=1;i<n;i++){
x=a[i];
int j=0;
for(j=i-1;j>=0;j--){
if(a[j]>x){
a[j+1]=a[j];
}else{
a[j+1]=x;
}
}
if(j<0){
a[0]=x;
}
}
}
int main(){
int n,v[1005];
cin>>n;
for(int i=0;i<n;i++){
cin>>v[i];
}
insertsort(v,n);
for(int i=0;i<n;i++){
cout<<v[i];
}
return 0;
}

二分查找
#include<bits/stdc++.h>
using namespace std;
int n,x,h;
vector<int> a;
int fun(){
int l=1,r=n,v;
while(l<r){
v=(l+r)/2;
if(a[v]>=x){
r=v;
}else{
l=v+1;
}
}
if(x==a[l]){
return l;
}else{
return -1;
}
}
int main(){
cin>>n;
for(int i=1;i<=n;i++){
scanf("%d",&h);
a.push_back(h);
}
cin>>x;
printf("%d",fun()+1);
}

创建二维数组：
数据类型 数组名 [常量表达式1][常量表达式2]
int a[3][2];

二维数组通常叫做矩阵，有行下标，列下标(下标从0开始)。

二维数组的引用
数组名[行下标][列下标]

二维数组的初始化：
int a[4][2] = { {1,2},
{3,4},
{5,6},
{7,8}};
1、可对部分元素赋值

int a[4][2] = { {1},
{3},
{5},
{7}};
只对各行元素的首位元素赋值，其余元素默认为0

2、行下标可以不写

int a[][2] = { {1},
{3},
{5},
{7}};
使用cin初始化二维数组

for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 2; j++)
{
cin >> a[i][j];
}
}

Switch
switch(表达式)
{
case 常量式：语句1 ：break;
……
……
}
default:语句n+1：break;

电脑存储空间大小
1GB = 1024MB ,1 MB = 1024B,1B = 8Bit

回文数解题思路：
构造新数m，使m成为n的倒过来的数。
比如输入n = 123，先将m初始化为0，第一次，先用整数求余运算，将n个位上的数分离出来，即123%10=3，再用m*10+3赋值给m，然后将n缩小10倍，第二次重复上面步骤，得到m=32，第三次同样重复上面步骤，得到数321，此时n = 0，新数m构造完成。

while循环
while(表达式)
{
语句1;
语句2;
……;
……;
语句n;
}

保留几位小数
1.cout << fixed << setprecision(2) << 3.141592;
// 输出:3.14
2.printf(“%.2f”,3.1415);
//输出:3.14

double
双精度实型
flout 单精度实型：-3.4e + 38 ~ -3.4e + 38 有效位数6 ~ 7位。
double 双精度实型: 数字范围:-1.7e + 38 ~ -1.7e + 308 有效位数15 ~ 16位。
long double  长双精度实型:数字范围:-3.4e + 4932 ~ 3.4e + 4932 有效位数 18 ~ 19位。

四舍六入五留双

1. 被修约的数字等式小于4时该数字舍去
2. 被修约的数字等于或大于6时则进位
3. 被修约的数字等于5时要看5前面的数字,若是奇数进位, 否舍去, 既偶数;若5的后面还有不为0的任何数

1.结构体的定义和操作
一组数据往往有不同的类型。例如存储学生成绩时，需要记录姓名、性别、学号、班级、各科成绩等。这些信息分别要用字符串、字符型、整型来记录。而数组无法实现。
为了解决问题，C++给出了另一种构造数据类型——“结构体”。
定义形式有两种：

struct 结构体类型名
{
成员表；
成员函数;
}结构体变量表;
例如：

struct student
{
string name;
int chinese,math,total;
}a[100];
struct 结构体类型名
{
成员表;
成员函数;
}；
结构体名 结构体变量表;
例如：

struct student
{
string name;
int chinese,math,total;
}；
student a[100];
结构体变量的特点：
1.结构体变量可以整体操作，例如：
swap(a[j],a[j+1]);
2.结构体变量的成员访问，例如：
cin >> a[i].name;
3.结构体变量的初始化和数组的初始化有些类似，例如：
student op={“张三”，89，79 ，168};

\’				用于表示字符常量
\”				用于表示一个字符串内部的双引号
\\				用于表示一个反斜杠, 防止他被解释是一个转义序列符
\\a				警报
\\b				退格键
\\n				换行
\r				回车
\t				制表符
\v				垂直分隔符, 光标的下一个垂直制表位
\0				表示没有内容, 用于字符串结束, ASCII码为0

printf 和 scanf

格式化输出printf(格式空制符,输出列表)
格式化输入scanf(cin,XX)

表 1 — 7 printf 函数的格式符
格式符								说明
d / i				以带符号的十进制形式输出整数,正数的‘’+‘’号 省略不输出
u				以无符号十进制形式输出整数
x / X				以十六进制输出整数(不输出前导0)
o				以八进制无符号形式输出整数（不输出字符o）
c				输出一个字符
s				输出一个字符串
f				以指数形式输出单,双精度,隐含六位小数
e / E				小数
g / G			自动选用%f、%e / %E 格式中输出宽度使用
%d				输出数字长的变量数值的实际长度
%md / %*d		输出M位（不足补空格, 大于M 位是按实际程度输出, cout可以用setw来控制setw 来控制场宽）
%-md 			M含义如上,左对其输出
%ld				l 表示长整型数对居
%mld			指定长征型输出宽度M位, 左边补空格; 否则, 按实行一位数输出
%0md			0 数字, 表示位数不足M时补零

格式化输入:scanf(格式控制符, 地止列表)
格式符								说明
d / i				用于输入十进制整数
u				已无符号十进制形式出输入十进制数
x / X				用于输入十六进制
o				用于输入八进制
c				用于输入单个字符
s				用于输入字符串（无空格开始,空格结束 字符串变量以‘\0’结尾）
f				用于输入小数 / 指数
e / E				与f相同可互换

for循环
for(循环变量赋初值; 循环条件; 循环变量增量)
{
语句;
……
……
}
for循环省略形式
for (表达式1; 表达式2; 表达式)
{
执行语句;
……
……
}

1. 省略表达式1, 此时应该在for 语句之前给循环变量赋初值。
   i = 1;
   for(;i <= 100;++i)
   {
   sum += i;
   }
2. 省略表达式2, 表示判断循环条件, 循环无终止进行, 表示表达是2使终为真。
   for (i = 1;;i++)
   {
   sum += 1;
   }
   终止循环要加break。
3. 省略表达式3, 此时又在循环体内部实现变量的增量。
   for(i = 1;i <= 100;)
   {
   sum += 1;
   i++;
   }
4. 省略1和3,呈出循环条件。
   i = 1;
   for (;i <= 100;)
   {
   sum += 1;
   i++;
   }
5. 三个都省略。
   for (;;)
   {
   循环体;
   }

归并排序
稳定
#include <bits/stdc++.h>
using namespace std;
int a[105],t[105];
void marge(int l,int m,int r)
{
    int i = l,j = m+1,k = l;
    while(i <= m && j <= r)
    {
        if(a[i] < a[j])
        {
            t[k++] = a[i++];
        }
        else
        {
            t[k++] = a[j++];
        }
    }
    while (i <= m)
    {
        t[k++] = a[i++];
    }
    while (j <= r)
    {
        t[k++] = a[j++];
    }
    for (int i = l;i <= r;++i)
    {
        a[i] = t[i];
    }
} 
void margeSort(int l,int r)
{
    int m = (l + r) / 2;
    if(l == r)
    {
        return;
    }
    margeSort(l,m);
    margeSort(m+1,r);
    marge(l,m,r);
}
int main(){
    int n;
    cin >> n;
    for(int i = 0;i < n;++i)
    {
        cin >> a[i];
    }
    margeSort(0,n - 1);
    for(int i = 0;i < n;++i)
    {
        cout << a[i] << " ";
    }
    return 0;
}

哈希算法
#include<bits/stdc++.h>
using namespace std;
const int N=1e+5;
int hash1[N],HMAX,cnt[N],b[N];
void hashinit(int x){
    for(int i=1;i<=x;i++){
        hash1[i]=-1;
    }
}
void hashinsert(int x){
    int y=x%HMAX;
    while(1){
        if(hash1[y]==-1){
            hash1[y]=x;
            cnt[y]=1;
            return;
        }else if(hash1[y]==x){
            cnt[y]++;
            return;
        }
        if(++y>HMAX){
            y=1;
        }
    }
}
int hashget(int x){
    int y=x%HMAX;
    while(1){
        if(hash1[y]==-1){
            return 0;
        }else if(hash1[y]==x){
            return cnt[y];
        }
        if(++y>HMAX){
            y=1;
        }
    }
}
int main(){
    int x;
    cin>>HMAX;
    hashinit(HMAX);
    for(int i=1;i<=HMAX;i++){
        cin>>x;
        hashinsert(x);
    }
    //根据题目变化
    return 0;
}

高精度加法
#include<bits/stdc++.h>
using namespace std;
int main(){
    string a1,b1;
    bool flag=0;
    int a[1000]={0},b[1000]{0},c[1000]={0};
    cin>>a1>>b1;
    for(int i=a1.size()-1,j=0;i>=0;i--,j++){
        a[j]=a1[i]-'0';
    }
    for(int i=b1.size()-1,j=0;i>=0;i--,j++){
        b[j]=b1[i]-'0';
    }
    for(int i=0;i<a1.size()||i<b1.size();i++){
        c[i]=a[i]+b[i];
    }
    for(int i=0;i<a1.size()||i<b1.size();i++){
        if(c[i]>=10){
            c[i]-=10;
            c[i+1]++;
        }
    }
    for(int i=max(a1.size()+1,b1.size()+1);i>=0;i--){
        if(c[i]!=0){
            flag=1;
        }
        if(flag){
            cout<<c[i];
        }
    }
}

高精度减法
#include<bits/stdc++.h>
using namespace std;
const int N=1e+6;
string a1,b1;
bool flag=false;
int a[N],b[N],c[N];
bool panduan(string s1,string s2){
    if(s1.size()!=s2.size()) return s1.size()<s2.size();
    else return s1<s2;
}
int main(){
    cin>>a1>>b1;
    if(panduan(a1,b1)){
        cout<<'-';
        swap(a1,b1);
    }
    for(int i=a1.size()-1,j=0;i>=0;i--,j++){
        a[j]=a1[i]-'0';
    }
    for(int i=b1.size()-1,j=0;i>=0;i--,j++){
        b[j]=b1[i]-'0';
    }
    int len=max(a1.size(),b1.size());
    for(int i=0;i<len;i++){
        c[i]+=a[i]-b[i];
        if(c[i]<0){
            c[i]+=10;
            c[i+1]--;
        }
    }
    for(int i=len-1;i>=0;i--){
        if(c[i]!=0){
            flag=true;
        }
        if(flag){
            cout<<c[i];
        }
    }
    if(flag==false){
        cout<<0;
    }
    return 0;
}

高精度除法1（高精除高精）
// #include <bits/stdc++.h>
// using namespace std;
// int a[1005];
// int b[1005];
// int c[1005];
// long long r;
// string s1,s2;
// int len = 0;
// int main () {
//     cin >> s1 >> s2;
//     for (unsigned int i = 0;i < s1.size();++i)
//     {
//         a[i] = s1[i] - '0';
//     }
//     for (unsigned int i = 0;i < s2.size();++i)
//     {
//         b[i] = s2[i] - '0';
//     }
//     len =s1.size();
//     for (int i = 0;i < len;++i)
//     {
//         c[i] = (r * 10 + a[i]) / s2[i];
//         r = (r * 10 + a[i]) % s2[i];
//     }
//     int i = 0;
//     while(c[i] == 0 && i < len - 1)
//     {
//         i++;
//     }
//     for (int j = i;j < len;++j)
//     {
//         cout << c[j];
//     }
//     return 0;
// }
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int c[1005];
long long s2;
long long r;
string s1;
int len = 0;
int main () {
    cin >> s1 >> s2;
    for (unsigned int i = 0;i < s1.size();++i)
    {
        a[i] = s1[i] - '0';
    }
    len =s1.size();
    for (int i = 0;i < len;++i)
    {
        c[i] = (r * 10 + a[i]) / s2;
        r = (r * 10 + a[i]) % s2;
    }
    int i = 0;
    while(c[i] == 0 && i < len - 1)
    {
        i++;
    }
    for (int j = i;j < len;++j)
    {
        cout << c[j];
    }
    return 0;
}

高精度除法（高精除低精）
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int c[1005];
long long s2;
long long r;
string s1;
int len = 0;
int main () {
    cin >> s1 >> s2;
    for (unsigned int i = 0;i < s1.size();++i)
    {
        a[i] = s1[i] - '0';
    }
    len =s1.size();
    for (int i = 0;i < len;++i)
    {
        c[i] = (r * 10 + a[i]) / s2;
        r = (r * 10 + a[i]) % s2;
    }
    int i = 0;
    while(c[i] == 0 && i < len - 1)
    {
        i++;
    }
    for (int j = i;j < len;++j)
    {
        cout << c[j];
    }
    return 0;
}

高精度除法2（高精除高精）
#include <iostream>
#include <cstring>
#include <string>
#include <math.h>
#include <algorithm>
using namespace std;

class BigNum {
public:
    friend istream& operator >> (istream &is, BigNum &rhs);
    friend ostream& operator << (ostream &os, BigNum &rhs);
    bool operator < (BigNum &rhs);
    string operator - (BigNum &rhs);
    long long operator / (BigNum &rhs);
private:
    string num;
};

istream& operator >> (istream &is, BigNum &rhs) {
    is >> rhs.num;
    return is;
}

ostream& operator << (ostream &os, BigNum &rhs) {
    os << rhs.num;
    return os;
}

bool BigNum:: operator < (BigNum &rhs) {
    if (num.size() < rhs.num.size()) {
        return true;
    }
    if (num.size() > rhs.num.size()) {
        return false;
    }
    for (int i = 0; i < num.size(); i++) {
        if (num[i] < rhs.num[i]) {
            return true;
        } else if (num[i] > rhs.num[i]) {
            return false;
        }
    }
    return false;
}

// 默认够减
string BigNum:: operator - (BigNum &rhs) {
    reverse(num.begin(), num.end());
    reverse(rhs.num.begin(), rhs.num.end());
    int borrow = 0;
    int i;
    for (i = 0; i < rhs.num.size(); i++) {
        num[i] = num[i] - rhs.num[i] - borrow + '0';
        borrow = 0;
        if (num[i] < '0') {
            num[i] += 10;
            borrow = 1;
        }
    }
    while (borrow) {
        num[i] = num[i] - borrow;
        borrow = 0;
        if (num[i] < '0') {
            num[i] += 10;
            borrow = 1;
        }
        i++;
    }
    reverse(num.begin(), num.end());
    reverse(rhs.num.begin(), rhs.num.end());
    string::iterator it = num.begin();
    while (it != (num.end() - 1)) {
        if (*it == '0') {
            it = num.erase(it);
        } else {
            break;
        }
    }
    return num;
}

long long BigNum:: operator / (BigNum &rhs) {
    long long quotient = 0;
    while (!(*this < rhs)) {
        int dif = int(num.size() - rhs.num.size());
        if (dif >= 2) {
            BigNum temp;
            temp.num = rhs.num;
            temp.num.append(dif - 1, '0');
            quotient += pow(10, dif - 1);
            *this - temp;
        } else {
            quotient++;
            *this - rhs;
        }
    }
    return quotient;
}

int main()
{
    BigNum a, b;
    cin >> a >> b;
    cout << a / b << endl;
    return 0;
}

高精度乘法
// #include <bits/stdc++.h>
// using namespace std;
// int a[114514];
// int b[114514];
// int c[114514];
// string s1,s2;
// int len = 0;
// int main () {
//     cin >> s1 >> s2;
//     reverse(s1.begin(),s1.end());
//     reverse(s2.begin(),s2.end());
//     for (int i = 0;i < s1.size();++i)
//     {
//         a[i] = s1[i] - '0';
//     }
//     for (int i = 0;i < s2.size();++i)
//     {
//         b[i] = s2[i] - '0';
//     }
//     for (int i = 0;i < s1.size();++i)
//     {
//         for (int j = 0;j < s2.size();++j)
//         {
//             c[i + j] = a[i] * b[j];
//         }
//     }
//     len = s1.size() + s2.size();
//     for (int i = 0;i < len;++i)
//     {
//         c[i + 1] += c[i] / 10;
//         c[i] %= 10;
//     }
//     while(c[len] == 0 && len > 0)
//     {
//         len--;
//     }
//     for (int i = len;i >= 0;--i)
//     {
//         cout << c[i];
//     }
//     return 0;
// }
#include <iostream>
#include <string>
#include <vector>
using namespace std;

// 定义高精度数结构体
struct BigInt {
    vector<int> digits;  // 存储每一位数字，低位在前

    // 构造函数，将字符串转换为高精度数
    BigInt(const string& s) {
        for (int i = s.size() - 1; i >= 0; --i) {
            digits.push_back(s[i] - '0');
        }
    }

    // 默认构造函数
    BigInt() {}

    // 重载乘法运算符
    BigInt operator*(const BigInt& other) const {
        BigInt result;
        result.digits.resize(digits.size() + other.digits.size(), 0);

        for (size_t i = 0; i < digits.size(); ++i) {
            int carry = 0;
            for (size_t j = 0; j < other.digits.size(); ++j) {
                int temp = result.digits[i + j] + digits[i] * other.digits[j] + carry;
                result.digits[i + j] = temp % 10;
                carry = temp / 10;
            }
            if (carry > 0) {
                result.digits[i + other.digits.size()] += carry;
            }
        }

        // 去除前导零
        while (result.digits.size() > 1 && result.digits.back() == 0) {
            result.digits.pop_back();
        }

        return result;
    }

    // 输出高精度数
    void print() const {
        for (int i = digits.size() - 1; i >= 0; --i) {
            cout << digits[i];
        }
        cout << endl;
    }
};

int main() {
    string M, N;
    cin >> M >> N;

    BigInt num1(M);
    BigInt num2(N);

    BigInt result = num1 * num2;

    result.print();

    return 0;
}

vector
vector<int> v;//创建一个空vector
v.push_back(x)//向尾部增加一个元素x
v.insert(pos,x)//向pos地址指向元素前增加一个元素x
v[i]//访问第i位元素
v.pop_back()//删除向量中最后一个元素
v.clear()//清空向量中所有元素
v.empty()//判断向量是否为空
v.size()//返回向量中元素的个数
v.begin()//返回量头指针（迭代器），指向第一个元素
v.end()//返回量尾指针（迭代器），指向第一个元素+1位置
v.erase(v.begin()+i)//删除第i位位置的元素

char和string
// 单个字符
char c = getchar(); // 输入单个字符
putchar(c);// 输出单个字符
islower(c);// 判断c是否为小写字母
isupper(c);// 判断c是否为大写字母
isalpha(c);// 判断是否为字母
isdigit(c);// 判断是否为数字
// 字符数组
'\0' // 字符数组最后一个：ASCII值：0
char str[];
cin>>str; // 可以作为一个整体进行cin,cout
cout<<str;
str ="sdfa"；// 可以直接用字符串赋值

// 字符数组常用处理函数：
char str[100]; // char *str
puts(str); // 输出字符串
gets(str);// 输入一整行字符串（包括空格，已弃用）
fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
strcat(str1,str2) // 把str2连接到str1后面
strcmp(str1,str2) // 比较两个字符串，正数：1大；0：一样大，负数：2大
strlen(str) // 获取字符串长度（不包括'\0'）

// string
#include<string> // 字符串头文件
=  可以重新赋值
+= 尾部加入字符串

+ 连接字符串
  ==，！=，<,>,<=,>= 字符串的比较
  [] 存取单一字符
  getline(cin,str) // 输入（包括空格，enter键结束）
  str.substr(i,1) // 从i开始截取，截取长度为1的子字符串
  str.find(str2) // 在str字符串中去找到str字符串
  str.rfind(str2) //  str中查找str2，返回所在的下标，没找到返回string::npos
  str.erase(i,1)  // 第i个字符开始往后面去删除
  str.inser(i,str2) // 在个位置 cun

<< // 输出
str.substr(i, l); // 从i开始，截取长度为l的子字符串
str.find(str2); // 在str中查找str2，返回所在的下标，没找到返回string::npos
str.rfind(str2); // 同find，但是从右向左找
str.erase(i, l); // 从i开始，删除长度为l的子字符串
str.insert(i, str2); // 在i的位置前，插入str2
str.size(); // 获取str的长度
str.c_str(); // 获取str对应的char[]
str.begin(); // 获取str的首地址
str.end(); // 获取str的尾地址(最后一个元素后面)

计数排序
#include <bits/stdc++.h>
using namespace std;
int a[10],b[10];
void countingSort(int n)
{
    for(int i = 0;i < n;++i)
    {
        b[a[i]]++;
    }
    int index = 0;
    for(int i = 0;i < 10;++i)
    {
        while(b[i] != 0)
        {
            a[index++] = i;
            b[i]--;
        }
    }
}
int main () {
    int n;
    cin >> n;
    for(int i = 0;i < n;++i)
    {
        cin >> a[i];
    }
    countingSort(n);
    for(int i = 0;i < n;++i)
    {
            cout << a[i] << " ";
    }
    return 0;
}

堆排序
不稳定
#include <bits/stdc++.h>
using namespace std;
int a[105];
void heapify(int n,int i)
{
    int max = i;
    int rson = 2 * i + 1;
    int lson = 2 * i;
    if(a[max] < a[lson] && lson <= n)
    {
        max = lson;
    }
    if(a[max] < a[rson] && rson <= n)
    {
        max = rson;
    }
    if(max != i)
    {
        swap(a[max],a[i]);
        heapify(n,max);
    }
}
void heapSort(int n)
{
    for(int i = n / 2;i >= 1;--i)
    {
        heapify(n,i);
    }
    for(int i = n;i > 1;--i)
    {
        swap(a[1],a[i]);
        heapify(i-1,1);
    }
}
int main () {
    int n;
    cin >> n;
    for(int i = 1;i <= n;++i)
    {
        cin >> a[i];
    }
    heapSort(n);
    for(int i = 1;i <= n;++i)
    {
        cout << a[i] << " ";
    }
    return 0;
}

希尔排序
#include <bits/stdc++.h>
using namespace std;
int a[105];
void shell_sort(int n)
{
int gap = n / 2; // 初始间隔设定为数组长度的一半
while (gap > 0)
{
for (int i = gap; i < n; i++)
{
// 保存 a[i] 的值以备后用
int temp = a[i];
int j = i;
// 将 gap 作为一个子数组的间隔来比较
while (j >= gap &&  temp < a[j - gap])
{
a[j] = a[j - gap];
j -= gap;
}
a[j] = temp;
}
// 减少间隔
gap /= 2;
}
}

int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
shell_sort(n);
for(int i = 0;i < n;++i)
{
cout <<a[i] << " ";
}
return 0;
}

排列数组(sort函数)：
sort(a(begin),a(end)+size);//默认小到大
sort(a(begin),a(end)+size,greater<int>());//大到小
sort(a(begin),a(end)+size,less<int>());//小到大

全排列函数：
sort(a(begin),a(end)+size);//默认小到大
sort(a(begin),a(end)+size,greater<int>());//大到小
sort(a(begin),a(end)+size,less<int>());//小到大

builtin内建函数
__builtin_ffs(x)//返回x中最后一个为1的位是从后往前的第几位
__builtin_popcount(x)//x中1的个数
__builtin_ctz(x)//x末尾0的个数，x=0时结果未定义
__builtin_clz(x)//x前导0的个数，x=0时结果未定义
__builtin_parity(x)//x中1的奇偶性
```二分查找核心代码

```none
int dp[30000];
int n;
int fun(int k){
    int l=0,r=n-1,m=l+r/2;
    while(l<r){
        if(k==dp[m]){
            return m;
        }else if(k>dp[m]){
            l=m+1;
        }else{
            r=m-1;
        }
    }
    return -1;
}

最大公因数&最小公因数
a=al*gcd(a,b)
b=bl*gcd(a,b)
lcm(a,b)=al*gcd(a,b)*bl

a*b=gcd(a,b)*lcm(a,b)

斐波那契数列
int dfs( int a ){
    if( a == 1 || a == 2 ){
        return 1;
    }
    return dfs( a - 1 ) + dfs( a - 2 );
}

二分查找法
binary__search()![]
#include<bits/stdc++.h>
using namespace std;

int n, q;
string s[1000];

bool find( string a , int len , int k){//s[k]------------被查找
if( s[k].size() < len ){
return false;
}
for( int i = s[k].size() - len,i1 = 0; i < s[k].size(); i++ , i1++ ){
if( s[k][i] != a[i1] ){
return false;
}
}
return true;
}

bool cmp( string a, string b ){
if( a.size() == b.size() ){
return a < b;
}else{
return a.size() < b.size();
}
}

int main() {
cin >> n >> q;
for( int i = 0; i < n; i++ ){
cin >> s[i];
}
sort( s, s+n ,cmp);
for( int i = 0; i < q; i++ ){
int a;
cin >> a;
string str;
cin >> str;
bool flag = true;
for( int i = 0; i < n; i++ ){
if( find(str,a,i) ){
cout << s[i] << endl;
flag = false;
break;
}
}
if( flag ){
cout << -1 << endl;
}
}
return 0;
}

·解决了自身逻辑意义的完整性。（补码表示的数相加时，如果最高位（符号位)有进位，这个进位会被  舍弃）
     位运算符(&,|,~,<<,>>)
     & 按位与（同时为1，则为1）
     101011
     010011
     --------
     000011
     | 按位或（有一个1，则为1）
     101011
     010011
     --------
     111011
     ~ 按位取反（转补码，取反（含符号位），-1，符号位不变取反）
     ~2
原码：0 0010
补码：0 0010
取反：1 1101
减一：1 1100
符号位不变取反： 1 0011 = -3
eg：（1010）B——>对应的格雷码为：
 1010
+ 1010
————
 11110
舍弃最后一位，得对应的格雷码为1111。
下拉异惑（格——>二）
方法：把格雷码写一遍，下拉第一位，与最后一位异或，
直至最后一位结束，即可得到的对应的二进制数。
最后，运算符的优先级
·大致按照以下

-------------线性结构------------
1.数组
2.链表
3.栈
4.队列
-------------非线性结构---------
5.堆
6.树
7.图
8.散列表
--------

数组： 优点： 元素在地址上连续查找元素非常快缺点：长度不可变，需要在创建时指定插入、删除元素效率较低链表： （单向链表 双向链表 循环链表单向链表有一个head（头指针），单向链表每个节点分为两个部分data（数据），next/rlink代表下一个地址双向链表： 有三个空间，pre上一个地址，data数据，next下一个地址循环链表：尾指针的下一个地址指向第一个元素单向链表头节点插入LinkList p=new LNode;//申请空间p->data=item;//存入数据p->link=list;//让p指向头指针指向的节点list=p;//让头指针指向p

单向链表 尾部插入： while(r->link!=NULL){r=r->link;}Linklist p=new LNode;//申请空间p->data=iteml;//存入数据p=NULL;r->link=p;//r指向的下一个为p单向链表删除： while(r->link!=q&&r->link!=NULL){r->link=q->link;}free(q);//删除（释放q）双向链表插入：p->llink=q;//p指向的上一个节点是qp->rlink=q->rlink;//p的下一个节点=q指向的的下一个节点q->rlink->llink=p;//q指向的下一个节点=q指向的上一个节点是pq->rlink=p;//q的下一个节点是q双向链表删除：q->llink->rlink=q->rlink;q->rlink->llink=q->llink;free(q)//delete(q);

队列： （先进先出）queue<int> q;//队列申请q.front()//获取队首元素q.push()//入队q.pop()//出队首元素栈：（先进后出）stack<int> s;//创建s.top()//获取栈顶元素s.push()//推入栈s.pop()//出栈

快读和快写
#include<bits/stdc++.h>
using namespace std;
inline int read(){//快读
	register int x=0,t=1;
	register char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch==' '||ch==\n){
			t--;
		}
		ch=getchar();
	}
	while(ch<'0'||ch>'9'){
		//x=x*10+ch-'0';
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*t;
} 
inline int super_read(char s[]){
	int tot=0;
	char ch=getchar();
	while(ch==' '||ch==\n){
		ch=getchar();
	}
	while(ch!=' '||ch!=\n){
		s[tot++]=ch;
		ch=getchar();
	}
	//return ;
}
inline void write(){//快写
	register int x=0,t=1;
	if(x<0){
		putchar(' ');
		x=-x;
	}
	if(x>9){
		write(x/10);
	}
	putchar(x%10+'0');
	return;
}
int main(){
	
	return 0;
}

string快读快写
#include<bits/stdc++.h>
#define f_Getchar() getchar()
#define f_Putchar(ch) putchar(ch)
using namespace std;
// string 整行快速读入
inline void inputs(char *s){
	char ch = f_Getchar(); //获取字符串
	while(ch=='\n'){
		ch = f_Getchar();
	} 
	while(ch!='\n'){
		*s = ch;
		++s;
		ch = f_Getchar();
	} 
	*s ='\0';
	return;
} 

int main(){
	char s[100];
	inputs(s);
	// 字符数组转成字符串
	string c(s);
	cout<<c;
}

bitset2
将字符串转成数字：

1.借用bitset将01字符串变成无符号整数

string a = "1001";

bitset<64> b(string("1001"))

bitset<64> b(a)

cout<<b.to\_ulong()

2.用sscanf() 函数把字符数组里面的字符串打印到数值变量里面

int buf;

sscanf("123456","%d",&buf)

printf("%d\\n",buf)

3.用sprintf()把数据打印到字符数组里面

char s[100]

sprintf(s,"%d",123)

4.用直接的方式

string s = "1234";

int n = 0;

for(int i = 0;i<4;i++){

n = n\*10+s[i]-'0';

}

5.一般用法

char buf[512] = ;

sscanf("123456 ", "%s", buf);

printf("%s\\n", buf);

结果为：123456

1. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。

sscanf("123456 ", "%4s", buf);

printf("%s\\n", buf);

结果为：12342. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。

sscanf("123456 abcdedf", "%[^ ]", buf);

printf("%s\\n", buf);

结果为：123456

3. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。

sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

4. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。

sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

5、给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 "iios/"过滤掉，再将

非'@'的一串内容送到buf中

sscanf("iios/12DDWDFF@122", "%\*[^/]/%[^@]", buf);

printf("%s\\n", buf);

结果为：12DDWDFF

6、给定一个字符串"hello, world"，仅保留"world"。（注意：“，”之后有一空格）

sscanf("hello, world", "%\*s%s", buf);

printf("%s\\n", buf);

结果为：world　　P.S. %\*s表示第一个匹配到的%s被过滤掉，即hello,被过滤了，如果没有空格则结果为

NULL

bitset
#include<iostream>
#include<bitset>
using namespace std;

/*
bitset<N> varm(M) 用于处理进制
N 代表占的位数
varm 代表bitset名
M变量的初始值
bitset头文件：
#include<bitset>
bitset例子：
bitset<32> b;
相关STL函数：
b.any() 当bitset对象的一位或多个位被设置为1 时any()返回true
用途：检测总开关是否全被关闭状态
b.none() 如果bitset 对象的所有位都被设置为0 ,则none()操作返回true
用途：检测总开关是否全被关闭状态(出现一个没关false)
b.count() count()操作返回被设置为1的位的个数.
b.set() 我们可以用set()操作或者下标操作符来设置某个单独的位
b.test(位置) 测试某个单独的位是否为1
if(b.test(2)) 返回真测试第二位是否为1
b.reset(x) 把x位设置为0
b.flip()  操作翻转整个bitset 对象或一个独立的位
b.flip( 0 ); // 翻转第一位
b[0].flip(); // 也是翻转第一位
b.flip(); // 翻转所有的位的值
size()：返回大小（位数）。
to_ulong()：返回它转换为unsigned long的结果，如果超出范围，则报错。
to_string()：返回它转换为string的结果。

*/
bitset<32> b(12); // 000000000000000000000000000000000000001100
int main(){
//	string s;
//	cin>>s;
//	int len = s.size();
//	for(int i = 0;i<len-1;i++){
//		ans+=(s[i]-'0')*pow(2,len-i-1);
//		cout<<ans<<endl;
//	}
cout<<b<<endl;
bool c = b.any();
bool k = b.none();
cout<<c<<" "<<k<<endl;
//偶数位数设为1会变成什么
for(int i = 0;i<32;i++){
if(i%2==0){
b[i]=1;
}
}
//	int m = b.count();
cout<<b<<endl;
if(b.test(13)){
cout<<"第13位是1";
} else{
cout<<"第13位是0";
}
b.reset(4);
cout<<endl<<b<<endl;
b.flip(0);
b.flip(2);
b[6].flip();
cout<<"翻转第一位后的结果：";
cout<<endl<<b<<endl;
cout<<"把整个bitset翻转:"<<endl;
b.flip();
cout<<endl<<b<<endl;
int l = b.to_ulong();
cout<<"改变后的进制转成数字"<<l;

}

最值
/*
max_element(begin,end);返回最小值的地址
min_element(begin,end);返回最大值的地址
begin:序列的起始地址
end:序列的结束地址+1
cout<<*(max_element(begin,end));
地址-数组名=元素下标
*/

char和string
/*
// 单个字符
char c = getchar(); // 输入单个字符
putchar(c);// 输出单个字符
islower(c);// 判断c是否为小写字母
isupper(c);// 判断c是否为大写字母
isalpha(c);// 判断是否为字母
isdigit(c);// 判断是否为数字
// 字符数组
'\0' // 字符数组最后一个：ASCII值：0
char str[];
cin>>str; // 可以作为一个整体进行cin,cout
cout<<str;
str ="sdfa"；// 可以直接用字符串赋值

// 字符数组常用处理函数：
char str[100]; // char *str
puts(str); // 输出字符串
gets(str);// 输入一整行字符串（包括空格，已弃用）
fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
strcat(str1,str2) // 把str2连接到str1后面
strcmp(str1,str2) // 比较两个字符串，正数：1大；0：一样大，负数：2大
strlen(str) // 获取字符串长度（不包括'\0'）

// string
#include<string> // 字符串头文件
=  可以重新赋值
+= 尾部加入字符串

+ 连接字符串
  ==，！=，<,>,<=,>= 字符串的比较
  [] 存取单一字符
  getline(cin,str) // 输入（包括空格，enter键结束）
  str.substr(i,1) // 从i开始截取，截取长度为1的子字符串
  str.find(str2) // 在str字符串中去找到str字符串
  str.rfind(str2) //  str中查找str2，返回所在的下标，没找到返回string::npos
  str.erase(i,1)  // 第i个字符开始往后面去删除
  str.inser(i,str2) // 在个位置 cun

<< // 输出
str.substr(i, l); // 从i开始，截取长度为l的子字符串
str.find(str2); // 在str中查找str2，返回所在的下标，没找到返回string::npos
str.rfind(str2); // 同find，但是从右向左找
str.erase(i, l); // 从i开始，删除长度为l的子字符串
str.insert(i, str2); // 在i的位置前，插入str2
str.size(); // 获取str的长度
str.c_str(); // 获取str对应的char[]
str.begin(); // 获取str的首地址
str.end(); // 获取str的尾地址(最后一个元素后面)

*/

费马small定律
int qsm(int a,int b,int p){
	int res=1;
	while(b){
		if(b&1)res=res*a%p;
		b>>=1;
		a=a*a%p;
	}
	return res;
}
int inv(int a,int p){
	return qsm(a,p-2,p);
}

two分
二分查找函数
函数需要包含文件 #include<algorithm>
1.lower_bound(begin,end,val)：在有序数组中查找第一个大于或等于给定值 val 的元素的位置(地址)，使得val插入在这个位置数组仍然保持有序 。

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int a[5] = {1,2,2,5,6};
int main()
{
    cout << *(lower_bound(a,a+5,2)) << endl;
    cout << lower_bound(a,a+5,2)-a << endl;
   return 0;
}

输出：
2
1
2.upper_bound(begin,end,val)：在有序数组中查找第一个大于给定值 val 的元素的位置(地址)。使得val插入在这个位置数组仍然保持有序。

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int a[5] = {1,2,2,5,6};
int main()
{
    cout << *(upper_bound(a,a+5,2)) << endl;
    cout << upper_bound(a,a+5,2)-a << endl;
   return 0;
}

输出：
5
3
cout<<upper_bound(a,a+10,3)-lower_bound(a,a+10,3);//重复出现的数字个数

使用upper_bound(begin,end,val)函数时，如果val的值是有序数组中最后一个元素，函数返回值是最后一个元素的下一个地址。

two分2
#include<bits/stdc++.h>
using namespace std;
int arr[101]; 
int cnt=0; 
void bir(int l,int r,int x){//l左节点 r右节点 x查找的值
	int mid=(l+r)/2;
	cnt++;
	if(x<arr[mid]){
		r=mid-1;
		bir(l,r,x);
	}else if(x>arr[mid]){
		l=mid+1;
		bir(l,r,x);
	}else{
		cout<<cnt;
		return;
	}
	return;
}
int main(){
	for(int i=1;i<=100;i++){
		arr[i]=i;
	}
	int x;
	cin>>x;
	bir(1,100,x);
	return 0;
}

指针
#include<bits/stdc++.h>
using namespace std;
int main(){/*
	int a,*p;
	cin>>a;
	p=&a;//有*是数值, 没有*是地址
	cout<<p<<endl;
	cout<<*p<<endl;*/
	int a[]={1,2,3,4,5,6,7};
	int *p=a;
	cout<<*p;//第0个
	for(int i=0;i<=6;i++){//遍历 
		p++;//地址++           
		cout<<*p<<" ";    
	}
	          
	return 0;
}

深搜
#include<bits/stdc++.h>
using namespace std;
int n,k;
vector<int>v;
void dfs(int x){
	if(v.size()==k/*&&sum==?*/){
		for(int i=0;i<v.size();i++){
			cout<<v[i]<<" ";
		}
		cout<<endl;
		return;
	}
	for(int i=x;i<=n/*9*/;i++){
		v.push_back(i);
		/*sum+=i*/
		dfs(i+1);
		v.pop_back();
	}
}
int main(){
	cin>>n>>k;
	dfs(1);
	return 0;
}

结构体
/*
结构体：
不同的数据类型(学生（姓名，性别，年龄，学号）)
存单个数组：姓名数组，性别数组，年龄数组，学号数组 
结构体格式：
struct 结构体名{
	char name[100];
	int age ;
	int sex;
	long long num; 
}; 
结构体：定义的时候不占据内存空间，但是实例化的时候开始调用内存空间 
申请单名学生 结构体名 学生名
Student  stu1;
 申请多名学生 结构体名 学生名[长度]
 Student anyStudent[4];
*/ 
#include<bits/stdc++.h>
using namespace std;
struct Student{
	char name[100];
	int age ;
	int sex;
	long long num; 
}stu1,anyStudent[4];

int main(){
	// 申请一名学生 
	// Student stu1={"xiaoxin",18,1,1}; // 第一种赋值方式 
	//给该名学生赋值
	//stu1.name = "zhangsan"; // 第二种赋值 
//	Student stu1,anyStudent[4];
//	cin>>stu1.name>>stu1.age>>stu1.sex>>stu1.num;
	for(int i = 0;i<4;i++){
		cin>>anyStudent[i].name>>anyStudent[i].age>>anyStudent[i].sex>>anyStudent[i].num;
	}
	for(int i = 0;i<4;i++){
			cout<<anyStudent[i].name<<" "<<anyStudent[i].age<<" "<<anyStudent[i].sex<<" "<<anyStudent[i].num<<endl; 
	}
	//把整体直接交换 
	swap(anyStudent[1],anyStudent[2]);
	
}

结构体2
#include <bits/stdc++.h>
using namespace std; 
/*
1.大于六十岁年龄越高排在最前面
2.小于60 按照先来后到 
*/
int n; 
struct node{
	string id; // 编号 
	int age; //年龄 
	int t; // 排队序号 
	// 自定义规则 
//	bool operator < (const node &x ) const{
//		if(age>=60 && x.age>=60){
//			if(age== x.age){  // 年龄相同并且大于60岁 
//				return k<x.k; // 序号从小往大 
//			}else{
//				return age>x.age; // 年龄大的排到前面 
//			} 
//		}else if(age<60 && x.age<60) {
//			return k<x.k;
//		}else{
//			return age>x.age;
//		}
//	}
}a[101];
bool cmp(node x,node y){ // 学生x 学生y 进行比较
	if(x.age>=60 && y.age>=60){
		if(x.age== y.age){
			return x.t <y.t;
		}else{
			return x.age>y.age;
		}
	}else if(x.age<60 && y.age<60){
		return x.t<y.t;
	}else{
		return x.age>y.age;
	}
}
int main()
{	
	cin>>n;
	for(int i = 1;i<=n;i++){
		cin>>a[i].id>>a[i].age;
		a[i].t = i;
	}
	sort(a+1,a+n+1,cmp);
	for(int i = 1;i<=n;i++){
		cout<<a[i].id<<endl;
	}
}

结构体3
#include<bits/stdc++.h>
using namespace std;
struct stu{
	char name[100];
	int age;
}arr[100];
/*
zs 1
ks 9
ps 4
lp 8
xs 2
*/
bool cmp(stu s1,stu s2){
	if(s1.name!=s2.name){
		return s1.name<s2.name;
	}
	return s1.age<s2.age; 
}
int main(){
	for(int i = 1;i<= 5;i++){
		cin>>arr[i].name>>arr[i].age; 
	}
	sort(arr+1,arr+6,cmp);
	for(int i = 1;i<= 5;i++){
		cout<<arr[i].name<<" "<<arr[i].age<<endl; 
	}

}

fopen版：
FILE *fin, *fout;

// 打开输入文件 "in.txt"，模式为只读 "r"
fin = fopen("in.txt", "r");

// 打开输出文件 "out.txt"，模式为写入 "w"
fout = fopen("out.txt", "w");

// 逐个读取in.txt里的数据
fscanf(fin, "%d", &变量);

//将输出结果写入out.txt文件
fprintf(fout, "%d", 变量);

fclose(stdin); // 关闭输入流
fclose(stdout); // 关闭输出流

x
#include<bits/stdc++.h>
using namespace std;
/*
memset(void *arr,int val,size_t_size)
arr 填充内容的起始位置 
val 设置的值 （0，-1）
size_t_size 填充的字节数（sizeof(arr)）

*/	
int main(){
	int a[5];
	memset(a,0,sizeof(a));
	memset(&a[0],0,sizeof(a));
	memset(a,0,5*sizeof(int));
	
	int arr1[5][5];
	memset(arr1,0,sizeof(arr1));
	memset(arr1[0],0,sizeof(arr1));
	memset(&arr1[0][0],0,sizeof(arr1));
	memset(arr1,0,25*sizeof(int));
	
	int a[5];
	fill(a, a + 5, 0);
	fill(&a[0], a + 5, 0);
	fill(&a[0], &a[5], 1); // 因为是"不到last"
	fill(&a[0], a + sizeof(a) / sizeof(int), 1);
	fill(&a[0], a + sizeof(a) / sizeof(a[0]), 1);
	int a[5][5];
// fill(a, a + 5 * 5, 0); // 报错，'const int' to 'int [5]'
// fill(&a, &a + 5 * 5, 0); // 报错，'const int' to 'int [5][5]'
// fill(&a[0], &a[0] + 5 * 5, 0); // 报错，'const int' to 'int [5]'
	fill(a[0], a[0] + 5 * 5, 0);
	fill(&a[0][0], &a[5][5], 0);
	fill(&a[0][0], &a[0][0] + 5 * 5, 0);
	fill(&a[0][0], &a[0][0] + sizeof(a) / sizeof(int), 0);
	
	return 0;
}
//https://www.luogu.com.cn/discuss/988405

char和string
/*
// 单个字符
char c = getchar(); // 输入单个字符
putchar(c);// 输出单个字符
islower(c);// 判断c是否为小写字母
isupper(c);// 判断c是否为大写字母
isalpha(c);// 判断是否为字母
isdigit(c);// 判断是否为数字
// 字符数组
'\0' // 字符数组最后一个：ASCII值：0
char str[];
cin>>str; // 可以作为一个整体进行cin,cout
cout<<str;
str ="sdfa"；// 可以直接用字符串赋值

// 字符数组常用处理函数：
char str[100]; // char *str
puts(str); // 输出字符串
gets(str);// 输入一整行字符串（包括空格，已弃用）
fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
strcat(str1,str2) // 把str2连接到str1后面
strcmp(str1,str2) // 比较两个字符串，正数：1大；0：一样大，负数：2大
strlen(str) // 获取字符串长度（不包括'\0'）

// string
#include<string> // 字符串头文件
=  可以重新赋值
+= 尾部加入字符串

+ 连接字符串
  ==，！=，<,>,<=,>= 字符串的比较
  [] 存取单一字符
  getline(cin,str) // 输入（包括空格，enter键结束）
  str.substr(i,1) // 从i开始截取，截取长度为1的子字符串
  str.find(str2) // 在str字符串中去找到str字符串
  str.rfind(str2) //  str中查找str2，返回所在的下标，没找到返回string::npos
  str.erase(i,1)  // 第i个字符开始往后面去删除
  str.inser(i,str2) // 在个位置 cun

<< // 输出
str.substr(i, l); // 从i开始，截取长度为l的子字符串
str.find(str2); // 在str中查找str2，返回所在的下标，没找到返回string::npos
str.rfind(str2); // 同find，但是从右向左找
str.erase(i, l); // 从i开始，删除长度为l的子字符串
str.insert(i, str2); // 在i的位置前，插入str2
str.size(); // 获取str的长度
str.c_str(); // 获取str对应的char[]
str.begin(); // 获取str的首地址
str.end(); // 获取str的尾地址(最后一个元素后面)

*/

bitset
#include<iostream>
#include<bitset>
using namespace std;

/*
bitset<N> varm(M) 用于处理进制
N 代表占的位数
varm 代表bitset名
M变量的初始值
bitset头文件：
#include<bitset>
bitset例子：
bitset<32> b;
相关STL函数：
b.any() 当bitset对象的一位或多个位被设置为1 时any()返回true
用途：检测总开关是否全被关闭状态
b.none() 如果bitset 对象的所有位都被设置为0 ,则none()操作返回true
用途：检测总开关是否全被关闭状态(出现一个没关false)
b.count() count()操作返回被设置为1的位的个数.
b.set() 我们可以用set()操作或者下标操作符来设置某个单独的位
b.test(位置) 测试某个单独的位是否为1
if(b.test(2)) 返回真测试第二位是否为1
b.reset(x) 把x位设置为0
b.flip()  操作翻转整个bitset 对象或一个独立的位
b.flip( 0 ); // 翻转第一位
b[0].flip(); // 也是翻转第一位
b.flip(); // 翻转所有的位的值
size()：返回大小（位数）。
to_ulong()：返回它转换为unsigned long的结果，如果超出范围，则报错。
to_string()：返回它转换为string的结果。

*/
bitset<32> b(12); // 000000000000000000000000000000000000001100
int main(){
//	string s;
//	cin>>s;
//	int len = s.size();
//	for(int i = 0;i<len-1;i++){
//		ans+=(s[i]-'0')*pow(2,len-i-1);
//		cout<<ans<<endl;
//	}
cout<<b<<endl;
bool c = b.any();
bool k = b.none();
cout<<c<<" "<<k<<endl;
//偶数位数设为1会变成什么
for(int i = 0;i<32;i++){
if(i%2==0){
b[i]=1;
}
}
//	int m = b.count();
cout<<b<<endl;
if(b.test(13)){
cout<<"第13位是1";
} else{
cout<<"第13位是0";
}
b.reset(4);
cout<<endl<<b<<endl;
b.flip(0);
b.flip(2);
b[6].flip();
cout<<"翻转第一位后的结果：";
cout<<endl<<b<<endl;
cout<<"把整个bitset翻转:"<<endl;
b.flip();
cout<<endl<<b<<endl;
int l = b.to_ulong();
cout<<"改变后的进制转成数字"<<l;

}

bitset2
将字符串转成数字：

1.借用bitset将01字符串变成无符号整数

string a = "1001";

bitset<64> b(string("1001"))

bitset<64> b(a)

cout<<b.to\_ulong()

2.用sscanf() 函数把字符数组里面的字符串打印到数值变量里面

int buf;

sscanf("123456","%d",&buf)

printf("%d\\n",buf)

3.用sprintf()把数据打印到字符数组里面

char s[100]

sprintf(s,"%d",123)

4.用直接的方式

string s = "1234";

int n = 0;

for(int i = 0;i<4;i++){

n = n\*10+s[i]-'0';

}

5.一般用法

char buf[512] = ;

sscanf("123456 ", "%s", buf);

printf("%s\\n", buf);

结果为：123456

1. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。

sscanf("123456 ", "%4s", buf);

printf("%s\\n", buf);

结果为：12342. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。

sscanf("123456 abcdedf", "%[^ ]", buf);

printf("%s\\n", buf);

结果为：123456

3. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。

sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

4. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。

sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

5、给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 "iios/"过滤掉，再将

非'@'的一串内容送到buf中

sscanf("iios/12DDWDFF@122", "%\*[^/]/%[^@]", buf);

printf("%s\\n", buf);

结果为：12DDWDFF

6、给定一个字符串"hello, world"，仅保留"world"。（注意：“，”之后有一空格）

sscanf("hello, world", "%\*s%s", buf);

printf("%s\\n", buf);

结果为：world　　P.S. %\*s表示第一个匹配到的%s被过滤掉，即hello,被过滤了，如果没有空格则结果为

NULL