leetcode刷题笔记 (数组篇)(刷题中。。。)

2. 两数相加

/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next = null;
 *     function __construct($val) { $this->val = $val; }
 * }
 */
class Solution {

    /**
     * @param ListNode $l1
     * @param ListNode $l2
     * @return ListNode
     */
    function addTwoNumbers($l1, $l2) {
        $r = $p = null;
        $flag = 0; // 进位
        while ($l1 != null || $l2 != null) {
            // 下一个节点的值实际上是v1 + v2 + flag
            $v = $l1->val + $l2->val + $flag;
            $val = $v % 10;
            $flag = (int)($v / 10);
            if (is_null($r)) {
                $r = $p = new ListNode($val);
            } else {
                $p->next = new ListNode($val);
                $p = $p->next;
            }
            $l1 = $l1->next;
            $l2 = $l2->next;
        }
            
        //  最后的进位需要在加一位存储
        if ($flag > 0) {
            $p->next = new ListNode($flag);
        }
        return $r;
    }
}

执行时间 20ms, 运行内存 14.9MB

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    var r, p *ListNode
    var v, val, flag, v1, v2 int
    flag = 0
    
    for {
        // l1, l2为空时，检查是否有进位
        if l1 == nil && l2 == nil {
            if flag > 0 {
                p.Next = &ListNode{Val:flag}
            }
            break
        }
        
        // 防止nil值
        if l1 == nil {
            v1 = 0
        } else {
            v1 = l1.Val
            l1 = l1.Next
        }
        if l2 == nil {
            v2 = 0
        } else {
            v2=l2.Val
            l2 = l2.Next
        }
    
        v = v1 + v2 + flag 
        val = v % 10
        flag = v / 10
        
        if r == nil {
            r = &ListNode{Val: val}
            p = r
        } else {
            p.Next = &ListNode{Val: val}
            p = p.Next
        }
    }

    
    return r
}

执行时间 4ms, 运行内存 5.2MB

977. 有序数组的平方

// 数组两边的数字是最大的
// 从数组两边开始判断，取大的，放到数组的最后面，最后就是剩下的小数了
func sortedSquares(A []int) []int {
    r := make([]int, len(A))
    i := 0
    j := len(A) - 1
    k := len(A) - 1
    for {
        if i > j {
            break
        }
        powA := A[i] * A[i]
        powB := A[j] * A[j]
        if powA > powB {
            r[k] = powA
            i++
            k--
        } else {
            r[k] = powB
            j--
            k--
        }
    }

    return r
}

// 先全部转成平方，再重新sort
type sortInt []int
func (s sortInt) Len() int { return len(s) }
func (s sortInt) Less(i, j int) bool { return s[i] < s[j] }
func (s sortInt) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

func sortedSquares(A []int) []int {
    for k, v := range A {
        A[k] = v * v
    }
    
    sort.Sort(sortInt(A))
    return A
}

11. 盛最多水的容器

class Solution {

    /**
     * 暴力破解
     * @param Integer[] $height
     * @return Integer
     */
    function maxArea($height) {
        $max = 0;
        foreach ($height as $key => $value) {
            for ($i=1;$i<=count($height);$i++) {
                // 计算容器的高度
                $h = $value <= $height[$i] ? $value : $height[$i];
                // 计算容器的宽度
                $w = abs($key - $i);
                // 计算面积
                $max = $w * $h > $max ? $w * $h : $max;
            }
        }
        
        return $max;
    }
}

暴力破解法的时间复杂度是O(n), 数据量大的情况下，会占用大量的时间

func maxArea(height []int) int {
    i, j := 0, len(height) - 1
    ares := 0
    for {
        if i == j {
            break
        }
        
        h := min(height[i], height[j])
        ares = max(ares, h * (j - i))
        if height[i] < height[j] {
            i++
        } else {
            j--
        }
    }
    
    return ares
}

func min(i, j int) int {
    if i < j {
        return i
    }
    
    return j
}

func max(i , j int) int {
    if i > j {
        return i
    }
    
    return j
}

双指针法, 将当前最大的面积存储下来， 移动高度较低对应的指针值, 将新的面积与之前存储的最大面积进行比较, 时间复杂度为O(n)

125. 验证回文串

1. 双指针法

import (
	"strings"
	"unicode"
)

func isPalindrome(s string) bool {
        //判断是否是数字或者是字符
	isalnum := func(c rune) bool {
		if unicode.IsDigit(c) || unicode.IsLetter(c) {
			return true
		}

		return false
	}
	l, r := 0, len(s) - 1
	for {
		if l >= r {
			return true
		}

		c1 := rune(s[l])
		c2 := rune(s[r])
		if isalnum(rune(s[l])) && isalnum(rune(s[r])) {
			if strings.ToLower(string(c1)) == strings.ToLower(string(c2)) {
				l++
				r--
			} else {
				return false
			}
		} else {
			if !isalnum(c1) {
				l++
			}

			if !isalnum(c2) {
				r--
			}
		}
	}
}

2. 中心扩散法

import (
	"log"
	"strings"
	"unicode"
)

// 判断是否是回文串
func IsPalindrome(s string) bool {
	var str string
	for _, value := range s {
		if unicode.IsDigit(value) || unicode.IsLetter(value) {
			str = str + strings.ToLower(string(value))
		}
	}
	var l, r, mid int

	log.Println("字符串总长度:", len(str))
        // 奇数和偶数中心位置不同，需要特殊处理
	if len(str) % 2 == 1 { 
		mid = len(str) / 2
		l, r = mid - 1 , mid + 1
	} else {
		mid = (len(str) / 2) - 1
		l, r = mid, mid + 1
	}

	for {
		if l < 0 || r > len(str) {
			return true
		}

		log.Printf("[%d], [%d]\n", str[l], str[r])
		if str[l] == str[r] {
			l --
			r ++
		} else {
			return false
		}
	}
	log.Println("success")
	return true
}