day2 3-牛客67道剑指offer-JZ15、JZ16、JZ24、JZ25、JZ26、JZ27、JZ29、JZ30、调整数组顺序使奇数位于偶数前面、链表中倒数第k个结点

已于 2023-08-07 12:16:18 修改
阅读量198 收藏
点赞数
分类专栏： C++刷题-LeetCode-牛客 文章标签： 链表 算法 数据结构 c++
于 2023-08-04 01:30:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/UUUUU22/article/details/131937465
版权

文章目录

1. JZ15 二进制中1的个数

题目描述：输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示

bitset运用

利用递增，右上角为分割点

  class Solution {
public:
    int NumberOf1(int n) {
        //bitset运用 将n转化为 32位二进制数表示 不足32位的前面补齐即可 count()二进制数中1的个数
        return bitset<32>(n).count();
    }
};

位运算-右移/左移

class Solution {
public:
    int NumberOf1(int n) {
        //右移运算
        int result = 0;
        for(int i=0; i<32; i++)
        {
           if((n & 1)!=0) result++;
           n = n>>1;
            //if((n & (1 << i)) != 0) result++;//左移
        }
        return result;
    }
};

位运算-与操作-阿秀题解

思路：n&(n−1)n&(n-1)n&(n−1)，会将n的二进制中最低位由1变成0

如果一个整数不为0，那么这个整数至少有一位是1。如果把这个数减1，那么原来处在整数最右边的1就会变为0，如果最右边的1后面还有0的话，原来在1后面的所有的0都会变成1。其余所有位将不会受到影响。

举个例子： 一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011。也就是说减1的结果是把最右边的一个1开始的所有位都取反了。

这时，如果再把原来的整数和减去1之后的结果做与运算，来整数最右边的1之后的所有位都会变成0，如1100&1011=1000。也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0。那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。

在这里插入图片描述

class Solution {
public:
    int NumberOf1(int n) {
        int result = 0;
        //与操作
        while(n)
        {
            n = n & (n-1);
            result++;
        }
        return result;
    }
};

JZ16 数值的整数次方

题目：实现函数 double Power(double base, int exponent)，求base的exponent次方。
给定一个double类型的浮点数base和int类型的整数exponent，保证base和exponent不同时为0。不得使用库函数，同时不需要考虑大数问题，也不用考虑小数点后面0的位数

方法都是看题解的

数学计算模拟过程

在这里插入图片描述

class Solution {
public:
    double Power(double base, int exponent) {
    if(base == 0.0) return 0;
    if(exponent == 0) return 1;
    //数学计算
    bool flag = false;
    if(exponent < 0)
    {
        flag = true;
        exponent *= -1;
    }
    double result = base;
    for(int i=1; i<exponent; i++)
    {
        result *= base;
    }
    if(flag) return 1.0 / result;
    return result;
    }
};

快速幂运算-二分法应用

在这里插入图片描述

幂运算的理解

以下内容搬运力扣大佬的题解，很清晰，作者是jyd，来源力扣，链接

也是在模拟幂运算的过程，如果是偶数次方幂运算，底数扩大2倍，幂数就要缩小2倍；如果是奇数次方幂运算，取出一个底数，就变成了偶数次方的幂运算了，过程一样。所以才会有幂数对2取余数（ 判断二进制数最右一位值）的操作了。

注意点：

  1. long exp = exponent;这一步原因如下：

这里是因为计算机内int的范围问题。在普通计算机内，负数都是补码表示的。int32的范围是[-2147483648, 2147483648]，但int是无法正常表示-2147483648的补码，计算机里-2147483648的补码和2147483648的补码一样，这是因为溢出了，表示不了，而在long类型下可以正常表示-2147483648。

  1. if(exponent < 0) exp = exponent * (-1.0);这一步原因如下：

当exponent == INT_MIN时，对应的相反数是大于INT_MAX的，所以要用一个大于 INT_MAX的类型来保存。把此时的exponent转正数时， exponent*(-1)的结果依然是int类型（隐藏类型），然后将结果赋值给 exp。但用来保存结果值的不应该是个int型，因此用double型的-1（-1.0） ,这样就可以将相乘的结果值保存为一个 double类型了，然后再进行赋值。

