add

Author: limingzhong

src/linkedlist/list.go

@@ -1,6 +1,8 @@
 package linkedlist
 
-import "fmt"
+import (
+	"fmt"
+)
 
 type ListNode struct {
 	val  interface{}
@@ -96,3 +98,87 @@ func ReverseList(head *ListNode) *ListNode {
 
 	return pre
 }
+
+// 反转从位置  *m*  到  *n*  的链表。请使用一趟扫描完成反转。
+func ReverseListMN(head *ListNode, m, n int) *ListNode {
+	if m < 0 || m > n {
+		return head
+	}
+
+	dummy := &ListNode{}
+	dummy.next = head
+
+	i := 0
+	current := dummy
+	// 遍历跳过
+	nodeMPre := current
+	for current != nil && i < m {
+		nodeMPre = current
+		current = current.next
+		i++
+	}
+
+	// 遍历
+	var pre *ListNode
+	nodeM := current
+	for current != nil && i <= n {
+		temp := current.next
+		current.next = pre
+		pre = current
+		current = temp
+		i++
+	}
+
+	nodeMPre.next = pre
+	nodeM.next = current
+
+	return dummy.next
+}
+
+// 给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于  *x*  的节点都在大于或等于  *x*  的节点之前。
+// 思路：将大于 x 的节点，放到另外一个链表，最后连接这两个链表, 无需排序
+func PartitionX(head *ListNode, x int) *ListNode {
+	headDummy := &ListNode{}
+	tailDummy := &ListNode{}
+
+	headDummy.next = head
+	current := headDummy
+	tail := tailDummy
+	for current.next != nil {
+		if current.next.val.(int) < x {
+			current = current.next
+		} else {
+			tail.next = current.next
+			tail = tail.next
+			current.next = current.next.next
+		}
+	}
+
+	tail.next = nil
+	current.next = tailDummy.next
+
+	return headDummy.next
+}
+
+func Xxx() {
+	type A struct {
+		x int
+		y int
+		z []int
+	}
+	a := &A{
+		x: 0,
+		y: 1,
+		z: make([]int, 0),
+	}
+	a.z = append(a.z, 1)
+
+	fmt.Printf("a.ptr:%p a.x:%d a.y:%d, a.z:%v \n", a, a.x, a.y, a.z)
+
+	c := a
+	a.x = 10
+	a.y = 11
+	c.z = append(c.z, 10)
+	fmt.Printf("c.ptr:%p c.x:%d c.y:%d, c.z:%v \n", c, c.x, c.y, c.z)
+	fmt.Printf("a.ptr:%p a.x:%d a.y:%d, a.z:%v \n", a, a.x, a.y, a.z)
+}

src/linkedlist/list_test.go

@@ -31,3 +31,19 @@ func TestReverseList(t *testing.T) {
 	head.Print()
 	ReverseList(head).Print()
 }
+
+func TestReverseListMN(t *testing.T) {
+	head := NewIntList([]int{1, 2, 3, 4, 5})
+	head.Print()
+	ReverseListMN(head, 1, 3).Print()
+}
+
+func TestPartitionX(t *testing.T) {
+	head := NewIntList([]int{5, 4, 3, 1, 2})
+	head.Print()
+	PartitionX(head, 3).Print()
+}
+
+func TestXxx(t *testing.T) {
+	Xxx()
+}

src/nums/nums.go

@@ -0,0 +1,70 @@
+package nums
+
+import "sort"
+
+func SubSets(nums []int) [][]int {
+	if len(nums) == 0 {
+		return [][]int{{}}
+	}
+
+	cur := nums[len(nums)-1]
+	res := SubSets(nums[:len(nums)-1])
+	l := len(res)
+	for i := 0; i < l; i++ {
+		res = append(res, append(res[i], cur))
+	}
+	return res
+}
+
+func SubSetsV2(nums []int) [][]int {
+	var (
+		backtrack func(nums []int, track []int, res *[][]int)
+
+		res   = make([][]int, 0)
+		track = make([]int, 0)
+	)
+
+	backtrack = func(nums []int, track []int, res *[][]int) {
+		tmp := make([]int, len(track))
+		copy(tmp, track)
+		*res = append(*res, tmp)
+
+		for i := 0; i < len(nums); i++ {
+			track = append(track, nums[i])
+			backtrack(nums[i+1:], track, res)
+			track = track[:len(track)-1]
+		}
+	}
+
+	backtrack(nums, track, &res)
+
+	return res
+}
+
+func Combine(n, k int) [][]int {
+	var (
+		backtrack func(n, pos, k int, track []int, res *[][]int)
+
+		res   = make([][]int, 0)
+		track = make([]int, 0)
+	)
+
+	backtrack = func(n, pos, k int, track []int, res *[][]int) {
+		if len(track) == k {
+			ans := make([]int, k)
+			copy(ans, track)
+			*res = append(*res, ans)
+			return
+		}
+
+		for i := pos; i <= n; i++ {
+			track = append(track, i)
+			backtrack(n, i+1, k, track, res)
+			track = track[:len(track)-1]
+		}
+	}
+
+	backtrack(n, 1, k, track, &res)
+
+	return res
+}

src/nums/nums_test.go

@@ -0,0 +1,15 @@
+package nums
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestSubSets(t *testing.T) {
+	fmt.Println(SubSets([]int{1, 2, 3}))
+	fmt.Println(SubSetsV2([]int{1, 2, 3}))
+}
+
+func TestCombine(t *testing.T) {
+	fmt.Println(Combine(4, 2))
+}

src/str/str.go

@@ -1,5 +1,10 @@
 package str
 
+import (
+	"fmt"
+	"strings"
+)
+
 // O(m*n)
 func Contain(haystack string, needle string) int {
 	if len(needle) == 0 {
@@ -18,3 +23,68 @@ func Contain(haystack string, needle string) int {
 	}
 	return -1
 }
+
+// 判断s 是否是t 的子序列；可由t删减若干字符得到，但相对顺序不变
+// ace abcde true
+// cae abcde false
+func SubStr(s, t string) bool {
+	curIndex := 0
+	i := 0
+	for ; i < len(s); i++ {
+		println("before", i, curIndex)
+		println(s[i : i+1])
+		println(t[curIndex:])
+		tmp := strings.Index(t[curIndex:], s[i:i+1])
+		println("tmp", tmp)
+
+		if tmp < 0 {
+			break
+		}
+		curIndex += 1 + tmp
+		println("after", i, curIndex)
+	}
+
+	if i == len(s) {
+		return true
+	}
+	return false
+}
+
+func Permute(nums []int) [][]int {
+	result := make([][]int, 0)
+	list := make([]int, 0)
+	// 标记这个元素是否已经添加到结果集
+	visited := make([]bool, len(nums))
+	backtrack(nums, visited, list, &result)
+	return result
+}
+
+// nums 输入集合
+// visited 当前递归标记过的元素
+// list 临时结果集(路径)
+// result 最终结果
+func backtrack(nums []int, visited []bool, list []int, result *[][]int) {
+	// 返回条件：临时结果和输入集合长度一致 才是全排列
+	if len(list) == len(nums) {
+		ans := make([]int, len(list))
+		copy(ans, list)
+		*result = append(*result, ans)
+		return
+	}
+	for i := 0; i < len(nums); i++ {
+		// 已经添加过的元素，直接跳过
+		if visited[i] {
+			continue
+		}
+		// 添加元素
+		list = append(list, nums[i])
+		visited[i] = true
+		backtrack(nums, visited, list, result)
+		// 移除元素
+		visited[i] = false
+
+		println("after loop index", i)
+		fmt.Println(list)
+		list = list[0 : len(list)-1]
+	}
+}

src/str/str_test.go

@@ -1,9 +1,22 @@
 package str
 
-import "testing"
+import (
+	"fmt"
+	"testing"
+)
 
 func TestContain(t *testing.T) {
 	str := "abcdeqqqqqwww"
 	needle := "www"
 	println(Contain(str, needle))
 }
+
+func TestSubStr(t *testing.T) {
+	s := "ccae"
+	ss := "abcdeeeca"
+	println(SubStr(s, ss))
+}
+
+func TestPermute(t *testing.T) {
+	fmt.Println(Permute([]int{1, 2, 3}))
+}