LeetCode中文网第125题 验证回文串

定义：

回文串：从前往后读和从后往前读都一样的字符串，例如 radar、toot，以及 madam。

题目：

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

Go语言实现1

func isPalindrome(s string) bool {
	var srcStr []rune
	var reverseStr []rune
	for _, char := range s {
                // 数字或字母统一小写才放入
		if unicode.IsNumber(char) ||
			unicode.IsLetter(char) {
			srcStr = append(srcStr, unicode.ToLower(char))
		}
	}
        // 把srcStr数据拷贝到拟翻转后的reverseStr切片里
	reverseStr = append(reverseStr, srcStr...)
        // 切片数据翻转
	reverseAny(reverseStr)
        // 比较翻转前后的切片数据是否一样，一致则为回文，否则不为回文
	if string(srcStr) == string(reverseStr) {
		return true
	} else {
		return false
	}
}

func reverseAny(s interface{}) {
	n := reflect.ValueOf(s).Len()
	swap := reflect.Swapper(s)
	for i, j := 0, n-1; i < j; i, j = i+1, j-1 {
		swap(i, j)
	}
}

运行结果

执行结果：通过
执行用时：4 ms
内存消耗：5 MB

Go语言实现2

这里利用了双端队列数据结构进行同时从两头取数据，如果出现不相等，则明显不是回文。

func isPalindrome(s string) bool {
	// 构建双端队列
	dqueue := NewArrayDeque()
	for _, char := range s {
		// 数字或字母统一小写才放入队列
		if unicode.IsNumber(char) ||
			unicode.IsLetter(char) {
			dqueue.AddFront(unicode.ToLower(char))
		}
	}
	// 判断是否为回文, 默认为回文
	isPal := true
	// 从两端提取字符，判断是否相同，出现不同则为非回文
	// 直到队列长度为1或为2时(两端相同)则为回文
	for dqueue.Len() > 1 && isPal {
		// 获取队尾数据
		left := dqueue.RemoveBack()
		// 获取队首数据
		right := dqueue.RemoveFront()
		// 判断是否相同
		if left != right {
			isPal = false
			break
		}
	}
	return isPal
}

type Element interface{}

type Deque interface {
	// 向队首添加元素
	AddFront(e ...Element)

	// 向队尾添加元素
	AddBack(e ...Element)

	// 队首元素出队
	RemoveFront() Element

	// 队尾元素出队
	RemoveBack() Element

	// 队列长度
	Len() int
}

type ArrayDeque []Element

func (s *ArrayDeque) AddFront(e ...Element) {
	ln := len(e)
	rev := make([]Element, ln)
	for i, v := range e {
		rev[ln-i-1] = v
	}
	*s = append(rev, *s...)
}

func (s *ArrayDeque) AddBack(e ...Element) {
	*s = append(*s, e...)
}

func (s *ArrayDeque) RemoveFront() Element {
	if s.Empty() {
		return nil
	}
	v := (*s)[0]

	// 出队
	*s = (*s)[1:]
	return v

}

func (s *ArrayDeque) RemoveBack() Element {
	if s.Empty() {
		return nil
	}
	ln := len(*s)
	v := (*s)[ln-1]

	// 出队
	*s = (*s)[:ln-1]
	return v
}

func (s *ArrayDeque) Size() int {
	return len(*s)
}

func NewArrayDeque() Deque {
	return &ArrayDeque{}
}

以上为验证回文的两种解题思路的Golang语言的实现。