class Solution {
public:
    double Power(double base, int exponent) {
    if(base == 0.0) return 0;
    if(exponent == 0) return 1;
    //快速幂运算
    long exp = exponent;
    if(exponent < 0) 
    {
        exp = exponent * (-1.0);
    }
    double result = 1.0;
    while (exp != 0) 
    {
        //exp对2取余数 等价于 判断二进制数最右一位值是0还是1，即exp & 1
        if((exp & 1) == 1) result *= base;//奇数次方时，可以再往上乘一个
        base *= base;//叠加
        //exp对2向下取整 等价于 右移一位，即exp >> 1
        exp = exp >> 1;//减少乘次数
    }
    return exponent < 0 ? 1.0/result : result;
    }
};

3. 调整数组顺序使奇数位于偶数前面

题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
对应力扣922题，写过，第一时间反应过来的是暴力解法

暴力解法

一个数组，先保存奇数，再保存偶数。时间/空间都是 O ( n ) O(n) O(n)

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        vector<int> result(array.size(), 0);
        int count = 0;
        for(int i = 0; i<result.size(); i++)
        {
            if((array[i] % 2) != 0) result[count++] = array[i];
        }
        for(int j = 0; j<array.size(); j++)
        {
            if((array[j] % 2) == 0) result[count++] = array[j];
        }
        array.assign(result.begin(), result.end());
    }
};
  • 优化空间，只保存偶数，辅助数组的大小为原数组的一半
class Solution {
public:
    void reOrderArray(vector<int> &array) {
        //暴力解法-优化
        int len = array.size();
        int oddindex = 0, evenindex = 0;//奇偶数的个数
        vector<int> temp(len / 2 + 1, 0);
        for(int i=0; i<array.size(); i++)
        {
            if((array[i] & 1) == 1) array[oddindex++] = array[i];//奇数直接存在原数组
            else temp[evenindex++] = array[i];//偶数存在辅助数组
        }
        for(int j=0; j<evenindex; j++)
        {
            array[j + oddindex] = temp[j];
        }
    }
};

原地解法

不使用辅助数组，在原数组修改，但是时间复杂度是 O ( n 2 ) O(n^2) O(n2)，空间是 O ( 1 ) O(1) O(1)，空间换时间

如果两个相邻的数是前偶后奇，就交换，双层循环是从两头向中间逼近，外循环从前，内循环从外

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        //原地解法
        for(int i=0; i<array.size(); i++)//外循环向中间逼近
        {
            for(int j=array.size()-1; j>i; j--)//内循环向中间逼近
            {
                if((array[j-1] & 1) == 0 && (array[j] & 1) == 1)//前面是偶数，后面是奇数
                {
                    swap(array[j-1], array[j]);
                }
            }
        }
    }
};

4. 链表中倒数第k个结点

题目：输入一个链表，输出该链表中倒数第k个结点。

常规解法

求总结点数len，然后正序遍历len-k，找到倒数第k个结点

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
		int len = 0;
		ListNode* dummyhead = pListHead;
		while (dummyhead) 
		{
			dummyhead = dummyhead->next;
			len++;
		}
		len = len - k;
		if(len < 0) return nullptr;
		dummyhead = pListHead;
		while(len--)
		{
			dummyhead = dummyhead->next;
		}
		return dummyhead;
    }
};

快慢指针

pListHead相当于是快指针，先走k步，然后慢指针和快指针同时开始走，要注意慢指针走到倒数第k个位置时，快指针还没有走到头。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
		//快慢指针
		ListNode* slownode = pListHead;
		//pListHead相当于是快指针，先走k步
		while (k) //k 一直走到 0 即可
		{
			k--;
			//在其中判断是否出现k 大于链表总长度的情况 比如 【1,2,3,4,5】 6这样的情况，如果出现这样的情况，返回即可
			if(!pListHead) return nullptr;
			pListHead = pListHead->next;
		}
		while (pListHead) //先走的不能为空
		{
			slownode = slownode->next;
			pListHead = pListHead->next;
		}
		//if(slownode->next) slownode->next = nullptr;
		return slownode;	
    }
};

5. JZ24 反转链表

题目描述：完成队列的Push和Pop操作。 队列中的元素为int类型给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

在这里插入图片描述

前后指针

