【学习日志】2022.08.04 幂运算 位运算 Iterator 链表操作

已于 2022-10-15 09:14:40 修改
阅读量267 收藏
点赞数 1
分类专栏： 学习日志 文章标签： leetcode
于 2022-08-04 21:24:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Angelloveyatou/article/details/126156197
版权

C++幂运算

浮点型 pow(x,y)

//函数名称:   pow
//函数原型:   double pow( double x, double y );
//函数功能:   计算x的y次幂
//所属文件:   <math.h>

/* pow example */
#include <stdio.h>      /* printf */
#include <math.h>       /* pow */
 
int main ()
{
  printf ("3 ^ 4 = %f\n", pow (3.0, 4.0) );
  return 0;
}

 整数型 简单幂运算

for(int i=0;i<4;i++){
    ans=ans*3%1000000007;
}

整数型 快速幂运算 1

fd5f5f37190d4f2f9573dcbbf4999095.png

//m取模 一般为1000000007

typedef long long ll;
ll quick_pow(ll x,ll n,ll m){
	ll res = 1;
	while(n > 0){
		if(n & 1)	res = res * x % m;
		x = x * x % m;
		n >>= 1;//相当于n=n/2.详情请参考位移运算符。
	}
	return res;
}

整数型 快速幂运算 2 

28e2a05bef4144569820bde53753e0e2.png

ll q_pow(ll x,ll n,ll m){
	if(n == 0)	return 1;
	ll res = q_pow(x * x % m,n/2,m);
	if(n & 1)	res = res * x % m;
	return res;
}

1

5e2def78344845dd8087c4a85468c760.png

cpp

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int ret = 0;
        for(int i=0;i<32;i++){
            if(n & 1<<i){
                ret++;
            }
        }
        return ret;
    }
};

python

class Solution:
    def hammingWeight(self, n: int) -> int:
        ret = sum(1 for i in range(32) if n & (1 << i)) 
        return ret

运算符优先级

20170224091809734

2

788d2b160c6d4cf0a184fed3194856d5.png

 ebc190d2f5374bd0adfe24b6effa1558.png

 cpp

class Solution {
public:
    double quickMul(double x, long long N) {
        if (N == 0) {
            return 1.0;
        }
        double y = quickMul(x, N / 2);
        return N % 2 == 0 ? y * y : y * y * x;
    }

    double myPow(double x, int n) {
        long long N = n;
        return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N);
    }
};

python

class Solution:
    def myPow(self, x: float, n: int) -> float:
        def quickMul(N):
            if N == 0:
                return 1.0
            y = quickMul(N // 2)
            return y * y if N % 2 == 0 else y * y * x
        
        return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)

0deea8a820a340378ba5d05c847173c4.png

 cpp

class Solution {
public:
    double quickMul(double x, long long N) {
        double ans = 1.0;
        // 贡献的初始值为 x
        double x_contribute = x;
        // 在对 N 进行二进制拆分的同时计算答案
        while (N > 0) {
            if (N % 2 == 1) {
                // 如果 N 二进制表示的最低位为 1，那么需要计入贡献
                ans *= x_contribute;
            }
            // 将贡献不断地平方
            x_contribute *= x_contribute;
            // 舍弃 N 二进制表示的最低位，这样我们每次只要判断最低位即可
            N /= 2;
        }
        return ans;
    }

    double myPow(double x, int n) {
        long long N = n;
        return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N);
    }
};

python

class Solution:
    def myPow(self, x: float, n: int) -> float:
        def quickMul(N):
            ans = 1.0
            # 贡献的初始值为 x
            x_contribute = x
            # 在对 N 进行二进制拆分的同时计算答案
            while N > 0:
                if N % 2 == 1:
                    # 如果 N 二进制表示的最低位为 1，那么需要计入贡献
                    ans *= x_contribute
                # 将贡献不断地平方
                x_contribute *= x_contribute
                # 舍弃 N 二进制表示的最低位，这样我们每次只要判断最低位即可
                N //= 2
            return ans
        
        return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)

