代码段
Yii2怎么在ActivityRecorder中直接生成插入时间？
回复Yii框架 • zkbhj 回复了问题 • 1 人关注 • 1 个回复 • 4121 次浏览 • 2021-01-19 11:37
LeetCode刷题Day2：两数相加
LeetCode • zkbhj 发表了文章 • 0 个评论 • 2260 次浏览 • 2020-09-22 20:57
两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode
首先发一下我的思路已经给出的最初答案（大部分情况是正确的，但是超出数字范围就会和预期结果不一致），总之先把分析思路分享出来。
思路一：常规思路
分别循环两个链表，因为高位是个位，所以不断乘以10的n次方，n代表循环次数，从0开始，直到循环结束，就得到了两个无符号整数。所以，这就要求对输入数字有范围限制的要求，否则数字太大，超出整数的最大范围，得到的结果会因为发生溢出而不符合预期。
然后将两个整数进行加法运算，得到最终结果对应的int数字。
然后再将这个整数转化成字符串，循环字符串，得到字符对应的ASCII码点，然后减去48即可“间接“得到对应的数字。并按序生成链表。
func myPow(a,n int) int {
result := int(1)
for i:= n; i >0 ; i >>= 1 {
if i&1 != 0 {
result *=a
}
a *=a
}
return result
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
var a,b,c,i,j int
p1 := l1
for p1!= nil {
a = a + p1.Val * myPow(10,i)
i++
p1 = p1.Next
}
p2 := l2
for p2!= nil {
b = b + p2.Val * myPow(10,j)
j++
p2 = p2.Next
}
c = a + b
str := strconv.Itoa(c)
headNode := new(ListNode)
current := headNode
current.Next = nil
for _,one := range str {
preNode := current
current.Val = int(one-48)
current = new(ListNode)
current.Next = preNode
}
return current.Next
}
思路一：高级思路（学习）
对应位置的数字相加，跟10取模，即可得到该位置上十进制数相加之后的数字，然后和10进行整除，如果两个数相加小于10，则整除之后是0，否则是1，即要进位的1，所以直到两个链表都循环完，或者最后没有进位时，停止循环，最终返回。
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
headList := new(ListNode)
head := headList
num := 0
for (l1 != nil || l2 != nil || num > 0) {
headList.Next = new(ListNode)
headList = headList.Next
if l1 != nil {
num = num + l1.Val
l1 = l1.Next
}
if l2 != nil {
num = num + l2.Val
l2 = l2.Next
}
headList.Val = (num) % 10
num = num / 10
}
return head.Next
}
查看全部
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode
首先发一下我的思路已经给出的最初答案（大部分情况是正确的，但是超出数字范围就会和预期结果不一致），总之先把分析思路分享出来。
思路一：常规思路
分别循环两个链表，因为高位是个位，所以不断乘以10的n次方，n代表循环次数，从0开始，直到循环结束，就得到了两个无符号整数。所以，这就要求对输入数字有范围限制的要求，否则数字太大，超出整数的最大范围，得到的结果会因为发生溢出而不符合预期。
然后将两个整数进行加法运算，得到最终结果对应的int数字。
然后再将这个整数转化成字符串，循环字符串，得到字符对应的ASCII码点，然后减去48即可“间接“得到对应的数字。并按序生成链表。
func myPow(a,n int) int {
result := int(1)
for i:= n; i >0 ; i >>= 1 {
if i&1 != 0 {
result *=a
}
a *=a
}
return result
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
var a,b,c,i,j int
p1 := l1
for p1!= nil {
a = a + p1.Val * myPow(10,i)
i++
p1 = p1.Next
}
p2 := l2
for p2!= nil {
b = b + p2.Val * myPow(10,j)
j++
p2 = p2.Next
}
c = a + b
str := strconv.Itoa(c)
headNode := new(ListNode)
current := headNode
current.Next = nil
for _,one := range str {
preNode := current
current.Val = int(one-48)
current = new(ListNode)
current.Next = preNode
}
return current.Next
}
思路一：高级思路（学习）
对应位置的数字相加，跟10取模，即可得到该位置上十进制数相加之后的数字，然后和10进行整除，如果两个数相加小于10，则整除之后是0，否则是1，即要进位的1，所以直到两个链表都循环完，或者最后没有进位时，停止循环，最终返回。
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
headList := new(ListNode)
head := headList
num := 0
for (l1 != nil || l2 != nil || num > 0) {
headList.Next = new(ListNode)
headList = headList.Next
if l1 != nil {
num = num + l1.Val
l1 = l1.Next
}
if l2 != nil {
num = num + l2.Val
l2 = l2.Next
}
headList.Val = (num) % 10
num = num / 10
}
return head.Next
}
查看全部
两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode
首先发一下我的思路已经给出的最初答案（大部分情况是正确的，但是超出数字范围就会和预期结果不一致），总之先把分析思路分享出来。
思路一：常规思路
分别循环两个链表，因为高位是个位，所以不断乘以10的n次方，n代表循环次数，从0开始，直到循环结束，就得到了两个无符号整数。所以，这就要求对输入数字有范围限制的要求，否则数字太大，超出整数的最大范围，得到的结果会因为发生溢出而不符合预期。
然后将两个整数进行加法运算，得到最终结果对应的int数字。
然后再将这个整数转化成字符串，循环字符串，得到字符对应的ASCII码点，然后减去48即可“间接“得到对应的数字。并按序生成链表。
func myPow(a,n int) int {
result := int(1)
for i:= n; i >0 ; i >>= 1 {
if i&1 != 0 {
result *=a
}
a *=a
}
return result
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
var a,b,c,i,j int
p1 := l1
for p1!= nil {
a = a + p1.Val * myPow(10,i)
i++
p1 = p1.Next
}
p2 := l2
for p2!= nil {
b = b + p2.Val * myPow(10,j)
j++
p2 = p2.Next
}
c = a + b
str := strconv.Itoa(c)
headNode := new(ListNode)
current := headNode
current.Next = nil
for _,one := range str {
preNode := current
current.Val = int(one-48)
current = new(ListNode)
current.Next = preNode
}
return current.Next
}思路一：高级思路（学习）
对应位置的数字相加，跟10取模，即可得到该位置上十进制数相加之后的数字，然后和10进行整除，如果两个数相加小于10，则整除之后是0，否则是1，即要进位的1，所以直到两个链表都循环完，或者最后没有进位时，停止循环，最终返回。
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
headList := new(ListNode)
head := headList
num := 0
for (l1 != nil || l2 != nil || num > 0) {
headList.Next = new(ListNode)
headList = headList.Next
if l1 != nil {
num = num + l1.Val
l1 = l1.Next
}
if l2 != nil {
num = num + l2.Val
l2 = l2.Next
}
headList.Val = (num) % 10
num = num / 10
}
return head.Next
}
LeetCode刷题Day1：两数之和
LeetCode • zkbhj 发表了文章 • 0 个评论 • 2255 次浏览 • 2020-09-22 20:55
从今天开始，把LeetCode刷题作为每天日常计划的一项。尽早做准备，同时也每天对算法和相关的技能知识通过刷题的形式进行潜移默化的提升和加深理解。其实身边已经有很多程序猿朋友都在LeetCode刷题了，再不参与进来，都要出圈儿了呀。
今天是Day1，从第一道题目开始：
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
func twoSum(nums []int, target int) []int {
len := len(nums)
var x,y int
for i:=0; i < len && x|y == 0; i++ {
findNum := target - nums[i]
for j:=0; j < len; j++ {
if findNum == nums[j] {
x = i;
y = j;
}
}
}
return []int{x,y}
}
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
func twoSum(nums []int, target int) []int {
var hashMap map[int]int
len := len(nums)
var x,y,found int
//初始化字典
hashMap = make(map[int]int)
for i:=0; i < len; i++ {
hashMap[nums[i]] = i
}
for j:=0; j < len && found == 0; j++ {
findNum := target - nums[j]
v, ok := hashMap[findNum]
if ok && v != j {
found = 1
x = j
y = v
}
}
return []int{x,y}
}
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。 查看全部
今天是Day1，从第一道题目开始：
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
func twoSum(nums []int, target int) []int {
len := len(nums)
var x,y int
for i:=0; i < len && x|y == 0; i++ {
findNum := target - nums[i]
for j:=0; j < len; j++ {
if findNum == nums[j] {
x = i;
y = j;
}
}
}
return []int{x,y}
}
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
func twoSum(nums []int, target int) []int {
var hashMap map[int]int
len := len(nums)
var x,y,found int
//初始化字典
hashMap = make(map[int]int)
for i:=0; i < len; i++ {
hashMap[nums[i]] = i
}
for j:=0; j < len && found == 0; j++ {
findNum := target - nums[j]
v, ok := hashMap[findNum]
if ok && v != j {
found = 1
x = j
y = v
}
}
return []int{x,y}
}
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。 查看全部
从今天开始，把LeetCode刷题作为每天日常计划的一项。尽早做准备，同时也每天对算法和相关的技能知识通过刷题的形式进行潜移默化的提升和加深理解。其实身边已经有很多程序猿朋友都在LeetCode刷题了，再不参与进来，都要出圈儿了呀。
今天是Day1，从第一道题目开始：
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。
今天是Day1，从第一道题目开始：
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
func twoSum(nums []int, target int) []int {
len := len(nums)
var x,y int
for i:=0; i < len && x|y == 0; i++ {
findNum := target - nums[i]
for j:=0; j < len; j++ {
if findNum == nums[j] {
x = i;
y = j;
}
}
}
return []int{x,y}
}
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
func twoSum(nums []int, target int) []int {
var hashMap map[int]int
len := len(nums)
var x,y,found int
//初始化字典
hashMap = make(map[int]int)
for i:=0; i < len; i++ {
hashMap[nums[i]] = i
}
for j:=0; j < len && found == 0; j++ {
findNum := target - nums[j]
v, ok := hashMap[findNum]
if ok && v != j {
found = 1
x = j
y = v
}
}
return []int{x,y}
}
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。
#面试题集锦#实现单链表反转
面试 • zkbhj 发表了文章 • 0 个评论 • 2477 次浏览 • 2020-08-14 17:16
反转一个链表
示例：输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
结构体定义struct ListNode {
int val;
struct ListNode *next;
};
思路一
先对原链表做头删操作，再对新链表做头插
定义一个新head头指针，标记为newHead，将它初始为NULL，并非指向NULL，最后我们选择返回这个newHead指针作为新链表的头指针。
定义一个结点node作为"临时中转站"，初始化与否并无大影响。进行循环遍历链表各个结点，判定head指针是否为空，即是否到达了原链表的结尾。如果不为空，说明还没有到达尾部。如果程序第一次运行就没有进入循环，说明传入了一个空链表，此时返回newHead新链表的头指针，同样返回NULL，这样处理也是合理的。以下开始逆序链表逻辑：在当前指针不为NULL时，先对原链表做头删操作，再对新链表做头插操作。即使用循环进行操作：让node指针指向传入函数链表的头指针head，两指针指向保持相同。然后让head指针指向它的next结点，此时旧链表已经完成了头删操作。第一个结点已经被"切割"下来。接下来要做的就是对新链表进行头插操作，使结点放入新链表。让node指针的next下一个结点指向新链表的头指针newHead，完成结点的链接，即头插入新的链表中。然后更新newHead指向为新链表的头结点。进行下一次循环。最终head指针指向了原链表的结尾，即为NULL，退出循环，此时新链表已经反转完毕，情况如图：最终返回新链表头指针newHead即可。
struct ListNode *reverseList(struct ListNode* head) {
struct ListNode *newHead = NULL;
struct ListNode *node;
while (head != NULL) {
//1. 对之前的链表做头删
node = head;
head = head->next;
//2. 对新链表做头插
node->next = newHead;
newHead = node;
}
return newHead;
}
思路二
利用选择语句，找到空链表的情况，此情况返回NULL空指针，因为空链表不能反转，或者说反转之后还是一个空链表，返回空。利用三个指针p0"前指针"、p1“当前指针”、p2"后指针"来分批处理链表元素，p0置为NULL，它将作为链表的尾结点向前推进处理，p1指向旧链表的头指针head，p2指向旧链表的头指针的next结点。开始遍历链表，循环判定因子为p1，当它为空时到达链表尾部跳出循环。否则在表中执行循环内逻辑：将p1指向的当前结点的下一个结点指向p0，即前一个结点。此时p0为NULL，那么p1的下一个结点就为空了，它现在是最后一个结点。然后将p0指针指向p1，将p1指针指向p2，注意这两步不可以调换顺序，否则正确向后挪移一位。此时完成了三个指针的一轮更迭。判定p2指针是否为空，如果为空说明此时p2到达了链表结尾，当前指针p1的指向为最后一个结点，它的next即为空。如果不为空，将p2更新到下一个结点，进行下一次循环。下一次进行循环时，就会把截断结点链接到新链表的头部，同时更新三个指针。继续循环。循环终止条件为：p1指向了链表尾部的NULL，此时p1的前指针p0即指向了反转后的链表，它就是新链表的head头指针。此时返回p0即可。
struct ListNode *reverseList(struct ListNode* head) {
if (head == NULL) {
return NULL;
}
struct ListNode *p0 = NULL;
struct ListNode *p1 = head;
struct ListNode *p2 = head->next;
while (p1 != NULL) {
p1->next = p0;
p0 = p1;
p1 = p2;
if (p2 != NULL) {
p2 = p2->next;
}
}
return p0;
}
参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
查看全部
示例：输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
结构体定义struct ListNode {
int val;
struct ListNode *next;
};
思路一
先对原链表做头删操作，再对新链表做头插
定义一个新head头指针，标记为newHead，将它初始为NULL，并非指向NULL，最后我们选择返回这个newHead指针作为新链表的头指针。
定义一个结点node作为"临时中转站"，初始化与否并无大影响。进行循环遍历链表各个结点，判定head指针是否为空，即是否到达了原链表的结尾。如果不为空，说明还没有到达尾部。如果程序第一次运行就没有进入循环，说明传入了一个空链表，此时返回newHead新链表的头指针，同样返回NULL，这样处理也是合理的。以下开始逆序链表逻辑：在当前指针不为NULL时，先对原链表做头删操作，再对新链表做头插操作。即使用循环进行操作：让node指针指向传入函数链表的头指针head，两指针指向保持相同。然后让head指针指向它的next结点，此时旧链表已经完成了头删操作。第一个结点已经被"切割"下来。接下来要做的就是对新链表进行头插操作，使结点放入新链表。让node指针的next下一个结点指向新链表的头指针newHead，完成结点的链接，即头插入新的链表中。然后更新newHead指向为新链表的头结点。进行下一次循环。最终head指针指向了原链表的结尾，即为NULL，退出循环，此时新链表已经反转完毕，情况如图：最终返回新链表头指针newHead即可。
struct ListNode *reverseList(struct ListNode* head) {
struct ListNode *newHead = NULL;
struct ListNode *node;
while (head != NULL) {
//1. 对之前的链表做头删
node = head;
head = head->next;
//2. 对新链表做头插
node->next = newHead;
newHead = node;
}
return newHead;
}
思路二
利用选择语句，找到空链表的情况，此情况返回NULL空指针，因为空链表不能反转，或者说反转之后还是一个空链表，返回空。利用三个指针p0"前指针"、p1“当前指针”、p2"后指针"来分批处理链表元素，p0置为NULL，它将作为链表的尾结点向前推进处理，p1指向旧链表的头指针head，p2指向旧链表的头指针的next结点。开始遍历链表，循环判定因子为p1，当它为空时到达链表尾部跳出循环。否则在表中执行循环内逻辑：将p1指向的当前结点的下一个结点指向p0，即前一个结点。此时p0为NULL，那么p1的下一个结点就为空了，它现在是最后一个结点。然后将p0指针指向p1，将p1指针指向p2，注意这两步不可以调换顺序，否则正确向后挪移一位。此时完成了三个指针的一轮更迭。判定p2指针是否为空，如果为空说明此时p2到达了链表结尾，当前指针p1的指向为最后一个结点，它的next即为空。如果不为空，将p2更新到下一个结点，进行下一次循环。下一次进行循环时，就会把截断结点链接到新链表的头部，同时更新三个指针。继续循环。循环终止条件为：p1指向了链表尾部的NULL，此时p1的前指针p0即指向了反转后的链表，它就是新链表的head头指针。此时返回p0即可。
struct ListNode *reverseList(struct ListNode* head) {
if (head == NULL) {
return NULL;
}
struct ListNode *p0 = NULL;
struct ListNode *p1 = head;
struct ListNode *p2 = head->next;
while (p1 != NULL) {
p1->next = p0;
p0 = p1;
p1 = p2;
if (p2 != NULL) {
p2 = p2->next;
}
}
return p0;
}
参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
查看全部
反转一个链表
示例：
结构体定义
思路一
先对原链表做头删操作，再对新链表做头插
思路二
参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
示例：
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
结构体定义
struct ListNode {
int val;
struct ListNode *next;
};
思路一
先对原链表做头删操作，再对新链表做头插
- 定义一个新head头指针，标记为newHead，将它初始为NULL，并非指向NULL，最后我们选择返回这个newHead指针作为新链表的头指针。
- 定义一个结点node作为"临时中转站"，初始化与否并无大影响。
- 进行循环遍历链表各个结点，判定head指针是否为空，即是否到达了原链表的结尾。如果不为空，说明还没有到达尾部。如果程序第一次运行就没有进入循环，说明传入了一个空链表，此时返回newHead新链表的头指针，同样返回NULL，这样处理也是合理的。
- 以下开始逆序链表逻辑：在当前指针不为NULL时，先对原链表做头删操作，再对新链表做头插操作。即使用循环进行操作：
- 让node指针指向传入函数链表的头指针head，两指针指向保持相同。
- 然后让head指针指向它的next结点，此时旧链表已经完成了头删操作。第一个结点已经被"切割"下来。接下来要做的就是对新链表进行头插操作，使结点放入新链表。
- 让node指针的next下一个结点指向新链表的头指针newHead，完成结点的链接，即头插入新的链表中。然后更新newHead指向为新链表的头结点。进行下一次循环。
- 最终head指针指向了原链表的结尾，即为NULL，退出循环，此时新链表已经反转完毕，情况如图：
- 最终返回新链表头指针newHead即可。
struct ListNode *reverseList(struct ListNode* head) {
struct ListNode *newHead = NULL;
struct ListNode *node;
while (head != NULL) {
//1. 对之前的链表做头删
node = head;
head = head->next;
//2. 对新链表做头插
node->next = newHead;
newHead = node;
}
return newHead;
}思路二
- 利用选择语句，找到空链表的情况，此情况返回NULL空指针，因为空链表不能反转，或者说反转之后还是一个空链表，返回空。
- 利用三个指针p0"前指针"、p1“当前指针”、p2"后指针"来分批处理链表元素，p0置为NULL，它将作为链表的尾结点向前推进处理，p1指向旧链表的头指针head，p2指向旧链表的头指针的next结点。
- 开始遍历链表，循环判定因子为p1，当它为空时到达链表尾部跳出循环。否则在表中执行循环内逻辑：将p1指向的当前结点的下一个结点指向p0，即前一个结点。此时p0为NULL，那么p1的下一个结点就为空了，它现在是最后一个结点。
- 然后将p0指针指向p1，将p1指针指向p2，注意这两步不可以调换顺序，否则正确向后挪移一位。此时完成了三个指针的一轮更迭。
- 判定p2指针是否为空，如果为空说明此时p2到达了链表结尾，当前指针p1的指向为最后一个结点，它的next即为空。如果不为空，将p2更新到下一个结点，进行下一次循环。
- 下一次进行循环时，就会把截断结点链接到新链表的头部，同时更新三个指针。继续循环。
- 循环终止条件为：p1指向了链表尾部的NULL，此时p1的前指针p0即指向了反转后的链表，它就是新链表的head头指针。此时返回p0即可。
struct ListNode *reverseList(struct ListNode* head) {
if (head == NULL) {
return NULL;
}
struct ListNode *p0 = NULL;
struct ListNode *p1 = head;
struct ListNode *p2 = head->next;
while (p1 != NULL) {
p1->next = p0;
p0 = p1;
p1 = p2;
if (p2 != NULL) {
p2 = p2->next;
}
}
return p0;
}参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
前端优秀代码片段
前端开发 • zkbhj 发表了文章 • 0 个评论 • 2985 次浏览 • 2016-09-19 15:38
//购物车控制显示
$("#head_car").hover(function(){
$(this).css("background", "#FBFEE9");
$(".head_car_text").css("color", "#ff6700");
$("#car_content").css({"width":"300px"}).animate({
height:"100px"
},400).finish();
},function(){
$(this).css("background", "#424242");
$(".head_car_text").css("color", "#b0b0b0");
$("#car_content").css({"width":"300px"}).animate({
height:"0px"
},400);
})
//导航栏控制显示
$(".menu_li").hover(function(){
$("#menu_content_bg").css("border","1px solid #D0D0D0");
$(this).css("color","#ff6700");
$("#"+$(this).attr("control")).show();
$("#menu_content_bg").height(230);
},function(){
$("#"+$(this).attr("control")).hide();
$(this).css("color"," #424242");
$("#menu_content_bg").height(0);
$("#menu_content_bg").css("border","0px solid #D0D0D0");
})
//搜索框失去和获取焦点border颜色改变
$("#find_input").focus(function(){
$("#find_wrap").css("border","1px solid #ff6700");
$("#find_but").css("border-left","1px solid #ff6700");
})
$("#find_input").blur(function(){
$("#find_wrap").css("border","1px solid #F0F0F0");
$("#find_but").css("border-left","1px solid #F0F0F0");
})
//搜索按钮的背景颜色改变
$("#find_but").hover(function(){
$(this).css({"background":"#ff6700",color:"#fff"});
},function(){
$(this).css({"background":"#fff",color:"#424242"});
})
//菜单栏的显示
$("#banner_menu_wrap").children().hover(function(){
$(this).css("background","#ff6700");
$(this).children(".banner_menu_content").css("border","1px solid #F0F0F0").show();
},function(){
$(this).css("background","none");
$(this).children(".banner_menu_content").css("border","0px solid #F0F0F0").hide();
}) 查看全部
$("#head_car").hover(function(){
$(this).css("background", "#FBFEE9");
$(".head_car_text").css("color", "#ff6700");
$("#car_content").css({"width":"300px"}).animate({
height:"100px"
},400).finish();
},function(){
$(this).css("background", "#424242");
$(".head_car_text").css("color", "#b0b0b0");
$("#car_content").css({"width":"300px"}).animate({
height:"0px"
},400);
})
//导航栏控制显示
$(".menu_li").hover(function(){
$("#menu_content_bg").css("border","1px solid #D0D0D0");
$(this).css("color","#ff6700");
$("#"+$(this).attr("control")).show();
$("#menu_content_bg").height(230);
},function(){
$("#"+$(this).attr("control")).hide();
$(this).css("color"," #424242");
$("#menu_content_bg").height(0);
$("#menu_content_bg").css("border","0px solid #D0D0D0");
})
//搜索框失去和获取焦点border颜色改变
$("#find_input").focus(function(){
$("#find_wrap").css("border","1px solid #ff6700");
$("#find_but").css("border-left","1px solid #ff6700");
})
$("#find_input").blur(function(){
$("#find_wrap").css("border","1px solid #F0F0F0");
$("#find_but").css("border-left","1px solid #F0F0F0");
})
//搜索按钮的背景颜色改变
$("#find_but").hover(function(){
$(this).css({"background":"#ff6700",color:"#fff"});
},function(){
$(this).css({"background":"#fff",color:"#424242"});
})
//菜单栏的显示
$("#banner_menu_wrap").children().hover(function(){
$(this).css("background","#ff6700");
$(this).children(".banner_menu_content").css("border","1px solid #F0F0F0").show();
},function(){
$(this).css("background","none");
$(this).children(".banner_menu_content").css("border","0px solid #F0F0F0").hide();
}) 查看全部
//购物车控制显示
$("#head_car").hover(function(){
$(this).css("background", "#FBFEE9");
$(".head_car_text").css("color", "#ff6700");
$("#car_content").css({"width":"300px"}).animate({
height:"100px"
},400).finish();
},function(){
$(this).css("background", "#424242");
$(".head_car_text").css("color", "#b0b0b0");
$("#car_content").css({"width":"300px"}).animate({
height:"0px"
},400);
})
//导航栏控制显示
$(".menu_li").hover(function(){
$("#menu_content_bg").css("border","1px solid #D0D0D0");
$(this).css("color","#ff6700");
$("#"+$(this).attr("control")).show();
$("#menu_content_bg").height(230);
},function(){
$("#"+$(this).attr("control")).hide();
$(this).css("color"," #424242");
$("#menu_content_bg").height(0);
$("#menu_content_bg").css("border","0px solid #D0D0D0");
})
//搜索框失去和获取焦点border颜色改变
$("#find_input").focus(function(){
$("#find_wrap").css("border","1px solid #ff6700");
$("#find_but").css("border-left","1px solid #ff6700");
})
$("#find_input").blur(function(){
$("#find_wrap").css("border","1px solid #F0F0F0");
$("#find_but").css("border-left","1px solid #F0F0F0");
})
//搜索按钮的背景颜色改变
$("#find_but").hover(function(){
$(this).css({"background":"#ff6700",color:"#fff"});
},function(){
$(this).css({"background":"#fff",color:"#424242"});
})
//菜单栏的显示
$("#banner_menu_wrap").children().hover(function(){
$(this).css("background","#ff6700");
$(this).children(".banner_menu_content").css("border","1px solid #F0F0F0").show();
},function(){
$(this).css("background","none");
$(this).children(".banner_menu_content").css("border","0px solid #F0F0F0").hide();
})
Yii2怎么在ActivityRecorder中直接生成插入时间？
回复Yii框架 • zkbhj 回复了问题 • 1 人关注 • 1 个回复 • 4121 次浏览 • 2021-01-19 11:37
LeetCode刷题Day2：两数相加
LeetCode • zkbhj 发表了文章 • 0 个评论 • 2260 次浏览 • 2020-09-22 20:57
两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode
首先发一下我的思路已经给出的最初答案（大部分情况是正确的，但是超出数字范围就会和预期结果不一致），总之先把分析思路分享出来。
思路一：常规思路
分别循环两个链表，因为高位是个位，所以不断乘以10的n次方，n代表循环次数，从0开始，直到循环结束，就得到了两个无符号整数。所以，这就要求对输入数字有范围限制的要求，否则数字太大，超出整数的最大范围，得到的结果会因为发生溢出而不符合预期。
然后将两个整数进行加法运算，得到最终结果对应的int数字。
然后再将这个整数转化成字符串，循环字符串，得到字符对应的ASCII码点，然后减去48即可“间接“得到对应的数字。并按序生成链表。
func myPow(a,n int) int {
result := int(1)
for i:= n; i >0 ; i >>= 1 {
if i&1 != 0 {
result *=a
}
a *=a
}
return result
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
var a,b,c,i,j int
p1 := l1
for p1!= nil {
a = a + p1.Val * myPow(10,i)
i++
p1 = p1.Next
}
p2 := l2
for p2!= nil {
b = b + p2.Val * myPow(10,j)
j++
p2 = p2.Next
}
c = a + b
str := strconv.Itoa(c)
headNode := new(ListNode)
current := headNode
current.Next = nil
for _,one := range str {
preNode := current
current.Val = int(one-48)
current = new(ListNode)
current.Next = preNode
}
return current.Next
}
思路一：高级思路（学习）
对应位置的数字相加，跟10取模，即可得到该位置上十进制数相加之后的数字，然后和10进行整除，如果两个数相加小于10，则整除之后是0，否则是1，即要进位的1，所以直到两个链表都循环完，或者最后没有进位时，停止循环，最终返回。
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
headList := new(ListNode)
head := headList
num := 0
for (l1 != nil || l2 != nil || num > 0) {
headList.Next = new(ListNode)
headList = headList.Next
if l1 != nil {
num = num + l1.Val
l1 = l1.Next
}
if l2 != nil {
num = num + l2.Val
l2 = l2.Next
}
headList.Val = (num) % 10
num = num / 10
}
return head.Next
}
查看全部
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode
首先发一下我的思路已经给出的最初答案（大部分情况是正确的，但是超出数字范围就会和预期结果不一致），总之先把分析思路分享出来。
思路一：常规思路
分别循环两个链表，因为高位是个位，所以不断乘以10的n次方，n代表循环次数，从0开始，直到循环结束，就得到了两个无符号整数。所以，这就要求对输入数字有范围限制的要求，否则数字太大，超出整数的最大范围，得到的结果会因为发生溢出而不符合预期。
然后将两个整数进行加法运算，得到最终结果对应的int数字。
然后再将这个整数转化成字符串，循环字符串，得到字符对应的ASCII码点，然后减去48即可“间接“得到对应的数字。并按序生成链表。
func myPow(a,n int) int {
result := int(1)
for i:= n; i >0 ; i >>= 1 {
if i&1 != 0 {
result *=a
}
a *=a
}
return result
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
var a,b,c,i,j int
p1 := l1
for p1!= nil {
a = a + p1.Val * myPow(10,i)
i++
p1 = p1.Next
}
p2 := l2
for p2!= nil {
b = b + p2.Val * myPow(10,j)
j++
p2 = p2.Next
}
c = a + b
str := strconv.Itoa(c)
headNode := new(ListNode)
current := headNode
current.Next = nil
for _,one := range str {
preNode := current
current.Val = int(one-48)
current = new(ListNode)
current.Next = preNode
}
return current.Next
}
思路一：高级思路（学习）
对应位置的数字相加，跟10取模，即可得到该位置上十进制数相加之后的数字，然后和10进行整除，如果两个数相加小于10，则整除之后是0，否则是1，即要进位的1，所以直到两个链表都循环完，或者最后没有进位时，停止循环，最终返回。
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
headList := new(ListNode)
head := headList
num := 0
for (l1 != nil || l2 != nil || num > 0) {
headList.Next = new(ListNode)
headList = headList.Next
if l1 != nil {
num = num + l1.Val
l1 = l1.Next
}
if l2 != nil {
num = num + l2.Val
l2 = l2.Next
}
headList.Val = (num) % 10
num = num / 10
}
return head.Next
}
查看全部
两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode
首先发一下我的思路已经给出的最初答案（大部分情况是正确的，但是超出数字范围就会和预期结果不一致），总之先把分析思路分享出来。
思路一：常规思路
分别循环两个链表，因为高位是个位，所以不断乘以10的n次方，n代表循环次数，从0开始，直到循环结束，就得到了两个无符号整数。所以，这就要求对输入数字有范围限制的要求，否则数字太大，超出整数的最大范围，得到的结果会因为发生溢出而不符合预期。
然后将两个整数进行加法运算，得到最终结果对应的int数字。
然后再将这个整数转化成字符串，循环字符串，得到字符对应的ASCII码点，然后减去48即可“间接“得到对应的数字。并按序生成链表。
func myPow(a,n int) int {
result := int(1)
for i:= n; i >0 ; i >>= 1 {
if i&1 != 0 {
result *=a
}
a *=a
}
return result
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
var a,b,c,i,j int
p1 := l1
for p1!= nil {
a = a + p1.Val * myPow(10,i)
i++
p1 = p1.Next
}
p2 := l2
for p2!= nil {
b = b + p2.Val * myPow(10,j)
j++
p2 = p2.Next
}
c = a + b
str := strconv.Itoa(c)
headNode := new(ListNode)
current := headNode
current.Next = nil
for _,one := range str {
preNode := current
current.Val = int(one-48)
current = new(ListNode)
current.Next = preNode
}
return current.Next
}思路一：高级思路（学习）
对应位置的数字相加，跟10取模，即可得到该位置上十进制数相加之后的数字，然后和10进行整除，如果两个数相加小于10，则整除之后是0，否则是1，即要进位的1，所以直到两个链表都循环完，或者最后没有进位时，停止循环，最终返回。
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
headList := new(ListNode)
head := headList
num := 0
for (l1 != nil || l2 != nil || num > 0) {
headList.Next = new(ListNode)
headList = headList.Next
if l1 != nil {
num = num + l1.Val
l1 = l1.Next
}
if l2 != nil {
num = num + l2.Val
l2 = l2.Next
}
headList.Val = (num) % 10
num = num / 10
}
return head.Next
}
LeetCode刷题Day1：两数之和
LeetCode • zkbhj 发表了文章 • 0 个评论 • 2255 次浏览 • 2020-09-22 20:55
从今天开始，把LeetCode刷题作为每天日常计划的一项。尽早做准备，同时也每天对算法和相关的技能知识通过刷题的形式进行潜移默化的提升和加深理解。其实身边已经有很多程序猿朋友都在LeetCode刷题了，再不参与进来，都要出圈儿了呀。
今天是Day1，从第一道题目开始：
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
func twoSum(nums []int, target int) []int {
len := len(nums)
var x,y int
for i:=0; i < len && x|y == 0; i++ {
findNum := target - nums[i]
for j:=0; j < len; j++ {
if findNum == nums[j] {
x = i;
y = j;
}
}
}
return []int{x,y}
}
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
func twoSum(nums []int, target int) []int {
var hashMap map[int]int
len := len(nums)
var x,y,found int
//初始化字典
hashMap = make(map[int]int)
for i:=0; i < len; i++ {
hashMap[nums[i]] = i
}
for j:=0; j < len && found == 0; j++ {
findNum := target - nums[j]
v, ok := hashMap[findNum]
if ok && v != j {
found = 1
x = j
y = v
}
}
return []int{x,y}
}
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。 查看全部
今天是Day1，从第一道题目开始：
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
func twoSum(nums []int, target int) []int {
len := len(nums)
var x,y int
for i:=0; i < len && x|y == 0; i++ {
findNum := target - nums[i]
for j:=0; j < len; j++ {
if findNum == nums[j] {
x = i;
y = j;
}
}
}
return []int{x,y}
}
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
func twoSum(nums []int, target int) []int {
var hashMap map[int]int
len := len(nums)
var x,y,found int
//初始化字典
hashMap = make(map[int]int)
for i:=0; i < len; i++ {
hashMap[nums[i]] = i
}
for j:=0; j < len && found == 0; j++ {
findNum := target - nums[j]
v, ok := hashMap[findNum]
if ok && v != j {
found = 1
x = j
y = v
}
}
return []int{x,y}
}
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。 查看全部
从今天开始，把LeetCode刷题作为每天日常计划的一项。尽早做准备，同时也每天对算法和相关的技能知识通过刷题的形式进行潜移默化的提升和加深理解。其实身边已经有很多程序猿朋友都在LeetCode刷题了，再不参与进来，都要出圈儿了呀。
今天是Day1，从第一道题目开始：
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。
今天是Day1，从第一道题目开始：
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
思路一：暴力遍历
也是最简单最原始的未经优化的方案思路。
首先明确题目要求，可以假设每种输入只会对应一个答案，即一定会有且只有一对符合要求的数据。
所以得到数组的长度，然后从第一个开始进行循环，将目标值target减去当前被循环的值，得到与之可以配对的值，然后在数组中进行寻找，如果找到，就返回2个符合要求的值的索引，否则继续下一次寻找，直到找到。
最外层循环的条件中 x&y异或之后如果为1，说明已经找到对应的结果，就不再循环。时间复杂度是O(n²)，空间复杂度是O(1)。
func twoSum(nums []int, target int) []int {
len := len(nums)
var x,y int
for i:=0; i < len && x|y == 0; i++ {
findNum := target - nums[i]
for j:=0; j < len; j++ {
if findNum == nums[j] {
x = i;
y = j;
}
}
}
return []int{x,y}
}
思路二：进一步提升效率，可以利用哈希表
从第一个思路中，可以看到其实在判断一个值在一个“表”中是否存在的时候，我们采用了遍历的方式，这样的话时间复杂度就是O(n)，但是大家肯定都知道，哈希表是最擅长做这个事情的。它可以把时间复杂度降到O(1)。所以，这样思路就很清晰了，我们需要先把传过来的数组生成对应的哈希结构，也就是Go里面的map字典，这样我们就可以快速的找到某值在还是不在了。我们把数组的value作为map的key，index作为map的value。代码实现如下。
func twoSum(nums []int, target int) []int {
var hashMap map[int]int
len := len(nums)
var x,y,found int
//初始化字典
hashMap = make(map[int]int)
for i:=0; i < len; i++ {
hashMap[nums[i]] = i
}
for j:=0; j < len && found == 0; j++ {
findNum := target - nums[j]
v, ok := hashMap[findNum]
if ok && v != j {
found = 1
x = j
y = v
}
}
return []int{x,y}
}
今天这道题的难度级别是简单，但是带我回顾了Go语言的数组、map的相关知识和用法，以及哈希表这一知识点。
#面试题集锦#实现单链表反转
面试 • zkbhj 发表了文章 • 0 个评论 • 2477 次浏览 • 2020-08-14 17:16
反转一个链表
示例：输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
结构体定义struct ListNode {
int val;
struct ListNode *next;
};
思路一
先对原链表做头删操作，再对新链表做头插
定义一个新head头指针，标记为newHead，将它初始为NULL，并非指向NULL，最后我们选择返回这个newHead指针作为新链表的头指针。
定义一个结点node作为"临时中转站"，初始化与否并无大影响。进行循环遍历链表各个结点，判定head指针是否为空，即是否到达了原链表的结尾。如果不为空，说明还没有到达尾部。如果程序第一次运行就没有进入循环，说明传入了一个空链表，此时返回newHead新链表的头指针，同样返回NULL，这样处理也是合理的。以下开始逆序链表逻辑：在当前指针不为NULL时，先对原链表做头删操作，再对新链表做头插操作。即使用循环进行操作：让node指针指向传入函数链表的头指针head，两指针指向保持相同。然后让head指针指向它的next结点，此时旧链表已经完成了头删操作。第一个结点已经被"切割"下来。接下来要做的就是对新链表进行头插操作，使结点放入新链表。让node指针的next下一个结点指向新链表的头指针newHead，完成结点的链接，即头插入新的链表中。然后更新newHead指向为新链表的头结点。进行下一次循环。最终head指针指向了原链表的结尾，即为NULL，退出循环，此时新链表已经反转完毕，情况如图：最终返回新链表头指针newHead即可。
struct ListNode *reverseList(struct ListNode* head) {
struct ListNode *newHead = NULL;
struct ListNode *node;
while (head != NULL) {
//1. 对之前的链表做头删
node = head;
head = head->next;
//2. 对新链表做头插
node->next = newHead;
newHead = node;
}
return newHead;
}
思路二
利用选择语句，找到空链表的情况，此情况返回NULL空指针，因为空链表不能反转，或者说反转之后还是一个空链表，返回空。利用三个指针p0"前指针"、p1“当前指针”、p2"后指针"来分批处理链表元素，p0置为NULL，它将作为链表的尾结点向前推进处理，p1指向旧链表的头指针head，p2指向旧链表的头指针的next结点。开始遍历链表，循环判定因子为p1，当它为空时到达链表尾部跳出循环。否则在表中执行循环内逻辑：将p1指向的当前结点的下一个结点指向p0，即前一个结点。此时p0为NULL，那么p1的下一个结点就为空了，它现在是最后一个结点。然后将p0指针指向p1，将p1指针指向p2，注意这两步不可以调换顺序，否则正确向后挪移一位。此时完成了三个指针的一轮更迭。判定p2指针是否为空，如果为空说明此时p2到达了链表结尾，当前指针p1的指向为最后一个结点，它的next即为空。如果不为空，将p2更新到下一个结点，进行下一次循环。下一次进行循环时，就会把截断结点链接到新链表的头部，同时更新三个指针。继续循环。循环终止条件为：p1指向了链表尾部的NULL，此时p1的前指针p0即指向了反转后的链表，它就是新链表的head头指针。此时返回p0即可。
struct ListNode *reverseList(struct ListNode* head) {
if (head == NULL) {
return NULL;
}
struct ListNode *p0 = NULL;
struct ListNode *p1 = head;
struct ListNode *p2 = head->next;
while (p1 != NULL) {
p1->next = p0;
p0 = p1;
p1 = p2;
if (p2 != NULL) {
p2 = p2->next;
}
}
return p0;
}
参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
查看全部
示例：输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
结构体定义struct ListNode {
int val;
struct ListNode *next;
};
思路一
先对原链表做头删操作，再对新链表做头插
定义一个新head头指针，标记为newHead，将它初始为NULL，并非指向NULL，最后我们选择返回这个newHead指针作为新链表的头指针。
定义一个结点node作为"临时中转站"，初始化与否并无大影响。进行循环遍历链表各个结点，判定head指针是否为空，即是否到达了原链表的结尾。如果不为空，说明还没有到达尾部。如果程序第一次运行就没有进入循环，说明传入了一个空链表，此时返回newHead新链表的头指针，同样返回NULL，这样处理也是合理的。以下开始逆序链表逻辑：在当前指针不为NULL时，先对原链表做头删操作，再对新链表做头插操作。即使用循环进行操作：让node指针指向传入函数链表的头指针head，两指针指向保持相同。然后让head指针指向它的next结点，此时旧链表已经完成了头删操作。第一个结点已经被"切割"下来。接下来要做的就是对新链表进行头插操作，使结点放入新链表。让node指针的next下一个结点指向新链表的头指针newHead，完成结点的链接，即头插入新的链表中。然后更新newHead指向为新链表的头结点。进行下一次循环。最终head指针指向了原链表的结尾，即为NULL，退出循环，此时新链表已经反转完毕，情况如图：最终返回新链表头指针newHead即可。
struct ListNode *reverseList(struct ListNode* head) {
struct ListNode *newHead = NULL;
struct ListNode *node;
while (head != NULL) {
//1. 对之前的链表做头删
node = head;
head = head->next;
//2. 对新链表做头插
node->next = newHead;
newHead = node;
}
return newHead;
}
思路二
利用选择语句，找到空链表的情况，此情况返回NULL空指针，因为空链表不能反转，或者说反转之后还是一个空链表，返回空。利用三个指针p0"前指针"、p1“当前指针”、p2"后指针"来分批处理链表元素，p0置为NULL，它将作为链表的尾结点向前推进处理，p1指向旧链表的头指针head，p2指向旧链表的头指针的next结点。开始遍历链表，循环判定因子为p1，当它为空时到达链表尾部跳出循环。否则在表中执行循环内逻辑：将p1指向的当前结点的下一个结点指向p0，即前一个结点。此时p0为NULL，那么p1的下一个结点就为空了，它现在是最后一个结点。然后将p0指针指向p1，将p1指针指向p2，注意这两步不可以调换顺序，否则正确向后挪移一位。此时完成了三个指针的一轮更迭。判定p2指针是否为空，如果为空说明此时p2到达了链表结尾，当前指针p1的指向为最后一个结点，它的next即为空。如果不为空，将p2更新到下一个结点，进行下一次循环。下一次进行循环时，就会把截断结点链接到新链表的头部，同时更新三个指针。继续循环。循环终止条件为：p1指向了链表尾部的NULL，此时p1的前指针p0即指向了反转后的链表，它就是新链表的head头指针。此时返回p0即可。
struct ListNode *reverseList(struct ListNode* head) {
if (head == NULL) {
return NULL;
}
struct ListNode *p0 = NULL;
struct ListNode *p1 = head;
struct ListNode *p2 = head->next;
while (p1 != NULL) {
p1->next = p0;
p0 = p1;
p1 = p2;
if (p2 != NULL) {
p2 = p2->next;
}
}
return p0;
}
参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
查看全部
反转一个链表
示例：
结构体定义
思路一
先对原链表做头删操作，再对新链表做头插
思路二
参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
示例：
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
结构体定义
struct ListNode {
int val;
struct ListNode *next;
};
思路一
先对原链表做头删操作，再对新链表做头插
- 定义一个新head头指针，标记为newHead，将它初始为NULL，并非指向NULL，最后我们选择返回这个newHead指针作为新链表的头指针。
- 定义一个结点node作为"临时中转站"，初始化与否并无大影响。
- 进行循环遍历链表各个结点，判定head指针是否为空，即是否到达了原链表的结尾。如果不为空，说明还没有到达尾部。如果程序第一次运行就没有进入循环，说明传入了一个空链表，此时返回newHead新链表的头指针，同样返回NULL，这样处理也是合理的。
- 以下开始逆序链表逻辑：在当前指针不为NULL时，先对原链表做头删操作，再对新链表做头插操作。即使用循环进行操作：
- 让node指针指向传入函数链表的头指针head，两指针指向保持相同。
- 然后让head指针指向它的next结点，此时旧链表已经完成了头删操作。第一个结点已经被"切割"下来。接下来要做的就是对新链表进行头插操作，使结点放入新链表。
- 让node指针的next下一个结点指向新链表的头指针newHead，完成结点的链接，即头插入新的链表中。然后更新newHead指向为新链表的头结点。进行下一次循环。
- 最终head指针指向了原链表的结尾，即为NULL，退出循环，此时新链表已经反转完毕，情况如图：
- 最终返回新链表头指针newHead即可。
struct ListNode *reverseList(struct ListNode* head) {
struct ListNode *newHead = NULL;
struct ListNode *node;
while (head != NULL) {
//1. 对之前的链表做头删
node = head;
head = head->next;
//2. 对新链表做头插
node->next = newHead;
newHead = node;
}
return newHead;
}思路二
- 利用选择语句，找到空链表的情况，此情况返回NULL空指针，因为空链表不能反转，或者说反转之后还是一个空链表，返回空。
- 利用三个指针p0"前指针"、p1“当前指针”、p2"后指针"来分批处理链表元素，p0置为NULL，它将作为链表的尾结点向前推进处理，p1指向旧链表的头指针head，p2指向旧链表的头指针的next结点。
- 开始遍历链表，循环判定因子为p1，当它为空时到达链表尾部跳出循环。否则在表中执行循环内逻辑：将p1指向的当前结点的下一个结点指向p0，即前一个结点。此时p0为NULL，那么p1的下一个结点就为空了，它现在是最后一个结点。
- 然后将p0指针指向p1，将p1指针指向p2，注意这两步不可以调换顺序，否则正确向后挪移一位。此时完成了三个指针的一轮更迭。
- 判定p2指针是否为空，如果为空说明此时p2到达了链表结尾，当前指针p1的指向为最后一个结点，它的next即为空。如果不为空，将p2更新到下一个结点，进行下一次循环。
- 下一次进行循环时，就会把截断结点链接到新链表的头部，同时更新三个指针。继续循环。
- 循环终止条件为：p1指向了链表尾部的NULL，此时p1的前指针p0即指向了反转后的链表，它就是新链表的head头指针。此时返回p0即可。
struct ListNode *reverseList(struct ListNode* head) {
if (head == NULL) {
return NULL;
}
struct ListNode *p0 = NULL;
struct ListNode *p1 = head;
struct ListNode *p2 = head->next;
while (p1 != NULL) {
p1->next = p0;
p0 = p1;
p1 = p2;
if (p2 != NULL) {
p2 = p2->next;
}
}
return p0;
}参考文档：
https://blog.csdn.net/qq_42351880/article/details/88637387
什么是变量的深拷贝和浅拷贝？
专业名词 • zkbhj 发表了文章 • 0 个评论 • 2105 次浏览 • 2020-07-24 10:41
通用深拷贝和浅拷贝的区别
深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。
假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）
浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址，
深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，
使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。
Go语言中的深浅拷贝
1、深拷贝（Deep Copy）：
拷贝的是数据本身，创造一个样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。
值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。
2、浅拷贝（Shallow Copy）：
拷贝的是数据地址，只复制指向的对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化。释放内存地址时，同时释放内存地址。
引用类型的数据，默认全部都是浅复制，Slice，Map。
深拷贝示例：
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。")
robot1 := Robot{
Name: "小白-X型-V1.0",
Color: "白色",
Model: "小型",
}
robot2 := robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)
fmt.Println("修改Robot1的Name属性值")
robot1.Name = "小白-X型-V1.1"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)
}深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。
Robot 1：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072360
修改Robot1的Name属性值
Robot 1：{小白-X型-V1.1 白色 小型} 内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072360浅拷贝示例2：
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("浅拷贝 使用new方式")
//new方式返回的是一个指针，是引用类型，所以会触发浅拷贝
robot1 := new(Robot)
robot1.Name = "小白-X型-V1.0"
robot1.Color = "白色"
robot1.Model = "小型"
robot2 := robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
fmt.Println("在这里面修改Robot1的Name和Color属性")
robot1.Name = "小蓝-X型-V1.2"
robot1.Color = "蓝色"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
}浅拷贝 使用new方式
Robot 1：&{小白-X型-V1.0 白色 小型} 内存地址：0xc000068330
Robot 2：&{小白-X型-V1.0 白色 小型} 内存地址：0xc000068330
在这里面修改Robot1的Name和Color属性
Robot 1：&{小黑-X型-V1.2 黑色 小型} 内存地址：0xc000068330
Robot 2：&{小黑-X型-V1.2 黑色 小型} 内存地址：0xc000068330另外一种浅拷贝方式：&取指针赋值
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("浅拷贝 内容和内存地址一样，改变其中一个对象的值时，另一个同时变化。")
robot1 := Robot{
Name: "小白-X型-V1.0",
Color: "白色",
Model: "小型",
}
robot2 := &robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
fmt.Println("在这里面修改Robot1的Name和Color属性")
robot1.Name = "小黑-X型-V1.1"
robot1.Color = "黑色"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
}
参考文档：
https://www.cnblogs.com/mikeCao/p/8710837.html
https://www.cnblogs.com/guichenglin/p/12736203.html
查看全部
深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。
假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）
浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址，
深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，
使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。
Go语言中的深浅拷贝
1、深拷贝（Deep Copy）：
拷贝的是数据本身，创造一个样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。
值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。
2、浅拷贝（Shallow Copy）：
拷贝的是数据地址，只复制指向的对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化。释放内存地址时，同时释放内存地址。
引用类型的数据，默认全部都是浅复制，Slice，Map。
深拷贝示例：
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。")
robot1 := Robot{
Name: "小白-X型-V1.0",
Color: "白色",
Model: "小型",
}
robot2 := robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)
fmt.Println("修改Robot1的Name属性值")
robot1.Name = "小白-X型-V1.1"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)
}深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。
Robot 1：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072360
修改Robot1的Name属性值
Robot 1：{小白-X型-V1.1 白色 小型} 内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072360浅拷贝示例2：
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("浅拷贝 使用new方式")
//new方式返回的是一个指针，是引用类型，所以会触发浅拷贝
robot1 := new(Robot)
robot1.Name = "小白-X型-V1.0"
robot1.Color = "白色"
robot1.Model = "小型"
robot2 := robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
fmt.Println("在这里面修改Robot1的Name和Color属性")
robot1.Name = "小蓝-X型-V1.2"
robot1.Color = "蓝色"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
}浅拷贝 使用new方式
Robot 1：&{小白-X型-V1.0 白色 小型} 内存地址：0xc000068330
Robot 2：&{小白-X型-V1.0 白色 小型} 内存地址：0xc000068330
在这里面修改Robot1的Name和Color属性
Robot 1：&{小黑-X型-V1.2 黑色 小型} 内存地址：0xc000068330
Robot 2：&{小黑-X型-V1.2 黑色 小型} 内存地址：0xc000068330另外一种浅拷贝方式：&取指针赋值
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("浅拷贝 内容和内存地址一样，改变其中一个对象的值时，另一个同时变化。")
robot1 := Robot{
Name: "小白-X型-V1.0",
Color: "白色",
Model: "小型",
}
robot2 := &robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
fmt.Println("在这里面修改Robot1的Name和Color属性")
robot1.Name = "小黑-X型-V1.1"
robot1.Color = "黑色"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
}
参考文档：
https://www.cnblogs.com/mikeCao/p/8710837.html
https://www.cnblogs.com/guichenglin/p/12736203.html
查看全部
通用深拷贝和浅拷贝的区别
假设B复制了A，修改A的时候，看B是否发生变化：
浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址，
深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，
使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。
Go语言中的深浅拷贝
1、深拷贝（Deep Copy）：
拷贝的是数据本身，创造一个样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。
值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。
2、浅拷贝（Shallow Copy）：
拷贝的是数据地址，只复制指向的对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化。释放内存地址时，同时释放内存地址。
引用类型的数据，默认全部都是浅复制，Slice，Map。
深拷贝示例：
参考文档：
https://www.cnblogs.com/mikeCao/p/8710837.html
https://www.cnblogs.com/guichenglin/p/12736203.html
深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。
假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）
浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址，
深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，
使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。
Go语言中的深浅拷贝
1、深拷贝（Deep Copy）：
拷贝的是数据本身，创造一个样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。
值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。
2、浅拷贝（Shallow Copy）：
拷贝的是数据地址，只复制指向的对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化。释放内存地址时，同时释放内存地址。
引用类型的数据，默认全部都是浅复制，Slice，Map。
深拷贝示例：
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。")
robot1 := Robot{
Name: "小白-X型-V1.0",
Color: "白色",
Model: "小型",
}
robot2 := robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)
fmt.Println("修改Robot1的Name属性值")
robot1.Name = "小白-X型-V1.1"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)
}
深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。浅拷贝示例2：
Robot 1：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072360
修改Robot1的Name属性值
Robot 1：{小白-X型-V1.1 白色 小型} 内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型} 内存地址：0xc000072360
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("浅拷贝 使用new方式")
//new方式返回的是一个指针，是引用类型，所以会触发浅拷贝
robot1 := new(Robot)
robot1.Name = "小白-X型-V1.0"
robot1.Color = "白色"
robot1.Model = "小型"
robot2 := robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
fmt.Println("在这里面修改Robot1的Name和Color属性")
robot1.Name = "小蓝-X型-V1.2"
robot1.Color = "蓝色"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
}
浅拷贝 使用new方式另外一种浅拷贝方式：&取指针赋值
Robot 1：&{小白-X型-V1.0 白色 小型} 内存地址：0xc000068330
Robot 2：&{小白-X型-V1.0 白色 小型} 内存地址：0xc000068330
在这里面修改Robot1的Name和Color属性
Robot 1：&{小黑-X型-V1.2 黑色 小型} 内存地址：0xc000068330
Robot 2：&{小黑-X型-V1.2 黑色 小型} 内存地址：0xc000068330
package main
import (
"fmt"
)
// 定义一个Robot结构体
type Robot struct {
Name string
Color string
Model string
}
func main() {
fmt.Println("浅拷贝 内容和内存地址一样，改变其中一个对象的值时，另一个同时变化。")
robot1 := Robot{
Name: "小白-X型-V1.0",
Color: "白色",
Model: "小型",
}
robot2 := &robot1
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
fmt.Println("在这里面修改Robot1的Name和Color属性")
robot1.Name = "小黑-X型-V1.1"
robot1.Color = "黑色"
fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
}
参考文档：
https://www.cnblogs.com/mikeCao/p/8710837.html
https://www.cnblogs.com/guichenglin/p/12736203.html
Golang中的并发安全
GoLang • zkbhj 发表了文章 • 0 个评论 • 1909 次浏览 • 2020-07-23 17:05
并发安全
并发安全也叫线程安全，在并发中出现了数据的丢失，称为并发不安全。
map和slice都是并发不安全的。
slice在并发执行中不会报错，但是数据会丢失；
map在并发执行中会直接报错（fatal error: concurrent map writes）。
切片并发不安全
场景: 10000个协程同时添加切片
var s []int
func appendValue(i int) {
s = append(s, i)
}
func main() {
for i := 0; i < 10000; i++ { //10000个协程同时添加切片
go appendValue(i)
}
for i, v := range s { //同时打印索引和值
fmt.Println(i, ":", v)
}
}输出：
没有到9999,说明有数据丢失
解决方法: 加锁
var s []int
var lock sync.Mutex //互斥锁
func appendValue(i int) {
lock.Lock() //加锁
s = append(s, i)
lock.Unlock() //解锁
}
func main() {
for i := 0; i < 10000; i++ {
go appendValue(i)
}
//sort.Ints(s) //给切片排序,先排完序再打印,和下面一句效果相同
time.Sleep(time.Second) //间隔1s再打印,防止一边插入数据一边打印时数据乱序
for i, v := range s {
fmt.Println(i, ":", v)
}
}
总结: slice在并发执行中不会报错，但是数据会丢失
map并发不安全
场景: 2个协程同时读和写
func main() {
m := make(map[int]int)
go func() { //开一个协程写map
for i := 0; i < 10000; i++ {
m[i] = i
}
}()
go func() { //开一个协程读map
for i := 0; i < 10000; i++ {
fmt.Println(m[i])
}
}()
//time.Sleep(time.Second * 20)
for {
;
}
}输出：
解决方法：尽量不要做map的并发，如果用并发要加锁，保证map的操作要么读，要么写。
var lock sync.Mutex
func main() {
m:=make(map[int]int)
go func() { //开一个协程写map
for i:=0;i<10000 ;i++ {
lock.Lock() //加锁
m[i]=i
lock.Unlock() //解锁
}
}()
go func() { //开一个协程读map
for i:=0;i<10000 ;i++ {
lock.Lock() //加锁
fmt.Println(m[i])
lock.Unlock() //解锁
}
}()
time.Sleep(time.Second*20)
}
总结: map在并发执行中会直接报错
原文链接：https://blog.csdn.net/weixin_4 ... 97247 查看全部
并发安全也叫线程安全，在并发中出现了数据的丢失，称为并发不安全。
map和slice都是并发不安全的。
slice在并发执行中不会报错，但是数据会丢失；
map在并发执行中会直接报错（fatal error: concurrent map writes）。
切片并发不安全
场景: 10000个协程同时添加切片
var s []int
func appendValue(i int) {
s = append(s, i)
}
func main() {
for i := 0; i < 10000; i++ { //10000个协程同时添加切片
go appendValue(i)
}
for i, v := range s { //同时打印索引和值
fmt.Println(i, ":", v)
}
}输出：
没有到9999,说明有数据丢失
解决方法: 加锁
var s []int
var lock sync.Mutex //互斥锁
func appendValue(i int) {
lock.Lock() //加锁
s = append(s, i)
lock.Unlock() //解锁
}
func main() {
for i := 0; i < 10000; i++ {
go appendValue(i)
}
//sort.Ints(s) //给切片排序,先排完序再打印,和下面一句效果相同
time.Sleep(time.Second) //间隔1s再打印,防止一边插入数据一边打印时数据乱序
for i, v := range s {
fmt.Println(i, ":", v)
}
}
总结: slice在并发执行中不会报错，但是数据会丢失
map并发不安全
场景: 2个协程同时读和写
func main() {
m := make(map[int]int)
go func() { //开一个协程写map
for i := 0; i < 10000; i++ {
m[i] = i
}
}()
go func() { //开一个协程读map
for i := 0; i < 10000; i++ {
fmt.Println(m[i])
}
}()
//time.Sleep(time.Second * 20)
for {
;
}
}输出：
解决方法：尽量不要做map的并发，如果用并发要加锁，保证map的操作要么读，要么写。
var lock sync.Mutex
func main() {
m:=make(map[int]int)
go func() { //开一个协程写map
for i:=0;i<10000 ;i++ {
lock.Lock() //加锁
m[i]=i
lock.Unlock() //解锁
}
}()
go func() { //开一个协程读map
for i:=0;i<10000 ;i++ {
lock.Lock() //加锁
fmt.Println(m[i])
lock.Unlock() //解锁
}
}()
time.Sleep(time.Second*20)
}
总结: map在并发执行中会直接报错
原文链接：https://blog.csdn.net/weixin_4 ... 97247 查看全部
并发安全
并发安全也叫线程安全，在并发中出现了数据的丢失，称为并发不安全。
map和slice都是并发不安全的。
切片并发不安全
场景: 10000个协程同时添加切片
没有到9999,说明有数据丢失
解决方法: 加锁
map并发不安全
场景: 2个协程同时读和写
解决方法：尽量不要做map的并发，如果用并发要加锁，保证map的操作要么读，要么写。
总结: map在并发执行中会直接报错
原文链接：https://blog.csdn.net/weixin_4 ... 97247
并发安全也叫线程安全，在并发中出现了数据的丢失，称为并发不安全。
map和slice都是并发不安全的。
slice在并发执行中不会报错，但是数据会丢失；
map在并发执行中会直接报错（fatal error: concurrent map writes）。
切片并发不安全
场景: 10000个协程同时添加切片
var s []int输出：
func appendValue(i int) {
s = append(s, i)
}
func main() {
for i := 0; i < 10000; i++ { //10000个协程同时添加切片
go appendValue(i)
}
for i, v := range s { //同时打印索引和值
fmt.Println(i, ":", v)
}
}
没有到9999,说明有数据丢失
解决方法: 加锁
var s []int总结: slice在并发执行中不会报错，但是数据会丢失
var lock sync.Mutex //互斥锁
func appendValue(i int) {
lock.Lock() //加锁
s = append(s, i)
lock.Unlock() //解锁
}
func main() {
for i := 0; i < 10000; i++ {
go appendValue(i)
}
//sort.Ints(s) //给切片排序,先排完序再打印,和下面一句效果相同
time.Sleep(time.Second) //间隔1s再打印,防止一边插入数据一边打印时数据乱序
for i, v := range s {
fmt.Println(i, ":", v)
}
}
map并发不安全
场景: 2个协程同时读和写
func main() {
m := make(map[int]int)
go func() { //开一个协程写map
for i := 0; i < 10000; i++ {
m[i] = i
}
}()
go func() { //开一个协程读map
for i := 0; i < 10000; i++ {
fmt.Println(m[i])
}
}()
//time.Sleep(time.Second * 20)
for {
;
}
}输出：解决方法：尽量不要做map的并发，如果用并发要加锁，保证map的操作要么读，要么写。
var lock sync.Mutex
func main() {
m:=make(map[int]int)
go func() { //开一个协程写map
for i:=0;i<10000 ;i++ {
lock.Lock() //加锁
m[i]=i
lock.Unlock() //解锁
}
}()
go func() { //开一个协程读map
for i:=0;i<10000 ;i++ {
lock.Lock() //加锁
fmt.Println(m[i])
lock.Unlock() //解锁
}
}()
time.Sleep(time.Second*20)
}
总结: map在并发执行中会直接报错
原文链接：https://blog.csdn.net/weixin_4 ... 97247
#2020学习打卡##Go语言高级编程# 详细理解数组array、字符串string和切片slice的异同
GoLang • zkbhj 发表了文章 • 0 个评论 • 1131 次浏览 • 2020-06-08 12:37
Go语言中数组、字符串和切片三者是密切相关的数据结构。这3种数据类型，在底层原始数据有着相同的内存结构，在上层，因为语法的限制而有着不同的行为表现。
Go语言的数据是一种值类型，虽然数组的元素可以被修改，但是数组本身的赋值和函数传参都是以整体复制的方式处理的。
Go语言字符串底层数据也是对应的字节数组，但是字符串的只读属性禁止了在程序中对底层字节数组的元素的修改。字符串赋值只是复制了数据地址和对应的长度，而不会导师底层数据的复制。
切片的底层数据虽然也是对应数据类型的数组，但是每个切片还有独立的长度和容量信息，切片赋值和函数的传参时也是将切片头信息部分按传值方式处理。因为切片头含有底层数据的指针，所以它的赋值也不会导致底层数据的复制。
数组
数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。数组的长度是数组类型的组成部分。因为数组的长度是数组类型的一个部分，不同长度或不同类型的数据组成的数组都是不同的类型，因此在Go语言中很少直接使用数组（不同长度的数组因为类型不同无法直接赋值）。和数组对应的类型是切片，切片是可以动态增长和收缩的序列，切片的功能也更加灵活，但是要理解切片的工作原理还是要先理解数组。
定义方式
var a [3]int // 定义长度为3的int型数组, 元素全部为0
var b = [...]int{1, 2, 3} // 定义长度为3的int型数组, 元素为 1, 2, 3
var c = [...]int{2: 3, 1: 2} // 定义长度为3的int型数组, 元素为 0, 2, 3
var d = [...]int{1, 2, 4: 5, 6} // 定义长度为6的int型数组, 元素为 1, 2, 0, 0, 5, 6第一种方式是定义一个数组变量的最基本的方式，数组的长度明确指定，数组中的每个元素都以零值初始化。
第二种方式定义数组，可以在定义的时候顺序指定全部元素的初始化值，数组的长度根据初始化元素的数目自动计算。
第三种方式是以索引的方式来初始化数组的元素，因此元素的初始化值出现顺序比较随意。这种初始化方式和 map[int]Type 类型的初始化语法类似。数组的长度以出现的最大的索引为准，没有明确初始化的元素依然用0值初始化。
第四种方式是混合了第二种和第三种的初始化方式，前面两个元素采用顺序初始化，第三第四个元素零值初始化，第五个元素通过索引初始化，最后一个元素跟在前面的第五个元素之后采用顺序初始化。
数组与指针
Go语言中数组是值语义。一个数组变量即表示整个数组，它并不是隐式的指向第一个元素的指针（比如C语言的数组），而是一个完整的值。当一个数组变量被赋值或者被传递的时候，实际上会复制整个数组。如果数组较大的话，数组的赋值也会有较大的开销。为了避免复制数组带来的开销，可以传递一个指向数组的指针，但是数组指针并不是数组。
var a = [...]int{1, 2, 3} // a 是一个数组
var b = &a // b 是指向数组的指针
fmt.Println(a[0], a[1]) // 打印数组的前2个元素
fmt.Println(b[0], b[1]) // 通过数组指针访问数组元素的方式和数组类似可以将数组看作一个特殊的结构体，结构的字段名对应数组的索引，同时结构体成员的数目是固定的。内置函数 len 可以用于计算数组的长度， cap 函数可以用于计算数组的容量。不过对于数组类型来说， len 和 cap 函数返回的结果始终是一样的，都是对应数组类型的长度。
遍历for i := range a {
fmt.Printf("a[%d]: %d\n", i, a[i])
}
for i, v := range b {
fmt.Printf("b[%d]: %d\n", i, v)
}
for i := 0; i < len(c); i++ {
fmt.Printf("c[%d]: %d\n", i, c[i])
}用 for range 方式迭代的性能可能会更好一些，因为这种迭代可以保证不会出现数组越界的情形，每轮迭代对数组元素的访问时可以省去对下标越界的判断。
字符串
一个字符串是一个不可改变的字节序列，字符串通常是用来包含人类可读的文本数据。和数组不同的是，字符串的元素不可修改，是一个只读的字节数组。每个字符串的长度虽然也是固定的，但是字符串的长度并不是字符串类型的一部分。
Go语言字符串的底层结构在 reflect.StringHeader 中定义：
type StringHeader struct {
Data uintptr
Len int
}字符串结构由两个信息组成：第一个是字符串指向的底层字节数组，第二个是字符串的字节的长度。
字符串其实是一个结构体，因此字符串的赋值操作也就是 reflect.StringHeader 结构体的复制过程。
字符串虽然不是切片，但是支持切片操作，不同位置的切片底层也访问的同一块内存数据（因为字符串是只读的，相同的字符串面值常量通常是对应同一个字符串常量）：
s := "hello, world"
hello := s[:5]
world := s[7:]
s1 := "hello, world"[:5]
s2 := "hello, world"[7:]切片
切片（slice）是一种简化版的动态数组。切片的结构定义， reflect.SliceHeader ：
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
定义方式
var (
a []int // nil切片, 和 nil 相等, 一般用来表示一个不存在的切片
b = []int{} // 空切片, 和 nil 不相等, 一般用来表示一个空的集合
c = []int{1, 2, 3} // 有3个元素的切片, len和cap都为3
d = c[:2] // 有2个元素的切片, len为2, cap为3
e = c[0:2:cap(c)] // 有2个元素的切片, len为2, cap为3
f = c[:0] // 有0个元素的切片, len为0, cap为3
g = make([]int, 3) // 有3个元素的切片, len和cap都为3
h = make([]int, 2, 3) // 有2个元素的切片, len为2, cap为3
i = make([]int, 0, 3) // 有0个元素的切片, len为0, cap为3
)和数组一样，内置的len()函数返回切片中有效元素的长度，内置的cap()函数返回切片容量的大小，容量必须大于或等于切片的长度。
遍历
for i := range a {
fmt.Printf("a[%d]: %d\n", i, a[i])
}
for i, v := range b {
fmt.Printf("b[%d]: %d\n", i, v)
}
for i := 0; i < len(c); i++ {
fmt.Printf("c[%d]: %d\n", i, c[i])
}在对切片本身赋值或参数传递时，和数组指针的操作方式类似，只是复制切片头信息（ reflect.SliceHeader ），并不会复制底层的数据。
添加
var a []int
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包 注意，在容量不足的情况下，append()操作会导致重新分配内幕才能，可能导致巨大的内存分配和复制数据的代价。及时容量足够，依然需要用append()函数的返回值来更新切片本身，因为新切片的长度已经发生了变化。
删除切片元素
根据要删除的元素的位置，有从开头位置删除、从中间位置删除和从尾部删除3种情况，其中删除切片尾部的元素最快：
a = []int{1, 2, 3}
a = a[:len(a) - 1] //删除尾部1个元素
a = a[:len(a) - n] //删除尾部n个元素 删除开头的元素可以直接移动数据指针：
a = []int{1, 2, 3}
a = a[1:] //删除开头1个元素
a = a[N:] //删除开头N个元素
多维切片
同数组一样，切片也可以有多个维度。
package main
import (
"fmt"
)
func main() {
pls := [][]string {
{"C", "C++"},
{"JavaScript"},
{"Go", "Rust"},
}
for _, v1 := range pls {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
}数据结果：C C++
JavaScript
Go Rust
更多参考文档：
https://www.jianshu.com/p/4eb3e490abe1
https://blog.51cto.com/14073476/2478276
https://cloud.tencent.com/developer/article/1354294
查看全部
Go语言的数据是一种值类型，虽然数组的元素可以被修改，但是数组本身的赋值和函数传参都是以整体复制的方式处理的。
Go语言字符串底层数据也是对应的字节数组，但是字符串的只读属性禁止了在程序中对底层字节数组的元素的修改。字符串赋值只是复制了数据地址和对应的长度，而不会导师底层数据的复制。
切片的底层数据虽然也是对应数据类型的数组，但是每个切片还有独立的长度和容量信息，切片赋值和函数的传参时也是将切片头信息部分按传值方式处理。因为切片头含有底层数据的指针，所以它的赋值也不会导致底层数据的复制。
数组
数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。数组的长度是数组类型的组成部分。因为数组的长度是数组类型的一个部分，不同长度或不同类型的数据组成的数组都是不同的类型，因此在Go语言中很少直接使用数组（不同长度的数组因为类型不同无法直接赋值）。和数组对应的类型是切片，切片是可以动态增长和收缩的序列，切片的功能也更加灵活，但是要理解切片的工作原理还是要先理解数组。
定义方式
var a [3]int // 定义长度为3的int型数组, 元素全部为0
var b = [...]int{1, 2, 3} // 定义长度为3的int型数组, 元素为 1, 2, 3
var c = [...]int{2: 3, 1: 2} // 定义长度为3的int型数组, 元素为 0, 2, 3
var d = [...]int{1, 2, 4: 5, 6} // 定义长度为6的int型数组, 元素为 1, 2, 0, 0, 5, 6第一种方式是定义一个数组变量的最基本的方式，数组的长度明确指定，数组中的每个元素都以零值初始化。
第二种方式定义数组，可以在定义的时候顺序指定全部元素的初始化值，数组的长度根据初始化元素的数目自动计算。
第三种方式是以索引的方式来初始化数组的元素，因此元素的初始化值出现顺序比较随意。这种初始化方式和 map[int]Type 类型的初始化语法类似。数组的长度以出现的最大的索引为准，没有明确初始化的元素依然用0值初始化。
第四种方式是混合了第二种和第三种的初始化方式，前面两个元素采用顺序初始化，第三第四个元素零值初始化，第五个元素通过索引初始化，最后一个元素跟在前面的第五个元素之后采用顺序初始化。
数组与指针
Go语言中数组是值语义。一个数组变量即表示整个数组，它并不是隐式的指向第一个元素的指针（比如C语言的数组），而是一个完整的值。当一个数组变量被赋值或者被传递的时候，实际上会复制整个数组。如果数组较大的话，数组的赋值也会有较大的开销。为了避免复制数组带来的开销，可以传递一个指向数组的指针，但是数组指针并不是数组。
var a = [...]int{1, 2, 3} // a 是一个数组
var b = &a // b 是指向数组的指针
fmt.Println(a[0], a[1]) // 打印数组的前2个元素
fmt.Println(b[0], b[1]) // 通过数组指针访问数组元素的方式和数组类似可以将数组看作一个特殊的结构体，结构的字段名对应数组的索引，同时结构体成员的数目是固定的。内置函数 len 可以用于计算数组的长度， cap 函数可以用于计算数组的容量。不过对于数组类型来说， len 和 cap 函数返回的结果始终是一样的，都是对应数组类型的长度。
遍历for i := range a {
fmt.Printf("a[%d]: %d\n", i, a[i])
}
for i, v := range b {
fmt.Printf("b[%d]: %d\n", i, v)
}
for i := 0; i < len(c); i++ {
fmt.Printf("c[%d]: %d\n", i, c[i])
}用 for range 方式迭代的性能可能会更好一些，因为这种迭代可以保证不会出现数组越界的情形，每轮迭代对数组元素的访问时可以省去对下标越界的判断。
字符串
一个字符串是一个不可改变的字节序列，字符串通常是用来包含人类可读的文本数据。和数组不同的是，字符串的元素不可修改，是一个只读的字节数组。每个字符串的长度虽然也是固定的，但是字符串的长度并不是字符串类型的一部分。
Go语言字符串的底层结构在 reflect.StringHeader 中定义：
type StringHeader struct {
Data uintptr
Len int
}字符串结构由两个信息组成：第一个是字符串指向的底层字节数组，第二个是字符串的字节的长度。
字符串其实是一个结构体，因此字符串的赋值操作也就是 reflect.StringHeader 结构体的复制过程。
字符串虽然不是切片，但是支持切片操作，不同位置的切片底层也访问的同一块内存数据（因为字符串是只读的，相同的字符串面值常量通常是对应同一个字符串常量）：
s := "hello, world"
hello := s[:5]
world := s[7:]
s1 := "hello, world"[:5]
s2 := "hello, world"[7:]切片
切片（slice）是一种简化版的动态数组。切片的结构定义， reflect.SliceHeader ：
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
定义方式
var (
a []int // nil切片, 和 nil 相等, 一般用来表示一个不存在的切片
b = []int{} // 空切片, 和 nil 不相等, 一般用来表示一个空的集合
c = []int{1, 2, 3} // 有3个元素的切片, len和cap都为3
d = c[:2] // 有2个元素的切片, len为2, cap为3
e = c[0:2:cap(c)] // 有2个元素的切片, len为2, cap为3
f = c[:0] // 有0个元素的切片, len为0, cap为3
g = make([]int, 3) // 有3个元素的切片, len和cap都为3
h = make([]int, 2, 3) // 有2个元素的切片, len为2, cap为3
i = make([]int, 0, 3) // 有0个元素的切片, len为0, cap为3
)和数组一样，内置的len()函数返回切片中有效元素的长度，内置的cap()函数返回切片容量的大小，容量必须大于或等于切片的长度。
遍历
for i := range a {
fmt.Printf("a[%d]: %d\n", i, a[i])
}
for i, v := range b {
fmt.Printf("b[%d]: %d\n", i, v)
}
for i := 0; i < len(c); i++ {
fmt.Printf("c[%d]: %d\n", i, c[i])
}在对切片本身赋值或参数传递时，和数组指针的操作方式类似，只是复制切片头信息（ reflect.SliceHeader ），并不会复制底层的数据。
添加
var a []int
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包 注意，在容量不足的情况下，append()操作会导致重新分配内幕才能，可能导致巨大的内存分配和复制数据的代价。及时容量足够，依然需要用append()函数的返回值来更新切片本身，因为新切片的长度已经发生了变化。
删除切片元素
根据要删除的元素的位置，有从开头位置删除、从中间位置删除和从尾部删除3种情况，其中删除切片尾部的元素最快：
a = []int{1, 2, 3}
a = a[:len(a) - 1] //删除尾部1个元素
a = a[:len(a) - n] //删除尾部n个元素 删除开头的元素可以直接移动数据指针：
a = []int{1, 2, 3}
a = a[1:] //删除开头1个元素
a = a[N:] //删除开头N个元素
多维切片
同数组一样，切片也可以有多个维度。
package main
import (
"fmt"
)
func main() {
pls := [][]string {
{"C", "C++"},
{"JavaScript"},
{"Go", "Rust"},
}
for _, v1 := range pls {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
}数据结果：C C++
JavaScript
Go Rust
更多参考文档：
https://www.jianshu.com/p/4eb3e490abe1
https://blog.51cto.com/14073476/2478276
https://cloud.tencent.com/developer/article/1354294
查看全部
Go语言中数组、字符串和切片三者是密切相关的数据结构。这3种数据类型，在底层原始数据有着相同的内存结构，在上层，因为语法的限制而有着不同的行为表现。
Go语言的数据是一种值类型，虽然数组的元素可以被修改，但是数组本身的赋值和函数传参都是以整体复制的方式处理的。
Go语言字符串底层数据也是对应的字节数组，但是字符串的只读属性禁止了在程序中对底层字节数组的元素的修改。字符串赋值只是复制了数据地址和对应的长度，而不会导师底层数据的复制。
切片的底层数据虽然也是对应数据类型的数组，但是每个切片还有独立的长度和容量信息，切片赋值和函数的传参时也是将切片头信息部分按传值方式处理。因为切片头含有底层数据的指针，所以它的赋值也不会导致底层数据的复制。
数组
数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。数组的长度是数组类型的组成部分。因为数组的长度是数组类型的一个部分，不同长度或不同类型的数据组成的数组都是不同的类型，因此在Go语言中很少直接使用数组（不同长度的数组因为类型不同无法直接赋值）。和数组对应的类型是切片，切片是可以动态增长和收缩的序列，切片的功能也更加灵活，但是要理解切片的工作原理还是要先理解数组。
定义方式
第二种方式定义数组，可以在定义的时候顺序指定全部元素的初始化值，数组的长度根据初始化元素的数目自动计算。
第三种方式是以索引的方式来初始化数组的元素，因此元素的初始化值出现顺序比较随意。这种初始化方式和 map[int]Type 类型的初始化语法类似。数组的长度以出现的最大的索引为准，没有明确初始化的元素依然用0值初始化。
第四种方式是混合了第二种和第三种的初始化方式，前面两个元素采用顺序初始化，第三第四个元素零值初始化，第五个元素通过索引初始化，最后一个元素跟在前面的第五个元素之后采用顺序初始化。
数组与指针
Go语言中数组是值语义。一个数组变量即表示整个数组，它并不是隐式的指向第一个元素的指针（比如C语言的数组），而是一个完整的值。当一个数组变量被赋值或者被传递的时候，实际上会复制整个数组。如果数组较大的话，数组的赋值也会有较大的开销。为了避免复制数组带来的开销，可以传递一个指向数组的指针，但是数组指针并不是数组。
遍历
字符串
一个字符串是一个不可改变的字节序列，字符串通常是用来包含人类可读的文本数据。和数组不同的是，字符串的元素不可修改，是一个只读的字节数组。每个字符串的长度虽然也是固定的，但是字符串的长度并不是字符串类型的一部分。
Go语言字符串的底层结构在 reflect.StringHeader 中定义：
字符串其实是一个结构体，因此字符串的赋值操作也就是 reflect.StringHeader 结构体的复制过程。
字符串虽然不是切片，但是支持切片操作，不同位置的切片底层也访问的同一块内存数据（因为字符串是只读的，相同的字符串面值常量通常是对应同一个字符串常量）：
切片（slice）是一种简化版的动态数组。切片的结构定义， reflect.SliceHeader ：
定义方式
遍历
添加
删除切片元素
根据要删除的元素的位置，有从开头位置删除、从中间位置删除和从尾部删除3种情况，其中删除切片尾部的元素最快：
多维切片
同数组一样，切片也可以有多个维度。
更多参考文档：
https://www.jianshu.com/p/4eb3e490abe1
https://blog.51cto.com/14073476/2478276
https://cloud.tencent.com/developer/article/1354294
Go语言的数据是一种值类型，虽然数组的元素可以被修改，但是数组本身的赋值和函数传参都是以整体复制的方式处理的。
Go语言字符串底层数据也是对应的字节数组，但是字符串的只读属性禁止了在程序中对底层字节数组的元素的修改。字符串赋值只是复制了数据地址和对应的长度，而不会导师底层数据的复制。
切片的底层数据虽然也是对应数据类型的数组，但是每个切片还有独立的长度和容量信息，切片赋值和函数的传参时也是将切片头信息部分按传值方式处理。因为切片头含有底层数据的指针，所以它的赋值也不会导致底层数据的复制。
数组
数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。数组的长度是数组类型的组成部分。因为数组的长度是数组类型的一个部分，不同长度或不同类型的数据组成的数组都是不同的类型，因此在Go语言中很少直接使用数组（不同长度的数组因为类型不同无法直接赋值）。和数组对应的类型是切片，切片是可以动态增长和收缩的序列，切片的功能也更加灵活，但是要理解切片的工作原理还是要先理解数组。
定义方式
var a [3]int // 定义长度为3的int型数组, 元素全部为0第一种方式是定义一个数组变量的最基本的方式，数组的长度明确指定，数组中的每个元素都以零值初始化。
var b = [...]int{1, 2, 3} // 定义长度为3的int型数组, 元素为 1, 2, 3
var c = [...]int{2: 3, 1: 2} // 定义长度为3的int型数组, 元素为 0, 2, 3
var d = [...]int{1, 2, 4: 5, 6} // 定义长度为6的int型数组, 元素为 1, 2, 0, 0, 5, 6
第二种方式定义数组，可以在定义的时候顺序指定全部元素的初始化值，数组的长度根据初始化元素的数目自动计算。
第三种方式是以索引的方式来初始化数组的元素，因此元素的初始化值出现顺序比较随意。这种初始化方式和 map[int]Type 类型的初始化语法类似。数组的长度以出现的最大的索引为准，没有明确初始化的元素依然用0值初始化。
第四种方式是混合了第二种和第三种的初始化方式，前面两个元素采用顺序初始化，第三第四个元素零值初始化，第五个元素通过索引初始化，最后一个元素跟在前面的第五个元素之后采用顺序初始化。
数组与指针
Go语言中数组是值语义。一个数组变量即表示整个数组，它并不是隐式的指向第一个元素的指针（比如C语言的数组），而是一个完整的值。当一个数组变量被赋值或者被传递的时候，实际上会复制整个数组。如果数组较大的话，数组的赋值也会有较大的开销。为了避免复制数组带来的开销，可以传递一个指向数组的指针，但是数组指针并不是数组。
var a = [...]int{1, 2, 3} // a 是一个数组可以将数组看作一个特殊的结构体，结构的字段名对应数组的索引，同时结构体成员的数目是固定的。内置函数 len 可以用于计算数组的长度， cap 函数可以用于计算数组的容量。不过对于数组类型来说， len 和 cap 函数返回的结果始终是一样的，都是对应数组类型的长度。
var b = &a // b 是指向数组的指针
fmt.Println(a[0], a[1]) // 打印数组的前2个元素
fmt.Println(b[0], b[1]) // 通过数组指针访问数组元素的方式和数组类似
遍历
for i := range a {
fmt.Printf("a[%d]: %d\n", i, a[i])
}
for i, v := range b {
fmt.Printf("b[%d]: %d\n", i, v)
}
for i := 0; i < len(c); i++ {
fmt.Printf("c[%d]: %d\n", i, c[i])
}用 for range 方式迭代的性能可能会更好一些，因为这种迭代可以保证不会出现数组越界的情形，每轮迭代对数组元素的访问时可以省去对下标越界的判断。字符串
一个字符串是一个不可改变的字节序列，字符串通常是用来包含人类可读的文本数据。和数组不同的是，字符串的元素不可修改，是一个只读的字节数组。每个字符串的长度虽然也是固定的，但是字符串的长度并不是字符串类型的一部分。
Go语言字符串的底层结构在 reflect.StringHeader 中定义：
type StringHeader struct {
Data uintptr
Len int
}字符串结构由两个信息组成：第一个是字符串指向的底层字节数组，第二个是字符串的字节的长度。字符串其实是一个结构体，因此字符串的赋值操作也就是 reflect.StringHeader 结构体的复制过程。
字符串虽然不是切片，但是支持切片操作，不同位置的切片底层也访问的同一块内存数据（因为字符串是只读的，相同的字符串面值常量通常是对应同一个字符串常量）：
s := "hello, world"切片
hello := s[:5]
world := s[7:]
s1 := "hello, world"[:5]
s2 := "hello, world"[7:]
切片（slice）是一种简化版的动态数组。切片的结构定义， reflect.SliceHeader ：
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
定义方式
var (和数组一样，内置的len()函数返回切片中有效元素的长度，内置的cap()函数返回切片容量的大小，容量必须大于或等于切片的长度。
a []int // nil切片, 和 nil 相等, 一般用来表示一个不存在的切片
b = []int{} // 空切片, 和 nil 不相等, 一般用来表示一个空的集合
c = []int{1, 2, 3} // 有3个元素的切片, len和cap都为3
d = c[:2] // 有2个元素的切片, len为2, cap为3
e = c[0:2:cap(c)] // 有2个元素的切片, len为2, cap为3
f = c[:0] // 有0个元素的切片, len为0, cap为3
g = make([]int, 3) // 有3个元素的切片, len和cap都为3
h = make([]int, 2, 3) // 有2个元素的切片, len为2, cap为3
i = make([]int, 0, 3) // 有0个元素的切片, len为0, cap为3
)
遍历
for i := range a {
fmt.Printf("a[%d]: %d\n", i, a[i])
}
for i, v := range b {
fmt.Printf("b[%d]: %d\n", i, v)
}
for i := 0; i < len(c); i++ {
fmt.Printf("c[%d]: %d\n", i, c[i])
}在对切片本身赋值或参数传递时，和数组指针的操作方式类似，只是复制切片头信息（ reflect.SliceHeader ），并不会复制底层的数据。添加
var a []int注意，在容量不足的情况下，append()操作会导致重新分配内幕才能，可能导致巨大的内存分配和复制数据的代价。及时容量足够，依然需要用append()函数的返回值来更新切片本身，因为新切片的长度已经发生了变化。
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包
删除切片元素
根据要删除的元素的位置，有从开头位置删除、从中间位置删除和从尾部删除3种情况，其中删除切片尾部的元素最快：
a = []int{1, 2, 3}删除开头的元素可以直接移动数据指针：
a = a[:len(a) - 1] //删除尾部1个元素
a = a[:len(a) - n] //删除尾部n个元素
a = []int{1, 2, 3}
a = a[1:] //删除开头1个元素
a = a[N:] //删除开头N个元素
多维切片
同数组一样，切片也可以有多个维度。
package main数据结果：
import (
"fmt"
)
func main() {
pls := [][]string {
{"C", "C++"},
{"JavaScript"},
{"Go", "Rust"},
}
for _, v1 := range pls {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
}
C C++
JavaScript
Go Rust
更多参考文档：
https://www.jianshu.com/p/4eb3e490abe1
https://blog.51cto.com/14073476/2478276
https://cloud.tencent.com/developer/article/1354294
#2020学习打卡##C程序设计语言# C语言中的随机数函数解析
C语言 • zkbhj 发表了文章 • 0 个评论 • 1292 次浏览 • 2020-05-25 12:02
在计算机中并没有一个真正的随机数发生器，但是可以做到使产生的数字重复率很低，这样看起来好象是真正的随机数，实现这一功能的程序叫伪随机数发生器。
有关如何产生随机数的理论有许多，如果要详细地讨论，需要厚厚的一本书的篇幅。不管用什么方法实现随机数发生器，都必须给它提供一个名为“种子”的初始值。而且这个值最好是随机的，或者至少这个值是伪随机的。“种子”的值通常是用快速计数寄存器或移位寄存器来生成的。
在实际编程中，我们经常会用到随机数这个概念，其实也是一个伪随机数，实际上并不是一个真正的随机数，但是也足够我们使用了。在C语言中，编写一些关于游戏之类的程序时就需要用到随机数了。同时C语言也提供了一个标准库里面一个函数来产生随机数，而对于随机数的产生是根据种子（根据一个数值按照某种公式计算的）来变化的，种子 与随机数之间符合正态分布（高斯分布）。
生成随机数
在C语言中，我们一般使用 <stdlib.h> 头文件中的 rand() 函数来生成随机数，它的用法为：int rand (void);【void是指不需要传递参数】
rand() 会随机生成一个位于 0 ~ RAND_MAX 之间的整数。而对RAND_MAX 是 <stdlib.h> 头文件中的一个宏，它用来指明 rand() 所能返回的随机数的最大值。C语言标准并没有规定 RAND_MAX 的具体数值，只是规定它的值至少为 32767。/**
* 第35堂课示例：随机数
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
int main()
{
int rands;
rands = rand();
printf("rand number is %d\n", rands);
printf("rand number2 is %d\n", rand());
return 0;
}但是这个随机数一旦编译之后就固定了，并不能满足我们的实际需求，前面提到了只是一个伪随机数，我们需要对产生随机数的种子进行不断的重播，从而达到我们实际需求的随机数效果。我们可以通过 srand() 函数来重新“播种”，这样种子就会发生改变。
srand() 的用法为：void srand (unsigned int seed);
它需要一个 unsigned int 类型的参数。在实际开发中，我们可以用时间作为参数，只要每次播种的时间不同，那么生成的种子就不同，最终的随机数也就不同，通常我们采用 <time.h> 头文件中的 time() 函数即可得到当前的时间【精准到秒】srand((unsigned)time(NULL));/**
* 第35堂课示例：随机数
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int rands;
srand((unsigned)time(NULL));
rands = rand();
printf("rand number is %d\n", rands);
printf("rand number2 is %d\n", rand());
return 0;
}小提示：根据种子与随机数的符合高斯分布的关系可知，生成的随机数是逐渐增大或者逐渐减小！
生成一定范围随机数
在实际编程开发中，实际需求往往是一定范围内的随机数，对于产生一定范围的随机数，就需要使用一定的技巧了，常用的方法是取模运算，再加上一个加法运算：int a = rand() % 10; //产生0~9的随机数，注意10会被整除
如果要规定上下限：int a = rand() % 51 + 100; //产生100~150的随机数
分析：取模即取余，rand()%51+13，看成两部分：rand()%51是产生 0~50 的随机数，后面+100保证 a 最小只能是 100，最大就是 50+100=150。/**
* 第35堂课示例：有区间的随机数
* 例如：100~150之间的数字
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int rands;
srand((unsigned)time(NULL));
rands = rand() % 51 + 100;
printf("rand number is %d\n", rands);
return 0;
}
根据种子与随机数的符合高斯分布的关系可知，生成的随机数是逐渐增大或者逐渐减小。 查看全部
有关如何产生随机数的理论有许多，如果要详细地讨论，需要厚厚的一本书的篇幅。不管用什么方法实现随机数发生器，都必须给它提供一个名为“种子”的初始值。而且这个值最好是随机的，或者至少这个值是伪随机的。“种子”的值通常是用快速计数寄存器或移位寄存器来生成的。
在实际编程中，我们经常会用到随机数这个概念，其实也是一个伪随机数，实际上并不是一个真正的随机数，但是也足够我们使用了。在C语言中，编写一些关于游戏之类的程序时就需要用到随机数了。同时C语言也提供了一个标准库里面一个函数来产生随机数，而对于随机数的产生是根据种子（根据一个数值按照某种公式计算的）来变化的，种子 与随机数之间符合正态分布（高斯分布）。
生成随机数
在C语言中，我们一般使用 <stdlib.h> 头文件中的 rand() 函数来生成随机数，它的用法为：int rand (void);【void是指不需要传递参数】
rand() 会随机生成一个位于 0 ~ RAND_MAX 之间的整数。而对RAND_MAX 是 <stdlib.h> 头文件中的一个宏，它用来指明 rand() 所能返回的随机数的最大值。C语言标准并没有规定 RAND_MAX 的具体数值，只是规定它的值至少为 32767。/**
* 第35堂课示例：随机数
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
int main()
{
int rands;
rands = rand();
printf("rand number is %d\n", rands);
printf("rand number2 is %d\n", rand());
return 0;
}但是这个随机数一旦编译之后就固定了，并不能满足我们的实际需求，前面提到了只是一个伪随机数，我们需要对产生随机数的种子进行不断的重播，从而达到我们实际需求的随机数效果。我们可以通过 srand() 函数来重新“播种”，这样种子就会发生改变。
srand() 的用法为：void srand (unsigned int seed);
它需要一个 unsigned int 类型的参数。在实际开发中，我们可以用时间作为参数，只要每次播种的时间不同，那么生成的种子就不同，最终的随机数也就不同，通常我们采用 <time.h> 头文件中的 time() 函数即可得到当前的时间【精准到秒】srand((unsigned)time(NULL));/**
* 第35堂课示例：随机数
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int rands;
srand((unsigned)time(NULL));
rands = rand();
printf("rand number is %d\n", rands);
printf("rand number2 is %d\n", rand());
return 0;
}小提示：根据种子与随机数的符合高斯分布的关系可知，生成的随机数是逐渐增大或者逐渐减小！
生成一定范围随机数
在实际编程开发中，实际需求往往是一定范围内的随机数，对于产生一定范围的随机数，就需要使用一定的技巧了，常用的方法是取模运算，再加上一个加法运算：int a = rand() % 10; //产生0~9的随机数，注意10会被整除
如果要规定上下限：int a = rand() % 51 + 100; //产生100~150的随机数
分析：取模即取余，rand()%51+13，看成两部分：rand()%51是产生 0~50 的随机数，后面+100保证 a 最小只能是 100，最大就是 50+100=150。/**
* 第35堂课示例：有区间的随机数
* 例如：100~150之间的数字
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int rands;
srand((unsigned)time(NULL));
rands = rand() % 51 + 100;
printf("rand number is %d\n", rands);
return 0;
}
根据种子与随机数的符合高斯分布的关系可知，生成的随机数是逐渐增大或者逐渐减小。 查看全部
在计算机中并没有一个真正的随机数发生器，但是可以做到使产生的数字重复率很低，这样看起来好象是真正的随机数，实现这一功能的程序叫伪随机数发生器。
有关如何产生随机数的理论有许多，如果要详细地讨论，需要厚厚的一本书的篇幅。不管用什么方法实现随机数发生器，都必须给它提供一个名为“种子”的初始值。而且这个值最好是随机的，或者至少这个值是伪随机的。“种子”的值通常是用快速计数寄存器或移位寄存器来生成的。
在实际编程中，我们经常会用到随机数这个概念，其实也是一个伪随机数，实际上并不是一个真正的随机数，但是也足够我们使用了。在C语言中，编写一些关于游戏之类的程序时就需要用到随机数了。同时C语言也提供了一个标准库里面一个函数来产生随机数，而对于随机数的产生是根据种子（根据一个数值按照某种公式计算的）来变化的，种子 与随机数之间符合正态分布（高斯分布）。
生成随机数
在C语言中，我们一般使用 <stdlib.h> 头文件中的 rand() 函数来生成随机数，它的用法为：
rand() 会随机生成一个位于 0 ~ RAND_MAX 之间的整数。而对RAND_MAX 是 <stdlib.h> 头文件中的一个宏，它用来指明 rand() 所能返回的随机数的最大值。C语言标准并没有规定 RAND_MAX 的具体数值，只是规定它的值至少为 32767。
srand() 的用法为：
它需要一个 unsigned int 类型的参数。在实际开发中，我们可以用时间作为参数，只要每次播种的时间不同，那么生成的种子就不同，最终的随机数也就不同，通常我们采用 <time.h> 头文件中的 time() 函数即可得到当前的时间【精准到秒】srand((unsigned)time(NULL));
生成一定范围随机数
在实际编程开发中，实际需求往往是一定范围内的随机数，对于产生一定范围的随机数，就需要使用一定的技巧了，常用的方法是取模运算，再加上一个加法运算：
如果要规定上下限：
分析：取模即取余，rand()%51+13，看成两部分：rand()%51是产生 0~50 的随机数，后面+100保证 a 最小只能是 100，最大就是 50+100=150。
根据种子与随机数的符合高斯分布的关系可知，生成的随机数是逐渐增大或者逐渐减小。
有关如何产生随机数的理论有许多，如果要详细地讨论，需要厚厚的一本书的篇幅。不管用什么方法实现随机数发生器，都必须给它提供一个名为“种子”的初始值。而且这个值最好是随机的，或者至少这个值是伪随机的。“种子”的值通常是用快速计数寄存器或移位寄存器来生成的。
在实际编程中，我们经常会用到随机数这个概念，其实也是一个伪随机数，实际上并不是一个真正的随机数，但是也足够我们使用了。在C语言中，编写一些关于游戏之类的程序时就需要用到随机数了。同时C语言也提供了一个标准库里面一个函数来产生随机数，而对于随机数的产生是根据种子（根据一个数值按照某种公式计算的）来变化的，种子 与随机数之间符合正态分布（高斯分布）。
生成随机数
在C语言中，我们一般使用 <stdlib.h> 头文件中的 rand() 函数来生成随机数，它的用法为：
int rand (void);【void是指不需要传递参数】
rand() 会随机生成一个位于 0 ~ RAND_MAX 之间的整数。而对RAND_MAX 是 <stdlib.h> 头文件中的一个宏，它用来指明 rand() 所能返回的随机数的最大值。C语言标准并没有规定 RAND_MAX 的具体数值，只是规定它的值至少为 32767。
/**但是这个随机数一旦编译之后就固定了，并不能满足我们的实际需求，前面提到了只是一个伪随机数，我们需要对产生随机数的种子进行不断的重播，从而达到我们实际需求的随机数效果。我们可以通过 srand() 函数来重新“播种”，这样种子就会发生改变。
* 第35堂课示例：随机数
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
int main()
{
int rands;
rands = rand();
printf("rand number is %d\n", rands);
printf("rand number2 is %d\n", rand());
return 0;
}
srand() 的用法为：
void srand (unsigned int seed);
它需要一个 unsigned int 类型的参数。在实际开发中，我们可以用时间作为参数，只要每次播种的时间不同，那么生成的种子就不同，最终的随机数也就不同，通常我们采用 <time.h> 头文件中的 time() 函数即可得到当前的时间【精准到秒】srand((unsigned)time(NULL));
/**小提示：根据种子与随机数的符合高斯分布的关系可知，生成的随机数是逐渐增大或者逐渐减小！
* 第35堂课示例：随机数
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int rands;
srand((unsigned)time(NULL));
rands = rand();
printf("rand number is %d\n", rands);
printf("rand number2 is %d\n", rand());
return 0;
}
生成一定范围随机数
在实际编程开发中，实际需求往往是一定范围内的随机数，对于产生一定范围的随机数，就需要使用一定的技巧了，常用的方法是取模运算，再加上一个加法运算：
int a = rand() % 10; //产生0~9的随机数，注意10会被整除
如果要规定上下限：
int a = rand() % 51 + 100; //产生100~150的随机数
分析：取模即取余，rand()%51+13，看成两部分：rand()%51是产生 0~50 的随机数，后面+100保证 a 最小只能是 100，最大就是 50+100=150。
/**
* 第35堂课示例：有区间的随机数
* 例如：100~150之间的数字
* 郑凯
* 2020年5月25日
* */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int rands;
srand((unsigned)time(NULL));
rands = rand() % 51 + 100;
printf("rand number is %d\n", rands);
return 0;
}
根据种子与随机数的符合高斯分布的关系可知，生成的随机数是逐渐增大或者逐渐减小。
#2020学习打卡##C程序设计语言# C语言实现快速排序
C语言 • zkbhj 发表了文章 • 0 个评论 • 1267 次浏览 • 2020-04-23 17:24
关于什么是快速排序，可以参考文章 ：什么是快速排序。里面有介绍快速排序的方法以及和冒泡排序的区别，还有PHP版本实现快速排序的方法。本文章只讨论C语言实现的一种方式。#include <stdio.h>
//快速排序算法(从小到大)
//arr:需要排序的数组，begin:需要排序的区间左边界，end:需要排序的区间的右边界
void quickSort(int *arr,int begin,int end)
{
//如果区间不只一个数
if(begin < end)
{
int temp = arr[begin]; //将区间的第一个数作为基准数
int i = begin; //从左到右进行查找时的“指针”，指示当前左位置
int j = end; //从右到左进行查找时的“指针”，指示当前右位置
//不重复遍历
while(i < j)
{
//当右边的数大于基准数时，略过，继续向左查找
//不满足条件时跳出循环，此时的j对应的元素是小于基准元素的
while(i<j && arr[j] > temp)
j--;
//将右边小于等于基准元素的数填入右边相应位置
arr[i] = arr[j];
//当左边的数小于等于基准数时，略过，继续向右查找
//(重复的基准元素集合到左区间)
//不满足条件时跳出循环，此时的i对应的元素是大于等于基准元素的
while(i<j && arr[i] <= temp)
i++;
//将左边大于基准元素的数填入左边相应位置
arr[j] = arr[i];
}
//将基准元素填入相应位置
arr[i] = temp;
//此时的i即为基准元素的位置
//对基准元素的左边子区间进行相似的快速排序
quickSort(arr,begin,i-1);
//对基准元素的右边子区间进行相似的快速排序
quickSort(arr,i+1,end);
}
//如果区间只有一个数，则返回
else
return;
}
int main()
{
int num[12] = {23,45,17,11,13,89,72,26,3,17,11,13};
int n = 12;
quickSort(num,0,n-1);
printf("排序后的数组为：\n");
// for(int i=0;i<n;i++)
// printf("%d ", num[i]);
int *p = num;
while(n>0) {
n--;
printf("%d ",*p++);
}
return 0;
}
[/i][/i][/i][/i][/i][i][i][i][i]https://github.com/happy-hacki ... ort.c[/i][/i][/i][/i] 查看全部
//快速排序算法(从小到大)
//arr:需要排序的数组，begin:需要排序的区间左边界，end:需要排序的区间的右边界
void quickSort(int *arr,int begin,int end)
{
//如果区间不只一个数
if(begin < end)
{
int temp = arr[begin]; //将区间的第一个数作为基准数
int i = begin; //从左到右进行查找时的“指针”，指示当前左位置
int j = end; //从右到左进行查找时的“指针”，指示当前右位置
//不重复遍历
while(i < j)
{
//当右边的数大于基准数时，略过，继续向左查找
//不满足条件时跳出循环，此时的j对应的元素是小于基准元素的
while(i<j && arr[j] > temp)
j--;
//将右边小于等于基准元素的数填入右边相应位置
arr[i] = arr[j];
//当左边的数小于等于基准数时，略过，继续向右查找
//(重复的基准元素集合到左区间)
//不满足条件时跳出循环，此时的i对应的元素是大于等于基准元素的
while(i<j && arr[i] <= temp)
i++;
//将左边大于基准元素的数填入左边相应位置
arr[j] = arr[i];
}
//将基准元素填入相应位置
arr[i] = temp;
//此时的i即为基准元素的位置
//对基准元素的左边子区间进行相似的快速排序
quickSort(arr,begin,i-1);
//对基准元素的右边子区间进行相似的快速排序
quickSort(arr,i+1,end);
}
//如果区间只有一个数，则返回
else
return;
}
int main()
{
int num[12] = {23,45,17,11,13,89,72,26,3,17,11,13};
int n = 12;
quickSort(num,0,n-1);
printf("排序后的数组为：\n");
// for(int i=0;i<n;i++)
// printf("%d ", num[i]);
int *p = num;
while(n>0) {
n--;
printf("%d ",*p++);
}
return 0;
}
[/i][/i][/i][/i][/i][i][i][i][i]https://github.com/happy-hacki ... ort.c[/i][/i][/i][/i] 查看全部
关于什么是快速排序，可以参考文章 ：什么是快速排序。里面有介绍快速排序的方法以及和冒泡排序的区别，还有PHP版本实现快速排序的方法。本文章只讨论C语言实现的一种方式。
#include <stdio.h>[i][i][i][i]https://github.com/happy-hacki ... ort.c[/i][/i][/i][/i]
//快速排序算法(从小到大)
//arr:需要排序的数组，begin:需要排序的区间左边界，end:需要排序的区间的右边界
void quickSort(int *arr,int begin,int end)
{
//如果区间不只一个数
if(begin < end)
{
int temp = arr[begin]; //将区间的第一个数作为基准数
int i = begin; //从左到右进行查找时的“指针”，指示当前左位置
int j = end; //从右到左进行查找时的“指针”，指示当前右位置
//不重复遍历
while(i < j)
{
//当右边的数大于基准数时，略过，继续向左查找
//不满足条件时跳出循环，此时的j对应的元素是小于基准元素的
while(i<j && arr[j] > temp)
j--;
//将右边小于等于基准元素的数填入右边相应位置
arr[i] = arr[j];
//当左边的数小于等于基准数时，略过，继续向右查找
//(重复的基准元素集合到左区间)
//不满足条件时跳出循环，此时的i对应的元素是大于等于基准元素的
while(i<j && arr[i] <= temp)
i++;
//将左边大于基准元素的数填入左边相应位置
arr[j] = arr[i];
}
//将基准元素填入相应位置
arr[i] = temp;
//此时的i即为基准元素的位置
//对基准元素的左边子区间进行相似的快速排序
quickSort(arr,begin,i-1);
//对基准元素的右边子区间进行相似的快速排序
quickSort(arr,i+1,end);
}
//如果区间只有一个数，则返回
else
return;
}
int main()
{
int num[12] = {23,45,17,11,13,89,72,26,3,17,11,13};
int n = 12;
quickSort(num,0,n-1);
printf("排序后的数组为：\n");
// for(int i=0;i<n;i++)
// printf("%d ", num[i]);
int *p = num;
while(n>0) {
n--;
printf("%d ",*p++);
}
return 0;
}
[/i][/i][/i][/i][/i]
序列化结构数据方法ProtoBuf使用（PHP和Go）
专业名词 • zkbhj 发表了文章 • 0 个评论 • 2221 次浏览 • 2020-04-13 17:24
一、在PHP下使用ProtoBuf
PHP如果要使用protobuf 需要安装 protoc+ 安装protobuf composer包
protoc用于根据protobuf数据结构文件(.proto)生成对应的类，用于生成protobuf文件安装 google/protobuf composer 包composer require google/protobuf
怎么用呢？开搞！
1、首先，需要定一个消息类型。创建一个关于Person的定义文件（以.proto为后缀），如示例为person.proto，文件内容如下：
syntax="proto3";
package test;
message Person{
string name=1;//姓名
int32 age=2;//年龄
bool sex=3;//性别
}
syntax="proto3":表明使用的是proto3格式，如果不指定则为proto2package test:定义包名为test，生成类时，会产生一个目录为testmessage Person:消息主体内容，里面为各个字段的定义
2、生成对应的PHP类
定义好Person的格式后，该格式如果不生成我们所需要的类库，其实是无任何意义的，还google提供一个工具protoc生成我们要的类库。也就是最开始说的 protoc！
proto 最新版的下载地址是：最新3.11.3。可以通过 官方包Release 进行有选择的下载。
tar -zxvf protobuf-php-3.11.3.tar.gz
cd protobuf-3.11.3
./configure --prefix=/usr/local/protobuf
make
make install解压安装完后，就可以通过下面的命令，生成对应的类库了：
/usr/
local/protobuf/bin/protoc --php_out=./ person.proto生成后将在当前目录产生如下文件：
GPBMetadata/Person.phpTest/Person.php
3、类库生成完了，就可以在PHP项目中使用ProtoBuf了：
在PHP中使用ProtoBuf依赖一个protobuf的扩展，目前提供两种方式进行使用：
php的c扩展，php的lib扩展包，
这两者均可在刚才下载包里可以找到。
另外，也可以使用composer进行安装该依赖扩展：
composer require google/protobuf
这里我主要是使用composer安装，应该它可以帮我产生autoload。安装好依赖后，我们就可以开始在php环境下使用protobuf了。
序列化
<?php
include 'vendor/autoload.php';
include 'GPBMetadata/Person.php';
include 'Test/Person.php';
$bindata = file_get_contents('./data.bin');
$person = new Test\Person();
$person->mergeFromString($bindata);
echo $person->getName();运行后，产生的data.bin,只有14Byte
反序列化
<?php
include 'vendor/autoload.php';
include 'GPBMetadata/Person.php';
include 'Test/Person.php';
$bindata = file_get_contents('./data.bin');
$person = new Test\Person();
$person->mergeFromString($bindata);
echo $person->getName();PHP常用的使用方法：
序列化：
1、serializeToString：序列化成二进制字符串
2、serializeToJsonString：序列化成JSON字符串
反序列化：
1、mergeFromString：二进制字符串反序列化
2、mergeFromJsonString：Json字符串反序列化
二、在Golang下使用ProtoBuf
安装protoc的方法和PHP中类型，编译安装即可。
安装好之后，需要安装ProtoBuf的编译器插件：protoc-gen-go：
进入GOPATH目录，运行：
go get -u github.com/golang/protobuf/protoc-gen-go 如果成功，会在GOPATH/bin下生成protoc-gen-go.exe文件（Windows上）。
1、准备好之后，就可以开始写proto文件了。假设文件目录为：
$GOPATH/src/test/protobuf/pb/user.proto代码如下：
//指定版本
//注意proto3与proto2的写法有些不同
syntax = "proto3";
//包名，通过protoc生成时go文件时
package test;
//手机类型
//枚举类型第一个字段必须为0
enum PhoneType {
HOME = 0;
WORK = 1;
}
//手机
message Phone {
PhoneType type = 1;
string number = 2;
}
//人
message Person {
//后面的数字表示标识号
int32 id = 1;
string name = 2;
//repeated表示可重复
//可以有多个手机
repeated Phone phones = 3;
}
//联系簿
message ContactBook {
repeated Person persons = 1;
}然后运行如下命令：
protoc --go_out=. *.proto
会生成一个user.pb.go的文件。
2、使用：
package main;
import (
"github.com/golang/protobuf/proto"
"go_dev/kongji/proto/test"
"io/ioutil"
"os"
"fmt"
)
func write() {
p1 := &test.Person{
Id: 1,
Name: "小张",
Phones: []*test.Phone{
{test.PhoneType_HOME, "111111111"},
{test.PhoneType_WORK, "222222222"},
},
};
p2 := &test.Person{
Id: 2,
Name: "小王",
Phones: []*test.Phone{
{test.PhoneType_HOME, "333333333"},
{test.PhoneType_WORK, "444444444"},
},
};
//创建地址簿
book := &test.ContactBook{};
book.Persons = append(book.Persons, p1);
book.Persons = append(book.Persons, p2);
//编码数据
data, _ := proto.Marshal(book);
//把数据写入文件
ioutil.WriteFile("./test.txt", data, os.ModePerm);
}
func read() {
//读取文件数据
data, _ := ioutil.ReadFile("./test.txt");
book := &test.ContactBook{};
//解码数据
proto.Unmarshal(data, book);
for _, v := range book.Persons {
fmt.Println(v.Id, v.Name);
for _, vv := range v.Phones {
fmt.Println(vv.Type, vv.Number);
}
}
}
func main() {
write();
read();
}
内容整理自下面链接：
https://www.jianshu.com/p/ce098058edf0
https://developers.google.cn/protocol-buffers/docs/gotutorial
https://developers.google.cn/protocol-buffers/docs/reference/go-generated
查看全部
PHP如果要使用protobuf 需要安装 protoc+ 安装protobuf composer包
protoc用于根据protobuf数据结构文件(.proto)生成对应的类，用于生成protobuf文件安装 google/protobuf composer 包composer require google/protobuf
怎么用呢？开搞！
1、首先，需要定一个消息类型。创建一个关于Person的定义文件（以.proto为后缀），如示例为person.proto，文件内容如下：
syntax="proto3";
package test;
message Person{
string name=1;//姓名
int32 age=2;//年龄
bool sex=3;//性别
}
syntax="proto3":表明使用的是proto3格式，如果不指定则为proto2package test:定义包名为test，生成类时，会产生一个目录为testmessage Person:消息主体内容，里面为各个字段的定义
2、生成对应的PHP类
定义好Person的格式后，该格式如果不生成我们所需要的类库，其实是无任何意义的，还google提供一个工具protoc生成我们要的类库。也就是最开始说的 protoc！
proto 最新版的下载地址是：最新3.11.3。可以通过 官方包Release 进行有选择的下载。
tar -zxvf protobuf-php-3.11.3.tar.gz
cd protobuf-3.11.3
./configure --prefix=/usr/local/protobuf
make
make install解压安装完后，就可以通过下面的命令，生成对应的类库了：
/usr/
local/protobuf/bin/protoc --php_out=./ person.proto生成后将在当前目录产生如下文件：
GPBMetadata/Person.phpTest/Person.php
3、类库生成完了，就可以在PHP项目中使用ProtoBuf了：
在PHP中使用ProtoBuf依赖一个protobuf的扩展，目前提供两种方式进行使用：
php的c扩展，php的lib扩展包，
这两者均可在刚才下载包里可以找到。
另外，也可以使用composer进行安装该依赖扩展：
composer require google/protobuf
这里我主要是使用composer安装，应该它可以帮我产生autoload。安装好依赖后，我们就可以开始在php环境下使用protobuf了。
序列化
<?php
include 'vendor/autoload.php';
include 'GPBMetadata/Person.php';
include 'Test/Person.php';
$bindata = file_get_contents('./data.bin');
$person = new Test\Person();
$person->mergeFromString($bindata);
echo $person->getName();运行后，产生的data.bin,只有14Byte
反序列化
<?php
include 'vendor/autoload.php';
include 'GPBMetadata/Person.php';
include 'Test/Person.php';
$bindata = file_get_contents('./data.bin');
$person = new Test\Person();
$person->mergeFromString($bindata);
echo $person->getName();PHP常用的使用方法：
序列化：
1、serializeToString：序列化成二进制字符串
2、serializeToJsonString：序列化成JSON字符串
反序列化：
1、mergeFromString：二进制字符串反序列化
2、mergeFromJsonString：Json字符串反序列化
二、在Golang下使用ProtoBuf
安装protoc的方法和PHP中类型，编译安装即可。
安装好之后，需要安装ProtoBuf的编译器插件：protoc-gen-go：
进入GOPATH目录，运行：
go get -u github.com/golang/protobuf/protoc-gen-go 如果成功，会在GOPATH/bin下生成protoc-gen-go.exe文件（Windows上）。
1、准备好之后，就可以开始写proto文件了。假设文件目录为：
$GOPATH/src/test/protobuf/pb/user.proto代码如下：
//指定版本
//注意proto3与proto2的写法有些不同
syntax = "proto3";
//包名，通过protoc生成时go文件时
package test;
//手机类型
//枚举类型第一个字段必须为0
enum PhoneType {
HOME = 0;
WORK = 1;
}
//手机
message Phone {
PhoneType type = 1;
string number = 2;
}
//人
message Person {
//后面的数字表示标识号
int32 id = 1;
string name = 2;
//repeated表示可重复
//可以有多个手机
repeated Phone phones = 3;
}
//联系簿
message ContactBook {
repeated Person persons = 1;
}然后运行如下命令：
protoc --go_out=. *.proto
会生成一个user.pb.go的文件。
2、使用：
package main;
import (
"github.com/golang/protobuf/proto"
"go_dev/kongji/proto/test"
"io/ioutil"
"os"
"fmt"
)
func write() {
p1 := &test.Person{
Id: 1,
Name: "小张",
Phones: []*test.Phone{
{test.PhoneType_HOME, "111111111"},
{test.PhoneType_WORK, "222222222"},
},
};
p2 := &test.Person{
Id: 2,
Name: "小王",
Phones: []*test.Phone{
{test.PhoneType_HOME, "333333333"},
{test.PhoneType_WORK, "444444444"},
},
};
//创建地址簿
book := &test.ContactBook{};
book.Persons = append(book.Persons, p1);
book.Persons = append(book.Persons, p2);
//编码数据
data, _ := proto.Marshal(book);
//把数据写入文件
ioutil.WriteFile("./test.txt", data, os.ModePerm);
}
func read() {
//读取文件数据
data, _ := ioutil.ReadFile("./test.txt");
book := &test.ContactBook{};
//解码数据
proto.Unmarshal(data, book);
for _, v := range book.Persons {
fmt.Println(v.Id, v.Name);
for _, vv := range v.Phones {
fmt.Println(vv.Type, vv.Number);
}
}
}
func main() {
write();
read();
}
内容整理自下面链接：
https://www.jianshu.com/p/ce098058edf0
https://developers.google.cn/protocol-buffers/docs/gotutorial
https://developers.google.cn/protocol-buffers/docs/reference/go-generated
查看全部
一、在PHP下使用ProtoBuf
PHP如果要使用protobuf 需要安装 protoc+ 安装protobuf composer包
怎么用呢？开搞！
1、首先，需要定一个消息类型。创建一个关于Person的定义文件（以.proto为后缀），如示例为person.proto，文件内容如下：
2、生成对应的PHP类
定义好Person的格式后，该格式如果不生成我们所需要的类库，其实是无任何意义的，还google提供一个工具protoc生成我们要的类库。也就是最开始说的 protoc！
proto 最新版的下载地址是：最新3.11.3。可以通过 官方包Release 进行有选择的下载。
3、类库生成完了，就可以在PHP项目中使用ProtoBuf了：
在PHP中使用ProtoBuf依赖一个protobuf的扩展，目前提供两种方式进行使用：
这两者均可在刚才下载包里可以找到。
另外，也可以使用composer进行安装该依赖扩展：
这里我主要是使用composer安装，应该它可以帮我产生autoload。安装好依赖后，我们就可以开始在php环境下使用protobuf了。
序列化
反序列化
序列化：
1、serializeToString：序列化成二进制字符串
2、serializeToJsonString：序列化成JSON字符串
反序列化：
1、mergeFromString：二进制字符串反序列化
2、mergeFromJsonString：Json字符串反序列化
二、在Golang下使用ProtoBuf
安装protoc的方法和PHP中类型，编译安装即可。
安装好之后，需要安装ProtoBuf的编译器插件：protoc-gen-go：
进入GOPATH目录，运行：
1、准备好之后，就可以开始写proto文件了。假设文件目录为：
2、使用：
内容整理自下面链接：
https://www.jianshu.com/p/ce098058edf0
https://developers.google.cn/protocol-buffers/docs/gotutorial
https://developers.google.cn/protocol-buffers/docs/reference/go-generated
PHP如果要使用protobuf 需要安装 protoc+ 安装protobuf composer包
- protoc用于根据protobuf数据结构文件(.proto)生成对应的类，用于生成protobuf文件
- 安装 google/protobuf composer 包composer require google/protobuf
怎么用呢？开搞！
1、首先，需要定一个消息类型。创建一个关于Person的定义文件（以.proto为后缀），如示例为person.proto，文件内容如下：
syntax="proto3";
package test;
message Person{
string name=1;//姓名
int32 age=2;//年龄
bool sex=3;//性别
}
- syntax="proto3":表明使用的是proto3格式，如果不指定则为proto2
- package test:定义包名为test，生成类时，会产生一个目录为test
- message Person:消息主体内容，里面为各个字段的定义
2、生成对应的PHP类
定义好Person的格式后，该格式如果不生成我们所需要的类库，其实是无任何意义的，还google提供一个工具protoc生成我们要的类库。也就是最开始说的 protoc！
proto 最新版的下载地址是：最新3.11.3。可以通过 官方包Release 进行有选择的下载。
tar -zxvf protobuf-php-3.11.3.tar.gz解压安装完后，就可以通过下面的命令，生成对应的类库了：
cd protobuf-3.11.3
./configure --prefix=/usr/local/protobuf
make
make install
/usr/生成后将在当前目录产生如下文件：
local/protobuf/bin/protoc --php_out=./ person.proto
- GPBMetadata/Person.php
- Test/Person.php
3、类库生成完了，就可以在PHP项目中使用ProtoBuf了：
在PHP中使用ProtoBuf依赖一个protobuf的扩展，目前提供两种方式进行使用：
- php的c扩展，
- php的lib扩展包，
这两者均可在刚才下载包里可以找到。
另外，也可以使用composer进行安装该依赖扩展：
composer require google/protobuf
这里我主要是使用composer安装，应该它可以帮我产生autoload。安装好依赖后，我们就可以开始在php环境下使用protobuf了。
序列化
<?php运行后，产生的data.bin,只有14Byte
include 'vendor/autoload.php';
include 'GPBMetadata/Person.php';
include 'Test/Person.php';
$bindata = file_get_contents('./data.bin');
$person = new Test\Person();
$person->mergeFromString($bindata);
echo $person->getName();
反序列化
<?phpPHP常用的使用方法：
include 'vendor/autoload.php';
include 'GPBMetadata/Person.php';
include 'Test/Person.php';
$bindata = file_get_contents('./data.bin');
$person = new Test\Person();
$person->mergeFromString($bindata);
echo $person->getName();
序列化：
1、serializeToString：序列化成二进制字符串
2、serializeToJsonString：序列化成JSON字符串
反序列化：
1、mergeFromString：二进制字符串反序列化
2、mergeFromJsonString：Json字符串反序列化
二、在Golang下使用ProtoBuf
安装protoc的方法和PHP中类型，编译安装即可。
安装好之后，需要安装ProtoBuf的编译器插件：protoc-gen-go：
进入GOPATH目录，运行：
go get -u github.com/golang/protobuf/protoc-gen-go如果成功，会在GOPATH/bin下生成protoc-gen-go.exe文件（Windows上）。
1、准备好之后，就可以开始写proto文件了。假设文件目录为：
$GOPATH/src/test/protobuf/pb/user.proto代码如下：
//指定版本然后运行如下命令：
//注意proto3与proto2的写法有些不同
syntax = "proto3";
//包名，通过protoc生成时go文件时
package test;
//手机类型
//枚举类型第一个字段必须为0
enum PhoneType {
HOME = 0;
WORK = 1;
}
//手机
message Phone {
PhoneType type = 1;
string number = 2;
}
//人
message Person {
//后面的数字表示标识号
int32 id = 1;
string name = 2;
//repeated表示可重复
//可以有多个手机
repeated Phone phones = 3;
}
//联系簿
message ContactBook {
repeated Person persons = 1;
}
protoc --go_out=. *.proto会生成一个user.pb.go的文件。
2、使用：
package main;
import (
"github.com/golang/protobuf/proto"
"go_dev/kongji/proto/test"
"io/ioutil"
"os"
"fmt"
)
func write() {
p1 := &test.Person{
Id: 1,
Name: "小张",
Phones: []*test.Phone{
{test.PhoneType_HOME, "111111111"},
{test.PhoneType_WORK, "222222222"},
},
};
p2 := &test.Person{
Id: 2,
Name: "小王",
Phones: []*test.Phone{
{test.PhoneType_HOME, "333333333"},
{test.PhoneType_WORK, "444444444"},
},
};
//创建地址簿
book := &test.ContactBook{};
book.Persons = append(book.Persons, p1);
book.Persons = append(book.Persons, p2);
//编码数据
data, _ := proto.Marshal(book);
//把数据写入文件
ioutil.WriteFile("./test.txt", data, os.ModePerm);
}
func read() {
//读取文件数据
data, _ := ioutil.ReadFile("./test.txt");
book := &test.ContactBook{};
//解码数据
proto.Unmarshal(data, book);
for _, v := range book.Persons {
fmt.Println(v.Id, v.Name);
for _, vv := range v.Phones {
fmt.Println(vv.Type, vv.Number);
}
}
}
func main() {
write();
read();
}
内容整理自下面链接：
https://www.jianshu.com/p/ce098058edf0
https://developers.google.cn/protocol-buffers/docs/gotutorial
https://developers.google.cn/protocol-buffers/docs/reference/go-generated
PHP代码总结：时间处理相关的辅助类
PHP • zkbhj 发表了文章 • 0 个评论 • 2494 次浏览 • 2019-05-30 14:49
class TimeHelper
{
/**
* 得到当前时间的毫秒时间戳
* @return float 13位毫秒时间戳
*/
public static function getCurTimeMsec()
{
list($t1, $t2) = explode(' ', microtime());
return (float)sprintf('%.0f',(floatval($t1)+floatval($t2))*1000);
}
/**
* 获取当前时间17位的毫秒时间格式时间点（2017 07 29 21 44 43 129）
* @return integer
*/
public static function getCurTimeMsecFormat()
{
list($u_sec, $sec) = explode(' ', microtime());
return intval(date('YmdHis', intval($sec)) . str_pad(round(floatval($u_sec) * 1000), 3, 0, STR_PAD_LEFT));
}
/**
* 将20200629000000格式的日期转换成0000-00-00 00:00:00格式
*/
public static function dateNormalization($date)
{
if (strlen($date) == 14) {
return preg_replace('/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', "$1-$2-$3 $4:$5:$6", $date);
}
return $date;
}
/**
* 将17位的毫秒时间格式（2017 07 29 21 44 43 129）转换成毫秒时间戳格式(15XXX)
*/
public static function dateToMescNormalization($date)
{
if (strlen($date) == 17) {
$secDate = preg_replace('/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', "$1-$2-$3 $4:$5:$6", substr($date,0,14));
return strtotime($secDate).substr($date,14,3);
}
return $date;
}
} 查看全部
{
/**
* 得到当前时间的毫秒时间戳
* @return float 13位毫秒时间戳
*/
public static function getCurTimeMsec()
{
list($t1, $t2) = explode(' ', microtime());
return (float)sprintf('%.0f',(floatval($t1)+floatval($t2))*1000);
}
/**
* 获取当前时间17位的毫秒时间格式时间点（2017 07 29 21 44 43 129）
* @return integer
*/
public static function getCurTimeMsecFormat()
{
list($u_sec, $sec) = explode(' ', microtime());
return intval(date('YmdHis', intval($sec)) . str_pad(round(floatval($u_sec) * 1000), 3, 0, STR_PAD_LEFT));
}
/**
* 将20200629000000格式的日期转换成0000-00-00 00:00:00格式
*/
public static function dateNormalization($date)
{
if (strlen($date) == 14) {
return preg_replace('/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', "$1-$2-$3 $4:$5:$6", $date);
}
return $date;
}
/**
* 将17位的毫秒时间格式（2017 07 29 21 44 43 129）转换成毫秒时间戳格式(15XXX)
*/
public static function dateToMescNormalization($date)
{
if (strlen($date) == 17) {
$secDate = preg_replace('/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', "$1-$2-$3 $4:$5:$6", substr($date,0,14));
return strtotime($secDate).substr($date,14,3);
}
return $date;
}
} 查看全部
class TimeHelper
{
/**
* 得到当前时间的毫秒时间戳
* @return float 13位毫秒时间戳
*/
public static function getCurTimeMsec()
{
list($t1, $t2) = explode(' ', microtime());
return (float)sprintf('%.0f',(floatval($t1)+floatval($t2))*1000);
}
/**
* 获取当前时间17位的毫秒时间格式时间点（2017 07 29 21 44 43 129）
* @return integer
*/
public static function getCurTimeMsecFormat()
{
list($u_sec, $sec) = explode(' ', microtime());
return intval(date('YmdHis', intval($sec)) . str_pad(round(floatval($u_sec) * 1000), 3, 0, STR_PAD_LEFT));
}
/**
* 将20200629000000格式的日期转换成0000-00-00 00:00:00格式
*/
public static function dateNormalization($date)
{
if (strlen($date) == 14) {
return preg_replace('/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', "$1-$2-$3 $4:$5:$6", $date);
}
return $date;
}
/**
* 将17位的毫秒时间格式（2017 07 29 21 44 43 129）转换成毫秒时间戳格式(15XXX)
*/
public static function dateToMescNormalization($date)
{
if (strlen($date) == 17) {
$secDate = preg_replace('/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', "$1-$2-$3 $4:$5:$6", substr($date,0,14));
return strtotime($secDate).substr($date,14,3);
}
return $date;
}
}