Go 实现的一些算法题

最近在学习算法，因为大学的时候，没有学好，现在就恶补一下。

下面代码是用golang实现的一部门的，之后会慢慢的在进行添加。package main

import (
	"fmt"
	"regexp"
	"strings"
)

//翻转数组
func reverseArr(arr []int) []int {
	for i := 0;i<len(arr)/2;i++{
		arr[i],arr[len(arr)-i-1] = arr[len(arr)-i-1],arr[i]
	}
	return arr
}

//原地删除数组指定值，不要用新的数组
func DeleteArr(arr []int, key int) []int {
	for i :=0;i<len(arr);{
		if arr[i] == key{
			arr = append(arr[:i],arr[i+1:]...)
		}else{
			i++
		}
	}
	return arr
}

//给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次
func DeleteDuplicates(arr []int) []int {
	//一定是一个排序数组，如果不是排序数组，就需要先排序
	for i :=0;i<len(arr)-1;{
		if arr[i] == arr[i+1] {
			arr = append(arr[:i],arr[i+1:]...)
		}else{
			i++
		}
	}
	return arr
}

//给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一
//如果加1等于10 ，需要进位
func AddOne(arr []int) []int {
	var result []int
	addOne :=0
	for i :=len(arr)-1;i>=0;i--{
		arr[i]+=addOne
		addOne = 0
		if i == len(arr)-1{
			arr[i]++
		}
		if arr[i] == 10{
			addOne = 1
			arr[i] = arr[i]%10
		}
	}
	if addOne == 1{
		result = make([]int,1)
		result[0] =1
		result = append(result,arr...)
	}else{
		result = arr
	}
	return result
}

//奇数偶数排序，奇数拍前面，偶数拍后面
func OddSortArr(arr []int) []int {
	j :=0
	for i :=0;i<len(arr);i++{
		if arr[i] %2 !=0{
			arr[i],arr[j] = arr[j],arr[i]
			j++
		}
	}
	return arr
}
//给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

func TwoSum(arr []int,target int) []int {
	var result []int
	m1 := make(map[int]int)
	for i,v := range arr{
		if val,exist := m1[target-v];exist{
			result = append(result,val)
			result = append(result,i)
		}
		m1[v] = i
	}
	return result
}


//将字符串翻转
func reverseString(str []byte) []byte {
	left :=0
	right := len(str)-1
	for left <right{
		str[left],str[right] = str[right],str[left]
		left++
		right--
	}
	return str
}
//判断是否是回文
func isHuiWen(str string) bool {
	reg := regexp.MustCompile(`[a-zA-Z]]`) //先将字符串的空格，符号去掉，只能字母
	strs := reg.FindAllString(str,-1)
	for i,j := 0,len(strs)-1;i<j;i,j = i+1,j-1{
		if strs[i] != strs[j] {
			return false
		}
	}
	return true
}

//两个数组取交集
func intersectArr(arr1,arr2 []int) []int {
	m1 := make(map[int]int)
	for _,v1 := range arr1{
		m1[v1] +=1
	}
	k:=0
	for _,v2 := range arr2{
		if m1[v2] >0{
			m1[v2]-=1
			arr2[k] = v2
			k++
		}
	}
	return arr2[0:k]
}

//获取最长公共前缀
func getLongText(arr []string) string{
	if len(arr) <1{
		return ""
	}
	prefix := arr[0]
	for _,val:=range arr{
		for strings.Index(val,prefix) != 0{
			if len(prefix) == 0{
				return ""
			}
			prefix = prefix[:len(prefix)-1]
		}
	}
	return prefix
}

//插入排序的实现方式1
func InsertSortOne(arr []int) []int {
	for i := 1;i<len(arr);i++{
		for j := i;j>0;j--{
			if arr[j]<arr[j-1]{
				arr[j],arr[j-1] = arr[j-1],arr[j]
			}
		}
	}
	return arr
}
//插入排序的实现方式2
func InsertSortTwo(arr []int) []int{
	for i := range arr {
		preIndex := i-1
		current := arr[i]
		for preIndex >=0 && arr[preIndex] >current{
			arr[preIndex+1] = arr[preIndex]
			preIndex -=1
		}
		arr[preIndex+1] = current
	}
	return arr
}

//选择排序
func SelectSort(arr []int) []int {
	for i :=0;i<len(arr)-1;i++{
		min := i
		for j := i+1;j<len(arr);j++{
			if arr[min] >arr[j]{
				min = j
			}
		}
		arr[min],arr[i] = arr[i],arr[min]
	}
	return arr
}


func main() {
	//arr := []int{1,2,3,4,5,5,6,9}
	//arr2 := []int{2,3,4,6,7}
	arr3 :=[]int{30,20,11,23,24,19,18,46}
	//fmt.Println(reverseArr(arr))
	//fmt.Println(DeleteArr(arr,4))
	//fmt.Println(DeleteDuplicates(arr))
	//fmt.Println(AddOne(arr))
	//fmt.Println(OddSortArr(arr))
	//fmt.Println(TwoSum(arr,10))
	//s2 := "A man, a plan, a canal: Panama"
	//fmt.Println(isHuiWen(s2))
	//fmt.Println(intersectArr(arr,arr2))
	//strs := []string{"flower","flow","flight"}
	//fmt.Println(getLongText(strs))

	//fmt.Println(InsertSortOne(arr3))
	//fmt.Println(InsertSortTwo(arr3))
	fmt.Println(SelectSort(arr3))
}

　　

//二分查找
func FindAll(arr []int ,k int) int {
	left,right,mid := 0,len(arr)-1,0
	for{
		mid = int(math.Floor(float64((left + right)/2)))
		if arr[mid] >k {
			right = mid -1
		}else if arr[mid] <k{
			left = mid+1
		}else{
			break
		}
		if left > right{
			mid = -1
			break
		}
	}
	return mid
}

　　

//快速排序
func quitSort(arr []int)[]int{
	if len(arr)<1{
		return arr
	}
	var left []int
	var right []int
	mid := arr[0]
	for i := 1;i<len(arr);i++{
		if arr[i]<=mid{
			left = append(left,arr[i])
		}else{
			right = append(right,arr[i])
		}
	}
	left = quitSort(left)
	right = quitSort(right)
	left = append(left,mid)
	left = append(left,right...)
	return left
}

　　

 合并两个有序数组，其实和合并两个有序链表是逻辑相似

//合并两个有序数组
func mergeArr(a, b []int) []int {
	alen := len(a)
	blen := len(b)
	clen := alen+blen

	result := make([]int,clen)

	aIndex := 0
	bIndex :=0
	cIndex := 0
	for aIndex <alen && bIndex <blen{
		if a[aIndex] <b[bIndex]{
			result[cIndex] = a[aIndex]
			cIndex++
			aIndex++
		}else{
			result[cIndex] = b[bIndex]
			cIndex++
			bIndex++
		}
	}
	if aIndex<alen{
		result[cIndex] = a[aIndex]
		cIndex++
		aIndex++
	}
	if bIndex<blen{
		result[cIndex] = b[bIndex]
		cIndex++
		aIndex++
	}
	return result
}