3

a0813703bdc3480eb08518186632400e.png

cpp

class Solution {
public:
    vector<int> printNumbers(int n) {
        if(n <= 0) return vector<int>(0);
        vector<int> res;
        int num = 1;
        for(int i=0; i<n; ++i)
            num *= 10; // 比如 n=3，num就是1000
        for(int i=1; i<num; ++i) res.push_back(i);
        return res;
    }
};

cpp

class Solution {
public:
	vector<int> printNumbers(int n) {
		vector<int> res;
		if (n == 0) return res;
		//打印到数组中
		for (int i=1,max=pow(10,n);i<max;i++)
		{
			res.push_back(i);
		}
		return res;
	}
};

cpp大数解法char版

class Solution {
public:
	vector<int> res;
	vector<int> printNumbers(int n) {
		if (n <= 0) return res;
		//创建一个能容纳最大值的字符数组,由于有一位要存储'\0'，因此要开大一格
		char* number = new char[n + 1];
		//初始全部设置为0
		memset(number, '0', n);
		number[n] = '\0';//第n位设为'\0'
		while (!Increment(number))
		{
			PrintNumber(number);
		}
		delete[]number;//注意要释放内存
		return res;
	}
	bool Increment(char* number) {//形参传递char*指针
		bool isOverflow = false;//检测是否越界
		int nTakeOver = 0;//存储进位
		int nLength = strlen(number);//长度为n,不是n+1
		for (int i = nLength - 1; i >= 0; i--)
		{
			int nSum = number[i] - '0' + nTakeOver;
			if (i == nLength - 1)
				//如果是第一位，进位
			{
				nSum++;
			}
			if (nSum >= 10)
				//有进位
			{
				if (i == 0)
					//如果是最高位有进位，说明超过了给定得到最大值，越界
				{
					isOverflow = true;
				}
				else//非最高位有进位
				{
					nTakeOver = 1;
					number[i] = nSum - 10 + '0';//对第i位进行设置
				}
			}
			else//没有进位
				//设置第i位数字
				//并直接跳出循环
			{
				number[i] = nSum + '0';
				break;
			}
		}
		return isOverflow;
	}
	void PrintNumber(char* number)
	//形参传递char*指针，此处改变形参number指向的位置，不会使原始的number指针所指位置改变
	{
		string s = "";
		bool isBegin0 = true;
		while (*number != '\0')
		{
			if (isBegin0 && *number != '0') isBegin0 = false;
			//碰到'0'，则不输出
			if (!isBegin0)
			{
				s += *number;
			}
			number++;
		}
		int num = stoi(s);//转为整数
		res.push_back(num);
	}
};

cpp大数解法string版

class Solution {
public:
	vector<int> res;
	vector<int> printNumbers(int n) {
		if (n <= 0) return res;
		//创建一个能容纳最大值的字符数组
		string number(n, '0');
		//初始全部设置为0
		while (!Increment(number))
		{
			saveNumber(number);
		}
		return res;
	}
	bool Increment(string& number) {
		//注意要使用引用传递，否则无法修改number
		bool isOverflow = false;//检测是否越界
		int nTakeOver = 0;//存储进位
		int nLength = number.size();
		for (int i = nLength - 1; i >= 0; i--)
		{
			int nSum = number[i] - '0' + nTakeOver;
			if (i == nLength - 1)
				//如果是第一位，进位
			{
				nSum++;
			}
			if (nSum >= 10)//有进位
			{
				if (i == 0)
					//如果是最高位有进位，说明超过了给定得到最大值，越界
				{
					isOverflow = true;
				}
				else
				{
					nTakeOver = 1;
					number[i] = nSum - 10 + '0';//对第i位进行设置
				}
			}
			else//没有进位
				//设置第i位数字
				//并直接跳出循环
			{
				number[i] = nSum + '0';
				break;
			}
		}
		return isOverflow;
	}
	void saveNumber(string number)
		//由于此处输出，不需要修改number，因此不需要加引用
	{
		string s = "";
		bool isBegin0 = true;
		string::iterator it = number.begin();
		while (it != number.end())
		{
			if (isBegin0 && *it != '0') isBegin0 = false;
			if (!isBegin0)
			{
				s += *it;
			}
			it++;
		}
		int num = stoi(s);
		res.push_back(num);
	}
};

