单链表操作(增删改查、反序列)

梦里梦外; 2022-01-17 04:27 197阅读 0赞

type Node struct { 
    	Name  string // 商品名
    	Value int    // 商品数量
    	Next  *Node  // 下一节点
    }
    
    // ---------------------------------------------
    
    func (n *Node) NewChain(params map[string]int) { 
    	var current = n
    	for key, val := range params { 
    		newNode := Node{ Name: key, Value: val}
    		current.Next = &newNode // 将当前指针的下一值更新
    		current = &newNode      // 换当前指针
    	}
    }
    
    func (n *Node) List() []Node { 
    	result := make([]Node, 0, 5)
    	current := n.Next
    	for current != nil { 
    		result = append(result, *current)
    		// fmt.Printf("->name: %v, value: %v\n", current.Name, current.Value)
    		current = current.Next
    	}
    	return result
    }
    
    // 从链头追加
    func (n *Node) Append(key string, val int) { 
    	next := n.Next
    	newNode := &Node{ Name: key, Value: val, Next: next}
    	n.Next = newNode
    }
    
    // 插入
    func (n *Node) Insert(key string, val, index int) error { 
    	current := n
    	for i := 0; current != nil; i++ { 
    		if index == i { 
    			newNode := &Node{ Name: key, Value: val, Next: current.Next}
    			current.Next = newNode
    			return nil
    		}
    		current = current.Next
    	}
    	return fmt.Errorf("越界")
    }
    
    // 更新
    func (n *Node) Update(key string, value, index int) error { 
    	current := n
    	for i := 0; current != nil; i++ { 
    		if index == i { 
    			current.Name = key
    			current.Value = value
    			return nil
    		}
    		current = current.Next
    	}
    	return fmt.Errorf("越界")
    }
    
    // 删除
    func (n *Node) Delete(index int) error { 
    	current := n
    	for i := 0; current != nil; i++ { 
    		if index == i && current.Next != nil { 
    			current.Next = current.Next.Next //注意next_node为nil是不能取Next的
    			return nil
    		}
    		current = current.Next
    	}
    	return fmt.Errorf("越界")
    }
    
    // 查询
    func (n *Node) Query(attr *Param) (*Node, error) { 
    	current := n.Next
    	for i := 0; current != nil; i++ { 
    		if attr.Name != "" && attr.Name == current.Name { 
    			return current, nil
    		}
    		if attr.Name == "" && attr.index == i { 
    			return current, nil
    		}
    		current = current.Next
    	}
    	return nil, fmt.Errorf("越界")
    }
    
    // 反向链表
    func (n *Node) reverseChain() { 
    	var up *Node = nil
    	current := n.Next
    	for current != nil { 
    		// 1.先以temp作为链头把剩余节点维护好
    		temp := current.Next
    		// 2.把当前节点指向上一位
    		current.Next = up
    		// 3.将当前位变为上一位
    		up = current
    		// 4.取下一个
    		current = temp
    		// 5.最后一个由原链头指向它
    		if current == nil { 
    			n.Next = up
    		}
    	}
    }
    
    type Param struct { 
    	Name  string
    	index int
    }
    
    type QueryAttr func(n *Param)
    
    func QueryName(name string) QueryAttr { 
    	return func(n *Param) { 
    		n.Name = name
    		n.index = -1
    	}
    }
    
    func QueryIndex(index int) QueryAttr { 
    	return func(n *Param) { 
    		n.index = index
    	}
    }
    
    func NewQueryParam(opts ...QueryAttr) *Param { 
    	var param = new(Param)
    	for _, opt := range opts { 
    		opt(param)
    	}
    	return param
    }
    
    func main() { 
    	goodsArray := make(map[string]int)
    	goodsArray["apple"] = 6
    	goodsArray["orange"] = 3
    	goodsArray["banana"] = 9
    	goodsArray["fish"] = 5
    	goodsArray["book"] = 7
    	n := &Node{ }
    	// 生成链表
    	n.NewChain(goodsArray)
    	fmt.Println(n.List())
    	// 反序列化
    	n.reverseChain()
    	fmt.Println(n.List())
    
    	// 1. 按下表查询节点
    	indexAttr := NewQueryParam(QueryIndex(4), QueryName("book"))
    	node, err := n.Query(indexAttr)
    	if err != nil { 
    		log.Fatal(err)
    	}
    	fmt.Println(node)
    }