编程语言
首页 > 编程语言> > 算法中的那些骚操作

算法中的那些骚操作

作者:互联网

算法中的那些骚操作

神奇的二进制

使用二进制解决过什么问题吗?

变量交换

x = x ^ y   // (1)
y = x ^ y   // (2)
x = x ^ y   // (3)

把(1)中的 x 代入 (2)中的 x,有

y = x^y = (x^y)^y = x^(y^y) = x^0 = x

x 的值成功赋给了 y。

对于(3),推导如下:

x = x^y = (x^y)^x = (x^x)^y = 0^y = y

最大、最小整数,掩码

一些算法题中, 会有"不能超过整数范围"的要求, 但是我们没法预知运行环境的总线长度

对于有符号整数:

//最大值:
INT_MAX = int(^uint(0) >> 1)
//最小值:
INT_MIN = ^INT_MAX

对于无符号整数:

//最大值:
INT_MAX = ^uint(0)
//最小值:
INT_MIN = 0

计算二进制中的1的个数

//核心是不停地抹去低位的1
func NumberOf1(n int) int {
	res := 0
	for n!=0 {
		res++
		n = (n - 1) & n

	}
	return res
}

乱序整型数组中找出没有重复的数

给你一组整型数据,这些数据中,其中有一个数只出现了一次,其他的数都出现了两次,让你来找出一个数 。

原理:

func Find(arr []int) int {
    var rs int
    for _,v := range arr{
        rs ^= v
    }
    return rs
}

大数据存储

案例, 双色球存储:

一注双色球格式:01,02,03,04,05,06|01(20个字符)

红区共33个号码可选, 蓝区共16个号码可选

要存储所有的组合:

C(33,6) * C(16, 1) = 1107568 * 16 = 17721088 注

存储共:17721088 * 20 = 300M

使用二进制存储:

共使用33个bit位记录33个红球和16个bit位记录16个红球, 一个整型存储就够了(64位系统), 存储可减少一半, 结合压缩, 会更低

场景:存储的数据可枚举

搞定递归

问题:容易套用平铺直叙的思维方式去推导计算机程序演进

递归的三大要素:

例:斐波那契数:1、1、2、3、5、8、13…, 求第n项的值

//明确你这个函数想要干什么:  f(n) 的功能是求第 n 项的值
func Fibonacci(n int) int {
    
}

//寻找递归结束条件
func Fibonacci(n int) int {
    if n <= 2{
        return 1
    }
}

//找出函数的等价关系式(递推公式)
//根据数列规则, 一个项的值是前两项之和
f(n)=f(n-1)+f(n-2)

func Fibonacci(n int) int {
    if n <= 2{
        return 1
    }
    return Fibonacci(n-1)+Fibonacci(n-2)
}

判断链表是否有环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cFLsTq1k-1615530141669)(http://note.youdao.com/yws/res/1798/630AE244FC83406D9C511A8ED3E0F34C)]

首先创建两个指针p1和p2,让它们同时 指向这个链表的头节点。然后开始一个大循环,在循环体中,让指针p1 每次向后移动1个节点,让指针p2每次向后移动2个节点,然后比较两个 指针指向的节点是否相同。如果相同,则可以判断出链表有环,如果不同,则继续下一次循环

追及问题:
在一个环形跑道上,两个运动员从同一地点起跑,一个运动员速度快, 另一个运动员速度慢。当两人跑了一段时间后,速度快的运动员必然会 再次追上并超过速度慢的运动员,原因很简单,因为跑道是环形的。

为什么快的指针步长是2?因为在快的追上慢的前, 必然是相差1或2步, 如果落后1, 下次一定能追上, 如果落后2, 那么下次一定是落后1, 再下一次就能追上

func hasCycle(head *ListNode) bool {
    fast, slow := head, head
    for fast != nil && fast.Next != nil {
        fast = fast.Next.Next
        slow = slow.Next
        if fast == slow {
            return true
        }
    }

    return false
}

组合计算

//输入
["a", "b", "c"]
//输出
["a", "b"]
["b", "c"]
["a", "c"]

例如求5中选3的组合:

1 1 1 0 0 //1,2,3
1 1 0 1 0 //1,2,4
1 0 1 1 0 //1,3,4
0 1 1 1 0 //2,3,4
1 1 0 0 1 //1,2,5
1 0 1 0 1 //1,3,5
0 1 1 0 1 //2,3,5
1 0 0 1 1 //1,4,5
0 1 0 1 1 //2,4,5
0 0 1 1 1 //3,4,5
for {
	find := false
	//每次循环将第一次出现的 1 0 改为 0 1,同时将左侧的1移动到最左侧
	for i := 0; i < n-1; i++ {
		if indexs[i] == 1 && indexs[i+1] == 0 {
			find = true
			indexs[i], indexs[i+1] = 0, 1
			if i > 1 {
				moveOneToLeft(indexs[:i])
			}
			result = addTo(result, indexs)
			break
		}
	}
	//本次循环没有找到 1 0 ,说明已经取到了最后一种情况
	if !find {
		break
	}
}

https://www.it610.com/article/4097023.htm

学习算法

标签:存储,int,fast,那些,INT,算法,func,indexs,操作
来源: https://blog.csdn.net/fengliye0311/article/details/114694807