Merge pull request neetcode-gh#29 from blurout/main

Added Golang solutions + fixed format inconsistencies

Author: Ahmad-A0

go/102-Binary-Tree-Level-Order-Traversal.go

@@ -0,0 +1,42 @@
+func levelOrder(root *TreeNode) [][]int {
+	// nil check
+		if root == nil {
+			return nil
+		}
+		
+		var result [][]int
+		level := 0
+		q := make([]*TreeNode,1)
+		q[0] = root
+		for len(q) > 0 {
+			curLen := len(q)
+			//add elements to the queue per level
+			for i := 0; i < curLen; i++ {
+			  //queue implementation : delete element from front(1st element of slice)
+				node := q[0]
+				q = q[1:]
+				
+				if len(result) <= level {
+				 //create new slice with first value of the level and append to result matrix
+					result = append(result,[]int{node.Val})
+				}else {
+				//add values to the slice created per level
+					result[level] = append(result[level],node.Val)
+				}
+				
+				//queue implementation : add element at Back( after last element of slice by append)
+				//add left node at queue
+				if node.Left != nil {
+					q = append(q,node.Left)
+				}
+				//add Right node at queue
+				if node.Right != nil{
+					q = append(q,node.Right)
+				}
+			}
+			//increment the level after adding current elements to result
+			level++
+		}
+		return result
+		
+	}

go/141-Linked-List-Cycle.go

@@ -0,0 +1,15 @@
+func hasCycle(head *ListNode) bool {
+	if head == nil || head.Next == nil {
+        return false
+    }
+    slow := head
+    fast := head
+    for fast != nil && fast.Next != nil {
+        slow = slow.Next
+        fast = fast.Next.Next
+        if slow == fast {
+            return true
+        }
+    }
+    return false
+}

go/15-3Sum.go

@@ -0,0 +1,39 @@
+func threeSum(nums []int) [][]int {
+	n := len(nums)
+
+	// Sort the given array
+	sort.Ints(nums)
+
+	var result [][]int
+	for num1Idx := 0; num1Idx < n-2; num1Idx++ {
+		// Skip all duplicates from left
+		// num1Idx>0 ensures this check is made only from 2nd element onwards
+		if num1Idx > 0 && nums[num1Idx] == nums[num1Idx-1] {
+			continue
+		}
+
+		num2Idx := num1Idx + 1
+		num3Idx := n - 1
+		for num2Idx < num3Idx {
+			sum := nums[num2Idx] + nums[num3Idx] + nums[num1Idx]
+			if sum == 0 {
+				// Add triplet to result
+				result = append(result, []int{nums[num1Idx], nums[num2Idx], nums[num3Idx]})
+
+				num3Idx--
+
+				// Skip all duplicates from right
+				for num2Idx < num3Idx && nums[num3Idx] == nums[num3Idx+1] {
+					num3Idx--
+				}
+			} else if sum > 0 {
+				// Decrement num3Idx to reduce sum value
+				num3Idx--
+			} else {
+				// Increment num2Idx to increase sum value
+				num2Idx++
+			}
+		}
+	}
+	return result
+}

go/155-Min-Stack.go

@@ -0,0 +1,60 @@
+type MinStack struct {
+    top *StackNode
+    min int
+}
+
+type StackNode struct {
+	data int
+	next *StackNode
+    lastmin int
+}
+
+var mystack MinStack = MinStack{top: nil}
+var newtop *StackNode
+
+func Constructor() MinStack {
+    return mystack
+}
+
+func (this *MinStack) Push(val int)  {
+    if this.top == nil {
+        newtop = &StackNode{data: val, next: this.top}
+        this.min = val
+    } else {
+        newtop = &StackNode{data: val, next: this.top, lastmin: this.min}
+    }
+    this.top = newtop
+    if this.top.data < this.min {
+        this.min = this.top.data
+    }
+}
+
+
+func (this *MinStack) Pop()  {
+    if this.top.next == nil {
+        this.top = nil
+        return
+    } 
+    this.min = this.top.lastmin
+    *this.top = *this.top.next
+}
+
+
+func (this *MinStack) Top() int {
+    return this.top.data
+}
+
+
+func (this *MinStack) GetMin() int {
+    return this.min; 
+}
+
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Push(val);
+ * obj.Pop();
+ * param_3 := obj.Top();
+ * param_4 := obj.GetMin();
+ */