杨子鳄鱼 ● 外贸自建站

location ~ \.(jpg|jpeg|png|gif)$ {
    valid_referers none server_names blocked *.magiclen.org *.facebook.com;
    if ($invalid_referer) {
        return 403;
    }
}

eq, err := http.NewRequest(method, url, body)
if err !=nil{

    return nil, err

}

resp, err := http.DefaultClient.Do(req)
if err !=nil{
    return nil, err
}
defer resp.Body.Close()

b, err := ioutil.ReadAll(resp.Body)
if err !=nil{
    return nil, err
}

return b,nil

package main

// 节点的数据结构
type Node struct {
    E int
    Next *Node
}
// 链表的数据结构
type List struct {
    dummyHead *Node
    size int
}

func (l List) Head() *Node {
    return l.dummyHead
}

func (l List) Size() int {
    return l.size
}
// 初始化一个节点
func initNode (e int) *Node {
    return &Node{
        E:e,
        Next:nil,
    }
}
// 初始化一个空链表
func InitList () *List {
    return &List{
        dummyHead:initNode(0),
        size:0,
    }
}

// 判断链表是否为空
func (this *List) IsEmpty() bool {
    return this.size == 0
}
// 插入部分
// 在链表的第index索引个元素后插入元素,索引从0开始
func (this *List) AddIndex (index,e int) {
    if index > this.size || index < 0 {
        panic("索引越界，不能插入了")
    }
    prev := this.dummyHead
    node := initNode(e)

    for i:=0;i<index;i++ {
        prev = prev.Next
    }
    // 这里的步骤一定不能反过来，思考一下为什么
    node.Next = prev.Next
    prev.Next = node
    this.size++

}
// 在链表头添加元素
func (this *List) AddFirst (e int) {
    this.AddIndex(0,e)
}
// 在链表尾部添加节点
func (this *List) AddLast (e int) {
    this.AddIndex(this.size,e)
}
// 查询部分
// 在链表中查询是否包括元素e
func (this *List) Contains (e int) bool {
    cur := this.dummyHead.Next
    for cur!=nil {
        if cur.E == e{
            return true
        }
        cur = cur.Next
    }
    return false
}
// 在链表中查询第index个元素
func (this *List) Get (index int) int {
    if index > this.size || index < 0 {
        panic("索引越界，不能查询")
    }
    cur := this.dummyHead.Next
    for i:=0;i<index;i++ {
        cur = cur.Next
    }
    return cur.E
}
func (this *List) GetFirst () int{
    return this.Get(0)
}
func (this *List) GetLast () int{
    return this.Get(this.size-1)
}

package main

import (
    "fmt"
    "strings"
)

type Node struct {
    E int
    Next *Node
}

type List struct {
    dummyHead *Node
    size int
}

func (l List) Head() *Node {
    return l.dummyHead
}