用一个指针暂存下一个要反转的结点，前指针指向后面的指针进行反转。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* ReverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        //头插法 前后指针
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* temp = nullptr;
        while(cur)
        {
            temp = cur->next;//保存cur下一个结点，下一个要反转的结点
            cur->next = pre;//翻转
            pre = cur;//更新
            cur = temp;//更新
        }
        return pre;
    }
};

头插法

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* ReverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        // 头插法
        ListNode* pre = new ListNode(0);
        ListNode* cur = head->next;
        ListNode* temp = nullptr;
        //head -> 1 -> 2 -> 3 -> null
        pre->next = head;//pre新链表的虚拟头结点 pre->head
        head->next = nullptr;//新链表是以null开始的，相当于pre -> null，即pre->next新链表是真正表头 
        while (cur) {
            temp = cur;//保存当前结点 后面要让pre更新 temp=1
            cur = cur->next;//cur为下一个反转结点 cur=2
            //此时pre=null temp=1, cur=2
            temp->next = pre->next;//相当于1 -> null
            pre->next = temp;//pre=1
            //此时1 -> null
        }
        return pre->next;
    }
};

6. JZ25 合并两个排序的链表

题目描述：输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。要求空间复杂度 O(1)，时间复杂度 O(n)。

双指针+虚拟表头，注意新链表指针后移

迭代法

空间复杂度 O(1)，时间复杂度 O(n+m)

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(pHead1 == nullptr) return pHead2;
        if(pHead2 == nullptr) return pHead1;
        ListNode* dummyhead = new ListNode(0);
        ListNode* cur = dummyhead;
        while(pHead1 && pHead2)
        {
            if(pHead1->val > pHead2->val) swap(pHead1, pHead2);//选结点值较小的
            cur->next = pHead1;//新链表连接结点
            //结点更新
            pHead1 = pHead1->next;//pHead1的结点用掉了 要更新
            cur = cur->next;//指针后移，否则从新链表头结点直接连下一个结点
        }
        //是否遍历完 奇数长度的链表还剩下一个结点没有连接
        cur->next = pHead1 ? pHead1 : pHead2;
        return dummyhead->next;//去掉新链表的表头
    }
};

递归法 不符合要求

时间、空间都是O(n+m)，扩展思路

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        //递归法 不符合要求
        //递归结束条件
        if(pHead1 == nullptr || pHead2 == nullptr)
        {
            return pHead1 ? pHead1 : pHead2;//返回不为空的链表
        }
        //选择结点值较小的作为新链表结点
        if(pHead1->val <= pHead2->val)
        {
            //pHead1结点值较小 连接下一个（两个链表中结点值小的）新结点
            //问题由1->3->5 2->4->6的合并 变成了3->5 2->4->6 的合并
            pHead1->next = Merge(pHead1->next, pHead2);//注意传入的链表
            return pHead1;
        }
        else
        {
            pHead2->next = Merge(pHead2->next, pHead1);
            return pHead2;
        }
    }
};

class Solution {
public:
    int minNumberInRotateArray(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        //二分法 左闭右开 最值在两头
        int left = 0, right = nums.size()-1;
        while(left+1 < right)
        {
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[right]) right = mid;//说明右边有序，那就向左边走
            else if(nums[mid] == nums[right]) right = right-1;
            else left = mid;
        }
        return min(nums[left], nums[right]);
    }
};

7. JZ26 树的子结构

