用go实现一些其他知识

1. 无重复最长字符串，假设有个字符串abcdcedecc，输出3，因为无重复的最长字符串为：abc

package main

import (
	"fmt"
	"strings"
)

func LengthString(s string) int {
	start := 0
	end := 0
	for i := 0; i < len(s); i++ {
		index := strings.Index(s[start:i],string(s[i]))
		if index == -1 && (i+1) > end {
			end = i + 1
		}else{
			start += index + 1
			end += index +1
		}
	}
	return end-start
}

func main() {
	s := "fa21eeee3456789eeeee"
	slen := LengthString(s)
	fmt.Println(slen)
}

2. go实现快排

package main
 
import (
   "fmt"
)
 
// 快速排序
// 说明
// 1 left 表示数组左边的下标
// 2 right 表示数组右边的下标
// 3 array 表示要排序的数组
func QuickSort(left int, right int, array *[9]int) {
   l := left
   r := right
   // pivot 是中轴， 支点
   pivot := array[(left+right)/2]
   temp := 0
   // for 循环的目标是将比 pivot 小的数放到左边，比 pivot 大的数放到右边
   for l < r {
      // 从 pivot 的左边找到大于等于pivot的值
      for array[l] < pivot {
         l++
      }
      // 从 pivot 的右边边找到小于等于pivot的值
      for array[r] > pivot {
         r--
      }
      // 1 >= r 表明本次分解任务完成, break
      if l >= r {
         break
      }
      // 交换
      temp = array[l]
      array[l] = array[r]
      array[r] = temp
      // 优化
      if array[l] == pivot {
         r--
      }
      if array[r] == pivot {
         l++
      }
   }
   // 如果  1== r, 再移动下
   if l == r {
      l++
      r--
   }
   // 向左递归
   if left < r {
      QuickSort(left, r, array)
   }
   // 向右递归
   if right > l {
      QuickSort(l, right, array)
   }
}
 
 
func main() {
   arr := [9]int{-9, 78, 0, 23, -567, 70, 123, 90, -23}
   // 调用快速排序
   QuickSort(0, len(arr)-1, &arr)
   fmt.Println(arr)
}

3. 用go实现反转链表

package main
 
 
type ListNode struct {
	Val int
	Next *ListNode
}

func reverseList(head *ListNode) *ListNode {
	cur := head
	var pre *ListNode = nil
	for cur != nil{
		pre, cur, cur.Next = cur, cur.Next, pre
	}
	return pre

}

4. 内存对齐(内存对齐讲解：地址)

package main

import (
	"fmt"
	"unsafe"
)

type A struct {
	a int32
	b int64
	c int32
}

type B struct {
	a int32
	b int32
	c int64
}

func main() {
	fmt.Println(unsafe.Sizeof(A{})) // 24
	fmt.Println(unsafe.Sizeof(B{})) // 16
}

6. 翻转字符串

package main

import (
	"fmt"
)
 
// 翻转字符串，可能包含有中文 数字 英文 要求翻转原有字符串 不创建新的存储空间
func reverse(str string) string {
	s := []rune(str)
	for i,j := 0, len(s) - 1; i < j; i,j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
	return string(s)
}

func main() {
	fmt.Println(reverse("白小黑45er"))
}