# 删除链表中的重复元素
---

:::success

package main

import "fmt"

//创建结点 结构体
type ListNode struct {
	Value int
	Next  *ListNode
}

//链表 结构体
type LinkList struct {
	Head   *ListNode
	Length int
}

// 创建链表结点
func NewListNode(v int) *ListNode {
	return &ListNode{v, nil}
}

// 创建空链表
func NewLinkedList() *LinkList {
	return &LinkList{&ListNode{0, nil}, 0}
}

//在i处插入节点（前插）
func (list *LinkList) Insert(i int, v int) {
	s := NewListNode(v)
	pre := list.Head
	for count := 1; count <= i; count++ {
		if count == i {
			s.Next = pre.Next
			pre.Next = s
			list.Length++
		}
		pre = pre.Next
	}
}

//打印链表
func (list *LinkList) PrintLinkList() {
	cur := list.Head.Next
	format := ""
	for cur != nil {
		format += fmt.Sprintf("%v", cur.Value) // 如果想完整数据使用cur替代cur.Value
		cur = cur.Next
		if cur != nil {
			format += "->"
		}
	}
	fmt.Println("LinkList length:", list.Length, "\n", format)
}

func (list *LinkList) DeleteDuplicatesLinkListValue() *LinkList {
	if list.Head == nil {
		return nil
	}
    
	for prev := list.Head; prev.Next != nil; {
		if prev.Value == prev.Next.Value {
			prev.Next = prev.Next.Next
			list.Length--
		} else {
			prev = prev.Next
		}
	}
    
	return list
}

func (list *LinkList) Sort() *LinkList {
	if list.Head == nil {
		return nil
	}

	for i:= 0; i < list.Length; i ++ {
		for p := list.Head; p.Next != nil; p = p.Next {
			if p.Value >= p.Next.Value {
				p.Value, p.Next.Value = p.Next.Value, p.Value
			}
		}
	}

	return list
}

func main() {
	list := NewLinkedList()
	list.Insert(1, 7)
	list.Insert(2, 6)
	list.Insert(3, 8)
	list.Insert(4, 6)
	list.Insert(5, 9)
	list.Insert(6, 8)
	list.PrintLinkList() // 7->6->8->6->9->8
	list.Sort() // 把无序链表变成有序链表 6->6->7->8->8->9
	list.PrintLinkList()
	list.DeleteDuplicatesLinkListValue() // 删除有序链表中的重复元素  6->7->8->9
	list.PrintLinkList()
}

:::

LinkList length: 6 
 7->6->8->6->9->8
LinkList length: 6 
 6->6->7->8->8->9
LinkList length: 4 
 6->7->8->9

###### tags: `Golang`