题目描述： 输入两棵二叉树A，B，判断B是不是A的子结构。（我们约定空树不是任意一个树的子结构）。假如给定A为{8,8,7,9,2,#,#,#,#,4,7}，B为{8,9,2}，2个树的结构如下，可以看出B是A的子结构。

在这里插入图片描述
搬运力扣Krahets的题解：

  1. isSubStructure(A, B) 函数：
  • 特例处理： 当 树 A 为空 或 树 B 为空 时，直接返回 false ；
  • 返回值： 若树 B 是树 A 的子结构，则必满足以下三种情况之一，因此用或 || 连接；
    • 以 节点 A 为根节点的子树 包含树 B ，对应 recur(A, B)；
    • 树 B 是 树 A 左子树 的子结构，对应 isSubStructure(A.left, B)；
    • 树 B 是 树 A 右子树 的子结构，对应 isSubStructure(A.right, B)；
    • 实质上是在对树 A 做 先序遍历 。
  1. recur(A, B) 函数：
  • 终止条件：
    • 当节点 B 为空：说明树 B 已匹配完成（越过叶子节点），因此返回 true ；
    • 当节点 A 为空：说明已经越过树 A 叶子节点，即匹配失败，返回 false ；
    • 当节点 A 和 B 的值不同：说明匹配失败，返回 false ；
  • 返回值：
    • 判断 A 和 B 的左子节点是否相等，即 recur(A.left, B.left) ；
    • 判断 A 和 B 的右子节点是否相等，即 recur(A.right, B.right) ；

这道题和力扣的 572. 另一个树的子树类似，力扣认为空树也是子树结构，上次写的这道题的记录，对称二叉树的相关题

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
		//如果两个树有一个是空树 都不符合要求
		if(pRoot1 == nullptr || pRoot2 == nullptr) return false;
		//三种情况 p2是p1的左子树、p2是p1的右子树、p2从根节点就是p1的子树 有一个成立即可 或条件 
		//前序遍历 另一个函数判断子树结构
		return isSametree(pRoot1, pRoot2) || HasSubtree(pRoot1->left, pRoot2) || HasSubtree(pRoot1->right, pRoot2);
    }

	bool isSametree(TreeNode* A, TreeNode* B)
	{
		//判断B是否为A子树结构 逐个结点判断
		//如果B是空结点，递归结束；A是空结点，或者 A、B结点值不相等 不合要求；依次左、右结点比较
		if(B == nullptr) return true;
		if(A == nullptr) return false;
		if(A->val == B->val) return isSametree(A->left, B->left) && isSametree(A->right, B->right);
		else return false;
	}
};

8. JZ27 二叉树的镜像

题目描述： 操作给定的二叉树，将其变换为源二叉树的镜像。
数据范围：二叉树的节点数 0≤n≤10000 ， 二叉树每个节点的值 0≤val≤10000
要求： 空间复杂度 O(n) 。本题也有原地操作，即空间复杂度 O(1)的解法，时间复杂度 O(n)。
在这里插入图片描述

递归

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    TreeNode* Mirror(TreeNode* pRoot) {
        //递归
        if(pRoot == nullptr) return nullptr; //结束
        swap(pRoot->left, pRoot->right);
        Mirror(pRoot->left);
        Mirror(pRoot->right);
        return pRoot;
    }
};

队列迭代

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    TreeNode* Mirror(TreeNode* pRoot) {
        if(pRoot == nullptr) return nullptr;
        //队列迭代
        queue<TreeNode*> que;
        que.push(pRoot);
        while(!que.empty())
        {
            TreeNode* cur = que.front();//中
            que.pop();
            if(cur)
            {
                //存当前节点的左、右子节点 然后交换
                que.push(cur->left);
                que.push(cur->right);
                swap(cur->left, cur->right);
            }
        }
        return pRoot;

    }
};

栈迭代

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    TreeNode* Mirror(TreeNode* pRoot) {
        if(pRoot == nullptr) return nullptr;
        //栈迭代
        stack<TreeNode*> st;
        st.push(pRoot);
        while(!st.empty())
        {
            TreeNode* cur = st.top();
            st.pop();
            if(cur)
            {
                st.push(cur->left);
                st.push(cur->right);
                swap(cur->left, cur->right);
            }
        }       
        return pRoot;
    }
};

9. JZ29 顺时针打印矩阵

题目描述：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵：
在这里插入图片描述

四个方向模拟，注意越界判断

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> result;
        if(matrix.empty()) return result;
        int rl = 0, rh = matrix.size() - 1;//上下边界 行 记录待打印的矩阵上下边缘
        int cl = 0, ch = matrix[0].size() - 1;//左右边界 列 记录待打印的矩阵左右边缘
        while(1)
        {
            for(int i=cl; i<=ch; i++) result.push_back(matrix[rl][i]);//固定上边界 行 从左往右
            if(rl++ > rh) break;//操作行 防止越界
            for(int i=rl; i<=rh; i++) result.push_back(matrix[i][ch]);//固定右边界 列 从上往下
            if(ch-- < cl) break;
            for(int i=ch; i>=cl; i--) result.push_back(matrix[rh][i]);//固定下边界 行 从右往左
            if(rh-- < rl) break;
            for(int i=rh; i>=rl; i--) result.push_back(matrix[i][cl]);//固定左边界 列 从下往上
            if(cl++ > ch) break;
        }
        return result;
    }
};

