20200519

Author: baxiang

2.06palindrome-linked-list-lcci/main.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"fmt"
+)
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func isPalindrome1(head *ListNode) bool {
+	var str string
+	var revertStr string
+	for head != nil {
+		str = fmt.Sprintf("%s%d", str, head.Val)
+		revertStr = fmt.Sprintf("%d%s", head.Val, revertStr)
+		head = head.Next
+	}
+	return str == revertStr
+}
+
+func isPalindrome(head *ListNode) bool {
+	if head==nil{
+		return true
+	}
+	// 查找中间节点
+	midNode := findMidNode(head)
+	// 翻转以中间节点的链表
+	currTail := revertLinkedNode(midNode)
+    // 判断头节点和尾节点值是否一直
+	for head!=nil&&currTail!=nil{
+		if head.Val!=currTail.Val{
+			return false
+		}
+		head= head.Next
+		currTail = currTail.Next
+	}
+	return true
+}
+
+func isPalindrome1(head *ListNode) bool {
+	if head==nil{
+		return true
+	}
+	var res []
+	for head!=nil{
+
+	}
+	return true
+}
+
+
+
+func findMidNode(head *ListNode)*ListNode{
+
+	 slow := head
+	 fast := head.Next
+	 for fast!=nil&&fast.Next!=nil{
+	 	slow = slow.Next
+	 	fast = fast.Next.Next
+	 }
+	 return slow
+}
+
+
+func revertLinkedNode(head *ListNode) *ListNode {
+	dummyHead := &ListNode{}
+	for head != nil {
+		next := head.Next
+		proNode := dummyHead.Next
+		dummyHead.Next = head
+		head.Next = proNode
+		head = next
+	}
+	return dummyHead.Next
+}
+
+
+func revertLinkedNode1(head *ListNode) *ListNode {
+	if head==nil||head.Next==nil{
+		return head
+	}
+	 next :=head.Next
+	 node := revertLinkedNode1(next)
+	 next.Next = head
+	 head.Next = nil
+	 return node
+}
+
+func main() {
+	t1 := ListNode{Val: 1}
+	t2 := ListNode{Val: 2}
+	t1.Next = &t2
+	t3 := ListNode{Val: 1}
+	t2.Next = &t3
+	t4 := ListNode{Val: 4}
+	t3.Next = &t4
+	t5 := ListNode{Val: 5}
+	t4.Next = &t5
+
+
+
+
+    fmt.Println(isPalindrome(&t1))
+
+
+}

226invert-binary-tree/main.go

@@ -9,12 +9,12 @@ type TreeNode struct {
 }
 
 
-func invertTree(root *TreeNode) *TreeNode {
+func invertTree3(root *TreeNode) *TreeNode {
 	if root==nil {// 递归结束条件
 		return nil
 	}
-	right:= invertTree(root.Right)// 返回已经翻转的右节点
-	left := invertTree(root.Left) // 返回已经翻转的左节点
+	right:= invertTree3(root.Right)// 返回已经翻转的右节点
+	left := invertTree3(root.Left) // 返回已经翻转的左节点
 	// 当前需要一级需要做的是把 左节点指向已经翻转的右节点 右节点指向已经翻转的左节点
 	root.Left = right
 	root.Right = left
@@ -30,33 +30,33 @@ func invertTree1(root *TreeNode) *TreeNode {
 	root.Left = root.Right
 	root.Right = temp
 
-	invertTree(root.Left) // 翻转的左节点
-	invertTree(root.Right)// 返翻转的右节点
+	invertTree1(root.Left) // 翻转的左节点
+	invertTree1(root.Right)// 返翻转的右节点
 
 	return root
 }
 
-func invertTree2(root *TreeNode) *TreeNode {
-	if root==nil {
-		return nil
-	}
-	l := make([]*TreeNode,0)
-	l = append(l ,root)
-	for len(l)>0{
-		curr := l[0]
-		l = l[1:]
-		left :=curr.Left
-		right :=curr.Right
-		curr.Right = left
-		curr.Left = right
-		if curr.Left!=nil {
-			l = append(l,curr.Left)
-		}
-		if curr.Right!=nil {
-			l = append(l,curr.Right)
-		}
-	}
-	return root
+
+func invertTree(root *TreeNode) *TreeNode {
+       if root==nil{
+       	  return root
+	   }
+	   queue :=[]*TreeNode{root}
+	   for len(queue)>0{
+	   	  size  :=len(queue)
+	   	  for i:=0;i<size;i++{
+	   	  	  node := queue[i]
+	   	  	  node.Left,node.Right = node.Right,node.Left
+	   	  	  if node.Left!=nil{
+				  queue = append(queue,node.Left)
+			  }
+			  if node.Right!=nil{
+				  queue = append(queue,node.Right)
+			  }
+		  }
+		  queue =queue[size:]
+	   }
+	   return root
 }
 
 
@@ -80,25 +80,25 @@ func main() {
 			Val: 3,
 		}
 		b.Right = e
-		f := &TreeNode{
-			Val: 6,
-		}
-	    c.Left = f
+		//f := &TreeNode{
+		//	Val: 6,
+		//}
+	    //c.Left = f
 	    g := &TreeNode{
 		Val: 9,
 	    }
 		c.Right = g
 		// 9 7 64 3 2 1
-	    invertTree2(a)
-		printOrder(a)
+	    r :=invertTree(a)
+		printOrder(r)
 }
 
 func printOrder(root *TreeNode){
 	if root== nil {
 		return
 	}
-	printOrder(root.Left)
 	fmt.Println(root.Val)
+	printOrder(root.Left)
 	printOrder(root.Right)
 	return
 }

86partition-list/main.go

@@ -0,0 +1,30 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func partition(head *ListNode, x int) *ListNode {
+	greatDummy := &ListNode{}
+	lessDummy := &ListNode{}
+	currGreat := greatDummy
+	currLess := lessDummy
+	for head != nil {
+		if head.Val < x {
+			currLess.Next = head
+			currLess = head
+		} else {
+			currGreat.Next = head
+			currGreat = head
+		}
+		head = head.Next
+	}
+	currGreat.Next = nil
+	currLess.Next = greatDummy.Next
+	return lessDummy.Next
+}
+
+func main() {
+
+}