cpp递归解法

class Solution
{
public:
	vector<int> res;
	vector<int> printNumbers(int n) {
		if (n <= 0) return res;
		string number(n, '0');
		for (int i = 0; i <= 9; i++)
		//从高位到低位进行全排列
		{
			number[0] = i + '0';//首字符赋初值
			permutationNumbers(number, n, 1);//设置下一位
		}
		return res;
	}
	//对数字全排列
	void permutationNumbers(string& number, int length, int index) {
		if (index == length) {//递归边界
			saveNumber(number);//存储结果
			return;
		}
		else
		{
			for (int i = 0; i <= 9; i++)
			{
				number[index] = '0' + i;//设置第index位的字符
				permutationNumbers(number, length, index + 1);
			}
		}
	}
	//存储结果
	//只能存储前导非0的排列
	void saveNumber(string number) {
		bool isBegin0 = true;
		string tempStr = "";
		string::iterator it = number.begin();
		while (it != number.end())
		{
			if (isBegin0 && *it != '0') isBegin0 = false;
			if (!isBegin0) {
				tempStr += *it;
			}
			it++;
		}
		//从高位到低位全排列，要注意首字符为0时，tempStr为空，不能执行stoi
		if (tempStr != "") {
			int tempNum = stoi(tempStr);
			res.push_back(tempNum);
		}
	}
};

python

class Solution:
    def printNumbers(self, n: int) -> List[int]:
        return [i for i in range(1, 10**n)]

4

1db65e494827455a844f6febe3d31d07.png

7d19e70467ec42bf98ab7492191d6173.png

 cpp

class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if(head->val == val) return head->next;
        ListNode *pre = head, *cur = head->next;
        while(cur != nullptr && cur->val != val) {
            pre = cur;
            cur = cur->next;
        }
        if(cur != nullptr) pre->next = cur->next;
        return head;
    }
};

python

class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        if head.val == val: return head.next
        pre, cur = head, head.next
        while cur and cur.val != val:
            pre, cur = cur, cur.next
        if cur: pre.next = cur.next
        return head

 

 

 

 