while循环条件改了

#include <vector>
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        if(matrix.size() == 0 || matrix[0].size() == 0) return vector<int>();
        vector<int> result;
        int top = 0, bottom = matrix.size()-1;
        int left = 0, right = matrix[0].size()-1;
        while(top <= bottom && left <= right)
        {
            for(int i=left; i<=right; ++i) result.push_back(matrix[top][i]);//从左往右
            if(++top > bottom) break;//逐行向下 防止越界
            for(int i=top; i<=bottom; ++i) result.push_back(matrix[i][right]);//从上往下
            if(--right < left) break;
            for(int i=right; i>=left; --i) result.push_back(matrix[bottom][i]);//从右往左
            if(--bottom < top) break;
            for(int i=bottom; i>=top; --i) result.push_back(matrix[i][left]);//从下往上
            if(++left > right) break;
        }
        return result;
    }
};

10. JZ30 包含min函数的栈

题目描述：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））
此栈包含的方法有：
push(value):将value压入栈中
pop():弹出栈顶元素
top():获取栈顶元素
min():获取栈中最小元素

两个栈

class Solution {
public:
    void push(int value) {
        if(st.empty() && minst.empty())
        {
            st.push(value);
            minst.push(value);
        }
        else
        {
            //st肯定是要入栈的 是否入minst要看值的大小
            st.push(value);
            if(value <= minst.top()) minst.push(value);
            else minst.push(minst.top());//保证minst存的是最小值且与st结构保持一致
        }
    }
    void pop() {
        st.pop();
        minst.top();
    }
    int top() {
        return st.top();
    }
    int min() {
        return minst.top();
    }
private:
    stack<int> st;
    stack<int> minst;
};

一个栈

注意一个栈时，最小值在下面

class Solution {
    //一个栈
    stack<int> st;
    int minNum = INT_MAX;
public:
    void push(int value) {
        minNum = std::min(value, minNum);//std::min不是要实现的min函数
        st.push(minNum);//最小值在下面
        st.push(value);
    }
    void pop() {
        st.pop();//弹出当前值
        st.pop();//弹出当前最小值
        //获取新的最小值 要先把新的最小值 上面的值取出
        if(!st.empty())
        {
            int temp = st.top();
            st.pop();
            minNum = st.top();
            st.push(temp);
        }
    }
    int top() {
        return st.top();
    }
    int min() {
        return minNum;
    }
};

补充内容：bitset的用法

bitset的用法

  1. bitset 介绍
    std::bitset 是 C++ 标准库中的一个类，用于表示二进制位序列。它提供了一种方便的方式来处理二进制数据，尤其适用于位运算操作。

std::bitset 类型表示一个固定长度的位序列，每个位都只能是 0 或 1。这个固定长度在创建对象时指定，并且不能在运行时更改。类似于整数类型，std::bitset 支持多种操作，包括位运算、位查询和位设置。

  1. std::bitset 类型的创建方式：
#include <bitset>
 ​
	std::bitset<N> bitset1; // 创建一个长度为 N 的 bitset，所有位都被初始化为 0
	std::bitset<N> bitset2(value); // 使用二进制整数 value 初始化一个长度为 N 的 bitset
	std::bitset<N> bitset3(string); // 使用二进制字符串 string 初始化一个长度为 N 的 bitset
	std::bitset<N> bitset4(bitset); // 使用另一个 bitset 初始化一个长度为 N 的 bitset
	
	bitset<8> bitset2(12);　　//长度为８，二进制保存，前面用０补充
	
	string s = "100101";
	bitset<10> bitset3(s);　　//长度为10，前面用０补充
	
	char s2[] = "10101";
	bitset<13> bitset4(s2);　　//长度为13，前面用０补充
	
	cout << bitset1 << endl;　　//0000
	cout << bitset2 << endl;　　//00001100
	cout << bitset3 << endl;　　//0000100101
	cout << bitset4 << endl;　　//0000000010101
  1. std::bitset 类型的一些常用操作：
  • size() 返回 std::bitset 的长度
  • count() 返回 std::bitset 中值为 1 的位的数量
  • any() 返回 std::bitset 中是否存在值为 1 的位
  • none() 返回 std::bitset 中是否所有位都是 0
  • all() 返回 std::bitset 中是否所有位都是 1
  • test(pos) 返回 std::bitset 中位于 pos 位置的值
  • set(pos) 将 std::bitset 中位于 pos 位置的值设为 1
  • reset(pos) 将 std::bitset 中位于 pos 位置的值设为 0
  • flip(pos) 将 std::bitset 中位于 pos 位置的值取反
  • to_ulong() 返回 std::bitset 转换成的无符号整数值
  • to_ullong() 返回 std::bitset 转换成的无符号长整数值