func (l List) Size() int {
    return l.size
}
func initNode (e int) *Node {
    return &Node{
        E:e,
        Next:nil,
    }
}
func InitList () *List {
    return &List{
        dummyHead:initNode(0),
        size:0,
    }
}
func (this *List) IsEmpty() bool {
    return this.size == 0
}
// 在链表的第index索引个元素后插入元素,索引从0开始
func (this *List) AddIndex (index,e int) {
    if index > this.size || index < 0 {
        panic("索引越界，不能插入了")
    }
    prev := this.dummyHead
    node := initNode(e)

    for i:=0;i<index;i++ {
        prev = prev.Next
    }
    node.Next = prev.Next
    prev.Next = node
    this.size++

}
// 在链表头添加元素
func (this *List) AddFirst (e int) {
    this.AddIndex(0,e)
}
// 在链表尾部添加节点
func (this *List) AddLast (e int) {
    this.AddIndex(this.size,e)
}
// 在链表中查询第index个元素
func (this *List) Get (index int) int {
    if index > this.size || index < 0 {
        panic("索引越界，不能查询")
    }
    cur := this.dummyHead.Next
    for i:=0;i<index;i++ {
        cur = cur.Next
    }
    return cur.E
}
func (this *List) GetFirst () int{
    return this.Get(0)
}
func (this *List) GetLast () int{
    return this.Get(this.size-1)
}
// 在链表index个位置中放入元素e
func (this *List) Set (index,e int) {
    if index > this.size || index < 0 {
        panic("索引越界，不能置入")
    }
    cur := this.dummyHead.Next
    for i:=0;i<index;i++ {
        cur = cur.Next
    }
    cur.E = e
}
// 在链表中查询是否包括元素e
func (this *List) Contains (e int) bool {
    cur := this.dummyHead.Next
    for cur!=nil {
        if cur.E == e{
            return true
        }
        cur = cur.Next
    }
    return false
}
// 在链表中删除元素
func (this *List) Remove (index int) int {
    if index > this.size || index < 0 {
        panic("索引越界，不能删除")
    }
    prev := this.dummyHead
    for i:=0;i<index;i++ {
        prev = prev.Next
    }
    retNode := prev.Next
    prev.Next = retNode.Next
    this.size--
    return retNode.E
}
func (this *List) RemoveFirst () int{
    return this.Remove(0)
}
func (this *List) RemoveLast () int{
    return this.Remove(this.size-1)
}
// 删除元素E
func (this *List) RemoveElement (e int) {
    prev := this.dummyHead
    for prev.Next != nil {
        if prev.E == e {
            break
        }
        prev = prev.Next
    }
    if prev.Next != nil {
        DelNode := prev.Next
        prev.Next = DelNode.Next
        DelNode = nil
    }
}
// 在Golang中，如果我们想对自建数据结构自定义在Println的时候打印出什么结果
// 就可以使用这种方式去自己构建打印的字符串格式
func (this *List) String () string {
    var builder strings.Builder
    cur := this.dummyHead.Next
    for cur != nil {
        fmt.Fprintf(&builder,"%d -> ",cur.E)
        cur = cur.Next
    }
    fmt.Fprintf(&builder,"NULL")
    return builder.String()
}

func main() {
    list := InitList()
    for i:=0;i<5 ; i++  {
        list.AddLast(i)
    }
    fmt.Println(list)
    fmt.Println(list.Contains(0))
    fmt.Println(list.Get(3))
    fmt.Println(list.RemoveLast())
    fmt.Println(list.GetFirst())
    // 其他功能可以自行测试。
}

package main

import (
    "fmt"
    "strings"
)

// 在这个函数前需要将list.go的代码拷贝到这里

func (this *List)Reverse()  {
    var pre *Node
    var cur *Node
    next := this.Head().Next

    for next != nil {
        cur = next.Next
        next.Next = pre
        pre = next
        next = cur
    }
    this.Head().Next = pre
}

func main(){
    list := InitList()
    for i:=0;i<5 ; i++  {
        list.AddFirst(i)
    }
    fmt.Println(list)
    list.Reverse()
    fmt.Println(list)
}

package main

import (
    "fmt"
    "strings"
)

// 在这个函数前需要将list.go的代码拷贝到这里


// 把两个用链表表示的整数相加
func AddTwoList(head1,head2 *Node) *List {
    // 初始化一个新链表
    newHead := InitList()
    // 因为有dummyHead，所以head的下一个节点才是真真正的头结点
    p1 := head1.Next
    p2 := head2.Next
    carry := 0
    for p1 != nil || p2 != nil {
        // 如果p1到头就只需要添加p2，反之同理
        if p1 == nil {
            newHead.AddLast(p2.E+ + carry)
            p2 = p2.Next
        }
        if p2 == nil {
            newHead.AddLast(p1.E + carry)
            p1 = p1.Next
        }
        // 计算本位的值
        temp := (p1.E + p2.E + carry )%10
        newHead.AddLast(temp)
        // 记录进位
        carry = (p1.E + p2.E + carry )/10
        p1 = p1.Next
        p2 = p2.Next
    }
    return newHead
}

// 测试代码和测试结果
func main(){
    list := InitList()
    list2 := InitList()
    for i:=0;i<6 ; i++  {
        list.AddFirst(i)
    }
    for i:=0;i<6 ; i++  {
        list2.AddFirst(i+1)
    }
    fmt.Println(list)
    fmt.Println(list2)
    newlist := AddTwoList(list.Head(),list2.Head())
    fmt.Println(newlist)
}

package main

type Queue struct {
    // 用来装元素的切片
    container []int
    // 队首标记位
    front int
    // 队尾标记位
    rear int
    // 容量限制
    size int
}

