go语言学习笔记三

问题

给定一个无序数组arr，和一个逆序范围数组revicesArr，意思就是在数组这个值范围内arr逆序对儿是多少，再给定逆序调整范围power

思想

通过归并排序计算数组再powerf范围的逆序对儿。

go

go语言的循环只有for,当for中间有间隔的时候相当于c语言中的for,例如

for i :=0; i<100; i++{
}

当for只是跟循环条件时相当于c中的while循环

for L < R{
}

go语言的for循环还可以遍历索引和值，比如

for index, value := range (str:="巴黎圣日耳曼"){
}

 go语言中的break还可以指定结束哪一层的循环只要break后面跟着一个标签就行

func main() {

	label:
	for i := 1; i < 5; i++ {
		for j := 1; j < 5; j++ {
			if  i == 3{
				break label
			}
			fmt.Println("这时候的i为：", i)
		}
	}

	fmt.Println("程序执行完，终止")
}

 代码如下

package main

import (
	"fmt"
)

func Findmain() {
	var originArr [10]int
	var reverseArr [4]int
	for i := 0; i < 10; i++ {
		fmt.Scanf("%d", &originArr[i])
	}
	for i := 0; i < 4; i++ {
		fmt.Scanf("%d", &reverseArr[i])
	}
	var power int
	fmt.Scanf("power=%d", &power)
	ans := reversePair(originArr, reverseArr, power)
	for i := 0; i < len(reverseArr); i++ {
		fmt.Printf("%d ", ans[i])
	}

}

func reversePair(originArr [10]int, revericeArr [4]int, power int) [10000]int {
	reverse := copyOrigin(originArr)
	reverseFunc(reverse, 0, len(reverse)-1)
	var recodeUpPower [10000]int
	var recodeDownPower [10000]int
	process(originArr, 0, len(originArr)-1, recodeDownPower, power)
	process(reverse, 0, len(reverse)-1, recodeUpPower, power)
	var ans [10000]int
	for i := 0; i < len(revericeArr)-1; i++ {
		curPower := revericeArr[i]
		for p := 1; p <= curPower; p++ {
			t := recodeUpPower[p]
			recodeUpPower[p] = recodeDownPower[p]
			recodeDownPower[p] = t
		}
		for p := 1; p <= power; p++ {
			ans[i] += recodeDownPower[p]
		}
	}
	return ans
}
func copyOrigin(originArr [10]int) [10]int {
	//N :=len(originArr)
	var revese [10]int = originArr
	return revese
}
func reverseFunc(reverse [10]int, L int, R int) {

	for L < R {
		swap(reverse, L, R)
		L = L + 1
		R = R - 1
	}
}
func swap(reverse [10]int, L int, R int) {
	t := reverse[L]
	reverse[L] = reverse[R]
	reverse[R] = t
}
func process(array [10]int, L int, R int, recode [10000]int, power int) {
	if L >= R {
		return
	}
	mid := L + ((R - L) >> 1)
	process(array, L, mid, recode, power-1)
	process(array, mid+1, R, recode, power-1)
	recode[power] += merge(array, L, mid, R)
}
func merge(arr [10]int, L int, mid int, R int) int {
	N := R - L + 1
	var helper [10000]int
	pre := L
	pos := mid + 1
	index := 0
	ans := 0
	for pre <= mid && pos <= R {
		if arr[pre] > arr[pos] {
			ans += 1
		}
		if arr[pre] > arr[pos] {
			helper[index] = arr[pos]
			index += 1
			pos += 1
		} else {
			helper[index] = arr[pre]
			index += 1
			pre += 1
		}
	}
	for pre <= mid {
		helper[index] = arr[pre]
		index += 1
		pre += 1
	}
	for pos <= R {
		helper[index] = arr[pos]
		index += 1
		pos += 1
	}
	for i := 0; i < N; i++ {
		arr[L+i] = helper[i]
	}
	return ans
}