bitset<8> foo ("10011011");
 
cout << foo.count() << endl;　　//5　　（count函数用来求bitset中1的位数，foo中共有５个１
cout << foo.size() << endl;　　 //8　　（size函数用来求bitset的大小，一共有８位

cout << foo.test(0) << endl;　　//true　　（test函数用来查下标处的元素是０还是１，并返回false或true，此处foo[0]为１，返回true
cout << foo.test(2) << endl;　　//false　　（同理，foo[2]为０，返回false
  
cout << foo.any() << endl;　　//true　　（any函数检查bitset中是否有１
cout << foo.none() << endl;　　//false　　（none函数检查bitset中是否没有１
cout << foo.all() << endl;　　//false　　（all函数检查bitset中是全部为１
  1. std::bitset 重载了许多二进制运算符，如 &、|、^、~ 等，使其支持类似于整数类型的位运算操作，使用左移、右移运算符进行位移操作，支持 to_string() 方法，将其转换成二进制字符串
//&、|、^、~ 等，使其支持类似于整数类型的位运算操作
 std::bitset<4> bitset1("1010");
 std::bitset<4> bitset2("0110");
 ​
 std::bitset<4> bitset3 = bitset1 & bitset2; // 按位与运算
 std::bitset<4> bitset4 = bitset1 | bitset2; // 按位或运算
 std::bitset<4> bitset5 = bitset1 ^ bitset2; // 按位异或运算
 std::bitset<4> bitset6 = ~bitset
//左移、右移运算符进行位移操作
 std::bitset<4> bitset1("0101");
 std::bitset<4> bitset2 = bitset1 << 2; // 左移 2 位，结果为 "010100"
 std::bitset<4> bitset3 = bitset1 >> 1; // 右移 1 位，结果为 "0010"
//转换成二进制字符串
 std::bitset<4> bitset1("1010");
 std::string str = bitset1.to_string(); // "1010"