EndlessDaydream
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES6中Iterator与for..of..遍历用法分析
08-30
主要介绍了ES6中Iterator与for..of..遍历用法,结合实例形式分析了ES6中Iterator的概念、用法及for..of..遍历的使用技巧,需要的朋友可以参考下
ES6 Iterator接口和for...of循环用法分析
10-16
主要介绍了ES6 Iterator接口和for...of循环用法,结合实例形式分析了Iterator接口和for...of循环相关使用技巧,需要的朋友可以参考下
位运算（快速幂详解）
m0_46686625的博客
05-16 845
位运算学习笔记（快速幂） 内容： 1.快速幂原理及其模版代码 2.判断奇数偶数 3.找出没有重复的数字 1.快速幂 对应到代码层面： 例如让我们求 a 的 b 次方对 p 取模的值。 #include <iostream> #include <cstring> #include <algorithm> using namespace std; typedef long long LL; int main() { int a,b,p; cin&g
位运算加减乘除，位运算快速幂要点及题目解析
weixin_61428506的博客
03-02 515
https://blog.csdn.net/whereisherofrom/category_11492771.html
迭代器(iterator)看这篇就够了
热门推荐
若葉的博客
08-03 9万+
迭代器很重要，是遍历线性数据结构（链表）的重要方法之一。迭代器仅仅是遍历输出语句！本身并没有任何排序等其他功能，在数据结构的二叉树中别认为迭代器输出二叉树是因为迭代器会排序，是因为排序二叉树本身有序，迭代器仅仅是按照排序二叉树本身的排序规则输出罢了。
链表（约瑟夫问题）
qq_60310132的博客
08-05 632
链表，模拟，约瑟夫问题
4.C++ 图解单向链表类模板、iterator迭代器类模版实现
抵抗时间扭曲，坚持做一件有意义的事
02-12 1390
C++ 图解单向链表类模板、iterator迭代器类模版实现
ES6 迭代器(Iterator)和 for.of循环使用方法学习(总结)
08-28
主要介绍了ES6 迭代器(Iterator)和 for.of循环使用方法学习总结,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
iterator_adaptor.pdf
08-13
Boost Iterator_adaptor
快速幂---（+位权、位运算）
liusy_21的博客
10-17 1038
先介绍两个知识点 二进制的位权问题 1、对于多位数，处在某一位上的“1”所表示的数值的大小，称为该位的位权。例如十进制第2位的位权为10，第3位的位权为100；而二进制第2位的位权为2，第3位的位权为4，对于 N进制数，整数部分第 i位的位权为N^(i-1)，而小数部分第j位的位权为N^-j。 数码所表示的数值等于该数码本身乘以一个与它所在数位有关的常数，这个常数称为“位权”，简称“权”。 ...
java 链表实现 iterator iterable
泡泡大脚的博客
05-02 1281
import java.util.Iterator; public interface ListInterface{ public boolean add(T newEntry); public boolean add(int newPosition, T newEntry); public T remove(int givenPosition); public void clea
使用迭代器(Iterator)来实现链表的相关操作
凌京的专栏
08-25 2551
在这一篇里，要讲的是如何使用迭代器对链表进行相关的操作，比如删除，获取，插入等操作，那首先介绍一下什么是迭代器，java里面的迭代器的实用性很大，在我们实际对链表进行删除操作时，如果是要对某个限制条件下的所有链表数据都删除，如果是用普通的指针，那就必须每次都对链表进行遍历查找，符合了条件进行删除，而效率很低，而不像数组，有固定的下标位，所以我们设法给予一个类似数组下标的东西来表明链表的位置。 这
Iterator的作用以及遍历LinkedList双向链表的效率
ronawilliam的专栏
12-09 8713
Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。例如，如果没有使用Iterator，遍历一个数组的方法是使用索引： for(int i=0; i而访问一个链表（LinkedList）又必须使用while循环： while((e=e.next())!=null) { ... e.data() ... } 
[C++]List with iterator(链表的迭代器实现）
stary_yan的博客
05-30 8271
List with iterator(链表的迭代器实现）我们都知道STL容器内部都有相应的迭代器，本文主要讨论的就是链表内部的迭代器实现。测试代码#include <iostream> #include <string> using namespace std; int main() { list<int> li; cout << "test size" << endl; c
指针的基本用法、指针的运算
weixin_55420595的博客
10-27 2178
指针的基本用法 1.掌握指针的基本用法 2.总结与思考 指针的作用 使程序简洁、紧凑、高效 有效的表示复杂的数据结构 动态分配内存 得到多余一个的函数返回值 地址和变量 在计算机内存中，每一个字节单元，都有一个编号，称为地址。 在C语言中，内存单元的地址称为指针，专门用来存放地址的变量，称为指针变量。 在不影响理解的情况下，有时对地址、指针和指针变量不区分，统称指针。 一般形式如下：<存储类型> <.
力扣HOT100 - 1143. 最长公共子序列
qq_61504864的博客
05-20 188
【代码】力扣HOT100 - 1143. 最长公共子序列。
力扣62 不同路径 Java版本
m0_47066863的博客
05-20 183
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 489
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
力扣HOT100 - 72. 编辑距离
最新发布
qq_61504864的博客
05-20 111
【代码】力扣HOT100 - 72. 编辑距离。
symbol.iterator
08-19
通过使用Symbol.iterator和迭代器对象，我们可以自定义对象的迭代逻辑，并使用for...of循环或展开操作符来进行迭代操作。因此，Symbol.iterator为我们提供了一种元编程行为，允许JavaScript的其他部分（如运算符和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值