Golang算法

//两数之和
func twoSum(nums []int, target int) []int {
    container := map[int]int{}
	for i,v := range nums {
        tmp := target - v
        if v, ok := container[tmp]; ok {
			return []int{v, i}
		}
		container[v] = i
	}
	return nil
}

//两数相加
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
	ret := &ListNode{}
	tmp := ret
	carry := 0
	for {
	    v := 0   
		if l1 != nil {
			v = v + l1.Val
			l1 = l1.Next
		}
		if l2 != nil {
			v = v + l2.Val
			l2 = l2.Next
		}
		v = v + carry
        carry = 0
		if v > 9 {
			v = v - 10
			carry = 1
		}
		tmp.Val = v
		if l1 == nil && l2 == nil {
			break
		}
		tmp.Next = &ListNode{}
		tmp = tmp.Next
	}
	if carry == 1 {
		tmp.Next = &ListNode{Val : 1,Next : nil}
	}
	return ret
}

//最长无重复字符的子串（C++）
#include<iostream>
#include<set>
using namespace std;
int max(int a ,int b) {
    if (a >= b) {
        return a;
    } else {
        return b;
    }
}
int lengthOfLongestSubstring(string s) {
    set<char> my_set;
    int right = 0,left = 0,count = 0;
    while (right < s.size()){
        if (my_set.find(s[right]) == my_set.end()) {//没找到
            my_set.insert(s[right++]);
            count = max(my_set.size(),count);
        } else {
            my_set.earse(s[left++]);
        }
    }
    return count;
}

//最长无重复字符的子串（Golang）
func max(a int,b int)int {
    if a >= b {
        return a
    } else {
        return b
    }    
}

func lengthOfLongestSubstring(s string) int {
    var hash [256]int
    ret := 0 
    left := 0 
    for i := 0; i < len(s); i++ {
        if hash[s[i]] == 0 || hash[s[i]]< left {
            ret = max(ret, i -left+1)
        } else {
            left = hash[s[i]]
        }    
         hash[s[i]] = i + 1; 
    }    
    return ret
}

//两个排序数组的中位数
func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
	m := []int{}
	i, j := 0, 0
	if len(nums1) == 0 {
		m = nums2
	} else if len(nums2) == 0 {
		m = nums1
	} else {
		for {
			if nums1[i] < nums2[j] {
				m = append(m, nums1[i])
				i++
			} else if nums1[i] > nums2[j]{
				m = append(m, nums2[j])
				j++
			} else {
				m = append(m, nums1[i])
				m = append(m, nums2[j])
				j++
				i++
			}
			if i == len(nums1){
				for j != len(nums2) {
					m = append(m, nums2[j])
					j++
				} 
				break
			}
			if j == len(nums2){
				for i != len(nums1) {
					m = append(m, nums1[i])
					i++
				} 
				break
			}
		} 
	}
	size := len(m)
	if size%2 == 0{
		return float64((m[size/2]+m[size/2-1]))/2
	} else {
		return float64(m[size/2])
	}
}

//最长回文子串
func judge(s string) bool {
	left := 0
	right := len(s)-1
	if right ==0 {
		return true
	}
	for left < right{
		if s[left] == s[right] {
			left++
			right--
		} else {
			return false
		}
	}
	return true
}
func longestPalindrome(s string) string {
	count := 0
	max_ret := ""
    for i := 0; i < len(s); i++ {
		ret := ""
		for j := i; j < len(s); j++ {
			ret =  ret + string(s[j])
			k := judge(ret)
			if k {
				if len(ret) > count{
					max_ret = ret
					count = len(ret)
				}
			}
		}
	}
	return max_ret
}

//i am a student.转为student. a am i
func convert(s string) string {
	ret := strings.Split(s," ")
	str := ""
	for i :=len(ret)-1; i>=0; i-- {
		str = str + ret[i] + " "
	}
	return str
}

//给定一个 32 位有符号整数，将整数中的数字进行反转。
func reverse(x int) int {
	flag := ""
	if x < 0 {
		x = x * -1
		flag = "-"
	}
	ret := strconv.Itoa(x)
	for i := len(ret)-1; i >= 0; i-- {
		flag += string(ret[i])
	}
	retVal,_ := strconv.Atoi(flag)
	if retVal >= -2147483648 && retVal <= 2147483647{
		return retVal
	} else {
		return 0
	}
}