虚假自律就会真自律！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Moving On 第 44 届 ACM/ICPC 亚洲区域赛（银川）网络赛
Up Panda
09-03 7万+
Firdaws and Fatinah are living in a country with nnn cities, numbered from 111 to nnn. Each city has a risk of kidnapping or robbery. Firdaws's home locates in the city uuu, and Fatinah's home locate...
爱情来的太快就像龙卷风
热门推荐
qq_45717538的博客
10-19 8万+
题解 uuuu yyy uuu uuu ooo rrr rr w iii ee ww yyy ooo eee uuu rrr ee yy e 首先再26个键盘上找到u所对应一行u是第几个字母u对应第7个所以对应九宫格第7个格u有四个所以是第七个格里第四个字母s，以此类推
WebSocket
MorningDuGe
07-31 3万+
ajax轮询 每隔一段时间发送一次请求询问服务器有消息发送不（需要服务器有很快的处理速度） 长轮询 发送一次请求然后一直等待直到服务器有消息发送，服务器发完消息后连接中断，客户端重新建立连接请求，周而复始重复。（需要服务器有很高的并发性，即同时处理） 以上两种都需要重复建立连接，且容易使服务器崩溃。websocket 是HTML5的新协议，实现了浏览器和服务器的全双工通信，节省带宽实时通
wwwwwwwwwwwww
yyyuuu999的专栏
11-30 4万+
wwwwwwwwwwwwww 
yuv图解（YUV444,YUV422,YUV420,YV12,NV12,NV21）
weixin_42097108的博客
08-02 1万+
图解YUV
剑指offer（java版）----牛客.zip
09-20
《剑指Offer》是经典的一本面试准备书籍，主要针对计算机科学与技术领域的求职者，尤其是对Java开发者具有很高的参考价值。这本书源自牛客网，一个专注于编程技能测试和在线编程竞赛的平台，旨在帮助求职者提升编程...
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
《剑指Offer：牛客网算法题编程代码解析汇总》 在编程领域，尤其是在面试准备过程中，"剑指Offer"是一本备受推崇的书籍，它集合了大量的算法题目，旨在提升程序员在解决实际问题中的能力。牛客网作为国内知名的在线...
offer:牛客剑指offer
05-06
《牛客剑指Offer》是Java开发者们非常关注的一套面试题集，它涵盖了大量面试中常见的编程问题，旨在帮助求职者提升技能，顺利通过面试。这个压缩包"offer-master"很可能包含了该题集的源代码或者解决方案。下面，...
javalruleetcode-onlinejudge-solutions:LeetCode、剑指Offer
06-29
1.牛客网(剑指Offer、笔试题) 解决问题 提交时间 状态 运行时间 占用内存 使用语言 代码链接 重建二叉树 2019-10-07 答案正确 218ms 22404K Java 数组中的逆序对 2019-09-21 答案正确 524ms 52020K Java 二叉树中和...
2007-2008 Summer Petrozavodsk Camp, Andrew Stankevich Contest 26 (ASC 26) Codeforces Gym 100153
deja vu
07-21 1万+
2007-2008 Summer Petrozavodsk Camp, Andrew Stankevich Contest 26 (ASC 26) 题解 Codeforces Gym 100153
一些比较好的站点
yyyyyyyyyywwwwwwwwww的专栏
04-13 1万+
关于 linux  C/C++  java  等的 http://www.cnblogs.com/ggjucheng/archive/2012/08/18/2645321.html linux那些事 http://blog.csdn.net/fudan_abc/ 蜗窝科技   慢下来，享受技术。 http://www.wowotech.net/
html结构及部分属性——从0开始
HZBCc的博客
04-03 2万+
<!--html负责网页的结构，使用html标``签时，应关注标签的语义而不是样式--> <!doctype html> <!--声明网页版本是html5--> <html> <head> <title>html的网页</title> <!--title的内容会会作为搜索结果的超链接上的文字显示--> <meta charset="utf-8"&
【中科院】分子生物学-朱玉贤第四版-笔记-第7-8讲 翻译
abdslfwoeugp
05-11 4万+
【中科院】分子生物学-朱玉贤第四版-笔记-第7-8讲 翻译
YOLOV4在Windows10下训练
ty的博客
03-15 7016
YOLOV4在Windows10下训练
＜软考高项＞必背英语单词
最新发布
明天是个好天气
04-26 1万+
英文
css的calc和vh&vw
pscool的博客
07-24 950
css的calc和vh&vw
php编译
u014576908的博客
07-30 3万+
linux下如何把php升级到5.6 08-03 阅读数 22764 phpstudy集成环境升级mysql5.6 02-13 阅读数 6774 CentOS 通过yum来升级php到php5.6 06-07立即下载 linux系统安装php5.6 08-09 阅读数 591 将lnmp 自带的 php 5.4升级为 5.6 08-03 阅读数 5556 Ubuntu 16.0...
离散数学及其应用知识点（自用）
weixin_58677390的博客
07-03 1万+
第二章 命题逻辑 1.→，前键为真，后键为假才为假；<—>，相同为真，不同为假； 2.主析取范式：极小项(m)之和；主合取范式：极大项(M)之积； 3.求极小项时，命题变元的肯定为1，否定为0，求极大项时相反； 4.求极大极小项时，每个变元或变元的否定只能出现一次，求极小项时变元不够合取真，求极大项时变元不够析取假； 5.求范式时，为保证编码不错，命题变元最好按P,Q,R的顺序依次写； 6.真值表中值为1的项为极小项，值为0的项为极大项； 7.n个变元共有个极小项或极大项，这为(0~-1)刚好
在线评测系统大全-2021-10-5
3. **《信息学奥赛一本通（C++版）》配套OJ**：适合中等难度的练习，两个网址提供了相同的练习环境。 4. **啊哈添柴**：一个中等难度的平台，适合有一定基础的用户。 5. **洛谷**：拥有大量的在线比赛和题目，虽然...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值