// 初始化时，要传入容量限制
func NewQueue(size int) *Queue {
    return &Queue{
        container: make([]int,size),
        // 在队列中已经装了多少元素我们可以用size表示
        // 想一想为什么不能用rear-front表示队列当前长度呢？
        front:       0,
        rear:        0,
        size:        0,
    }
}

package main

import "fmt"

type Queue struct {
    // 用来装元素的切片
    container []int
    // 队首标记位
    front int
    // 队尾标记位
    rear int
    // 容量限制
    size int
}

// 初始化时，要传入容量限制
func NewQueue(size int) *Queue {
    return &Queue{
        container: make([]int,size),
        // 在队列中已经装了多少元素我们可以用size表示
        // 想一想为什么不用 rear - front 表示呢
        front:       0,
        rear:         0,
        size:           0,
    }
}
// 队列是否为空
func (q *Queue) IsEmpty () bool {
    if q.size == 0 {
        return true
    }
    return false
}

func (q *Queue) IsFull () bool {
    if q.size == len(q.container) {
        return true
    }
    return false
}
// 新元素入队
func (q *Queue) EnQueue (a int) bool {
    if q.IsFull() {
        return false
    }
    q.container[q.rear] = a
    q.rear++
    q.size++
    return true
}
// 队首元素出队
func (q *Queue) Dequeue () (bool,int) {
    if q.IsEmpty() {
        return false,0
    }
    ret := q.container[q.front]
    q.front++
    q.size--
    return true,ret
}

func main() {
    queue := NewQueue(10)

    for i := 0; i < 5 ; i++ {
        queue.EnQueue(i)
    }

    for i := 0; i < 6; i++ {
        fmt.Println(queue.Dequeue())
    }
}

/** 检查循环队列是否为空. */
func (this *Queue) IsEmpty() bool {
    if this.size == 0 {
        return true
    }
    return false
}

/** 检查循环队列是否为满 */
func (this *Queue) IsFull() bool {
    if this.size == len(this.arr) {
        return true
    }
    return false
}

package main

import (
    "fmt"
)

type Queue struct {
    container   []int
    front int
    rear  int
    size  int
}


func NewQueue (k int) *Queue {
    return &Queue{
        make([]int, k),
        0,
        0,
        0,
    }
}


func (this *Queue) EnQueue(value int) bool {
    if this.container == nil || this.IsFull() {
        return false
    }
    this.container[this.rear%len(this.container)] = value
    this.rear = this.rear%len(this.container) + 1
    this.size++
    return true
}


func (this *Queue) DeQueue() (bool,int) {
    if this.container == nil || this.IsEmpty() {
        return false,0
    } else {
        ret := this.container[this.front%len(this.container)]
        this.front = this.front%len(this.container) + 1
        this.size--
        return true,ret
    }
}


func (this *Queue) IsEmpty() bool {
    if this.size == 0 {
        return true
    }
    return false
}

func (this *Queue) IsFull() bool {
    if this.size == len(this.container) {
        return true
    }
    return false
}

func main() {
    queue := NewQueue(5)
    // 循环3次，每次添加5个元素，再出队三个元素
    for i:=0; i<3; i++{
        for j:=0;j<5;j++ {
            queue.EnQueue(j)
        }
        for k:=0;k<3;k++ {
            fmt.Println(queue.DeQueue())
        }
    }
}

package main

type Stack struct {
    // 用来装元素的切片
    container []int
    // 栈顶标记位
    top int
    // 容量限制
    size int
}

// 初始化时，要传入容量限制
func NewStack(size int) *Stack {
    return &Stack{
        container: make([]int,size),
        // 栈顶指针初始可以指向-1，也可以指向0，想一想为什么。
        top:       0,
        size:      size,
    }
}

package main

import "fmt"

type Stack struct {
    // 用来装元素的切片
    container []int
    // 栈顶标记位
    top int
    // 容量限制
    size int
}

// 初始化时，要传入容量限制
func NewStack(size int) Stack {
    return Stack{
        container: make([]int, size),
        top:       0,
        size:      size,
    }
}

func (s *Stack) Push(e int) bool {
    if s.IsFull() {
        return false
    }
    // 把盘子摞上去
    s.container[s.top] = e
    // 下一个能摞盘子的位置
    s.top++
    return true
}

