github.com/qiuhoude/go-web@v0.0.0-20220223060959-ab545e78f20d/algorithm/datastructures/linkedlist/single_linkedlist_test.go (about)

     1  package linkedlist
     2  
     3  import "testing"
     4  
     5  func TestLinkedList_InsertToHead(t *testing.T) {
     6  	l := NewLinkedList()
     7  	for i := 1; i <= 10; i++ {
     8  		l.InsertToHead(i)
     9  	}
    10  	t.Log(l)
    11  }
    12  
    13  func TestLinkedList_InsertToTail(t *testing.T) {
    14  	l := NewLinkedList()
    15  	for i := 1; i <= 10; i++ {
    16  		l.InsertToTail(i)
    17  	}
    18  	t.Log(l)
    19  }
    20  
    21  func TestLinkedList_FindByIndex(t *testing.T) {
    22  	l := NewLinkedList()
    23  	for i := 1; i <= 10; i++ {
    24  		l.InsertToTail(i)
    25  	}
    26  
    27  	t.Log(l.FindByIndex(uint(0)))
    28  	t.Log(l.FindByIndex(uint(5)))
    29  	t.Log(l.FindByIndex(uint(10)))
    30  	t.Log(l.FindByIndex(uint(300)))
    31  }
    32  
    33  func TestLinkedList_DeleteNode(t *testing.T) {
    34  	l := NewLinkedList()
    35  	for i := 1; i <= 10; i++ {
    36  		l.InsertToTail(i)
    37  	}
    38  	t.Log(l)
    39  
    40  	t.Log(l.DeleteNode(l.FindByIndex(3)))
    41  	t.Log(l)
    42  
    43  	t.Log(l.DeleteNode(l.FindByIndex(6)))
    44  	t.Log(l)
    45  
    46  	t.Log(l.DeleteNode(l.FindByIndex(10)))
    47  	t.Log(l)
    48  }
    49  
    50  func TestLinkedList_Reverse(t *testing.T) {
    51  	t.Log(l)
    52  	l.Reverse()
    53  	t.Log(l)
    54  
    55  	t.Log(emptyL)
    56  	emptyL.Reverse()
    57  	t.Log(emptyL)
    58  
    59  }
    60  
    61  var l, emptyL, oneL, oddL, evenL *LinkedList
    62  
    63  func init() {
    64  	emptyL = NewLinkedList()
    65  
    66  	n5 := &ListNode{value: 5}
    67  	n4 := &ListNode{value: 4, next: n5}
    68  	n3 := &ListNode{value: 3, next: n4}
    69  	n2 := &ListNode{value: 2, next: n3}
    70  	n1 := &ListNode{value: 1, next: n2}
    71  	l = &LinkedList{head: &ListNode{next: n1}}
    72  
    73  	oneL = NewLinkedList()
    74  	oneL.InsertToTail(1)
    75  
    76  	oddL = NewLinkedList()
    77  	for i := 1; i <= 9; i++ {
    78  		oddL.InsertToTail(i)
    79  	}
    80  	evenL = NewLinkedList()
    81  	for i := 1; i <= 10; i++ {
    82  		evenL.InsertToTail(i)
    83  	}
    84  
    85  }
    86  
    87  func TestLinkedList_FindMidNode(t *testing.T) {
    88  
    89  	tests := []struct {
    90  		name string
    91  		l    *LinkedList
    92  		want interface{}
    93  	}{
    94  		{"空链表 => ", emptyL, nil},
    95  		{"一个元素 => ", oneL, 1},
    96  		{"奇数个元素 => ", oddL, 5},
    97  		{"偶数个元素 => ", evenL, 6},
    98  	}
    99  	for _, tt := range tests {
   100  		ts := tt
   101  		t.Run(tt.name, func(t *testing.T) {
   102  			node := ts.l.FindMidNode()
   103  			/*
   104  				var got interface{} = nil
   105  				if node != nil {
   106  					got = node.value
   107  				}
   108  				if got != tt.want {
   109  					t.Errorf("FindMidNode() = %v, want %v", got, ts.want)
   110  				}*/
   111  
   112  			node2 := ts.l.FindMidNode2()
   113  			if node != node2 {
   114  				t.Errorf("FindMidNode() = %v, want %v", node, node2)
   115  			}
   116  		})
   117  	}
   118  }
   119  
   120  func TestLinkedList_HasCycle(t *testing.T) {
   121  	n6 := &ListNode{value: 6}
   122  	n5 := &ListNode{value: 5, next: n6}
   123  	n4 := &ListNode{value: 4, next: n5}
   124  	n3 := &ListNode{value: 3, next: n4}
   125  	n2 := &ListNode{value: 2, next: n3}
   126  	n1 := &ListNode{value: 1, next: n2}
   127  	n6.next = n5
   128  	ll := &LinkedList{head: &ListNode{next: n1}}
   129  	t.Log(ll.HasCycle())
   130  }
   131  
   132  func TestMergeSortedList(t *testing.T) {
   133  	n5 := &ListNode{value: 9}
   134  	n4 := &ListNode{value: 7, next: n5}
   135  	n3 := &ListNode{value: 5, next: n4}
   136  	n2 := &ListNode{value: 3, next: n3}
   137  	n1 := &ListNode{value: 1, next: n2}
   138  	l1 := &LinkedList{head: &ListNode{next: n1}}
   139  
   140  	n12 := &ListNode{value: 12}
   141  	n11 := &ListNode{value: 11, next: n12}
   142  	n10 := &ListNode{value: 10, next: n11}
   143  	n9 := &ListNode{value: 8, next: n10}
   144  	n8 := &ListNode{value: 6, next: n9}
   145  	n7 := &ListNode{value: 4, next: n8}
   146  	n6 := &ListNode{value: 2, next: n7}
   147  	l2 := &LinkedList{head: &ListNode{next: n6}}
   148  
   149  	t.Log(l1)
   150  	t.Log(l2)
   151  	nl := MergeSortedList2(l1, l2)
   152  	t.Log("merge after ", nl)
   153  }
   154  
   155  func TestDeleteBottomN(t *testing.T) {
   156  	t.Log(l)
   157  	l.DeleteBottomN(1)
   158  	t.Log(l)
   159  }