func (s *Stack) Pop() (flag bool, ret int) {
    // 如果栈空了，你就无法拿到新盘子，所以flag此时为false
    if s.IsEmpty() {
        return false, ret
    }
    // 取出盘子
    ret = s.container[s.top-1]
    // 下一个能取盘子的位置
    s.top--
    return true, ret
}

func (s *Stack) IsEmpty() bool {
    if s.top == 0 {
        return true
    }
    return false
}

func (s *Stack) IsFull() bool {
    if s.top == s.size {
        return true
    }
    return false
}

func main() {
    stack := NewStack(3)
    // 先测试栈为空的时候能否Pop
    fmt.Println(stack.Pop())
    // 测试Push是否正常
    stack.Push(1)
    stack.Push(2)
    stack.Push(3)
    // 如果栈为正常的，这里Pop打印顺序应该是3,2,1
    fmt.Println(stack.Pop())
    fmt.Println(stack.Pop())
    fmt.Println(stack.Pop())
}

package main

import "fmt"

type Stack struct {
    // 用来装元素的切片
    container []string
    // 栈顶标记位
    top int
    // 容量限制
    size int
}

// 初始化时，要传入容量限制
func NewStack(size int) Stack {
    return Stack{
        container: make([]string, size),
        top:       0,
        size:      size,
    }
}

func (s *Stack) Push(e string) bool {
    if s.IsFull() {
        return false
    }
    s.container[s.top] = e
    s.top++
    return true
}

func (s *Stack) Pop() (flag bool, ret string) {
    // 如果栈是空的，那么就不能继续 Pop 了
    if s.IsEmpty() {
        return false, ret
    }
    ret = s.container[s.top-1]
    s.top--
    return true, ret
}

func (s *Stack) IsEmpty() bool {
    if s.top == 0 {
        return true
    }
    return false
}

func (s *Stack) IsFull() bool {
    if s.top == s.size {
        return true
    }
    return false
}

func main() {
    back := NewStack(3)
    // 模拟每次点击网页时，浏览器会自push你的网址到栈中
    back.Push("www.baidu.com")
    back.Push("www.bing.com")
    back.Push("www.goole.com")
    // 每次点击后退时，就相当于是从栈中Pop了一个网址
    fmt.Println(back.Pop())
    fmt.Println(back.Pop())
    fmt.Println(back.Pop())
}

package main

import "fmt"

type Stack struct {
    // 用来装元素的切片
    container []byte
    // 栈顶标记位
    top int
    // 容量限制
    size int
}

// 初始化时，要传入容量限制
func NewStack(size int) Stack {
    return Stack{
        container: make([]byte,size),
        top:       0,
        size:      size,
    }
}

func (s *Stack) Push (e byte) bool {
    if s.IsFull() {
        return false
    }
    s.container[s.top] = e
    s.top++
    return true
}


func (s *Stack) Pop () (flag bool,ret byte) {
    // 如果栈是空的，那么就不能继续 Pop 了
    if s.IsEmpty() {
        return false,ret
    }
    ret = s.container[s.top-1]
    s.top--
    return true,ret
}


func (s *Stack) IsEmpty () bool {
    if s.top == 0 {
        return true
    }
    return false
}


func (s *Stack) IsFull () bool {
    if s.top == s.size {
        return true
    }
    return false
}

func IsValid(s string) bool {
    stack := NewStack(100)
    // 遍历括号字符串
    for _,v := range s {
        if v == '(' {
            // 由于golang中的字符串默认是unicode编码，所以我们要做一个强制类型转换
            stack.Push(byte(v))
        }
        if v == ')' {
            // 如果flag不为true，说明栈已经到底了，可以直返回false
            if flag,top := stack.Pop(); flag == true &&top == '(' {
                continue
            } else {
                return false
            }
        }
    }
    // 字符串遍历完后如果栈也空了，说明括号匹配
    if stack.IsEmpty() {
        return true
    }
    // 如果栈不空，说明栈里还有多余的左括号
    return false
}

func main() {
    test1 := "()()())"
    test2 := "((()"
    test3 := "()()()()"
    fmt.Println(IsValid(test1))
    fmt.Println(IsValid(test2))
    fmt.Println(IsValid(test3))
}