改进garray排序数组

g/container/garray/garray_int.go

@@ -50,8 +50,8 @@ func (a *IntArray) Set(index int, value int) {
 func (a *IntArray) InsertBefore(index int, value int) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]int{}, a.array[index:]...)
-	a.array = append(a.array[0:index], value)
+	rear   := append([]int{}, a.array[index : ]...)
+	a.array = append(a.array[0 : index], value)
 	a.array = append(a.array, rear...)
 }
 
@@ -59,17 +59,19 @@ func (a *IntArray) InsertBefore(index int, value int) {
 func (a *IntArray) InsertAfter(index int, value int) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]int{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], value)
+	rear   := append([]int{}, a.array[index + 1:]...)
+	a.array = append(a.array[0 : index + 1], value)
 	a.array = append(a.array, rear...)
 
 }
 
 // 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *IntArray) Remove(index int) {
+func (a *IntArray) Remove(index int) int {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	a.array = append(a.array[:index], a.array[index+1:]...)
+	value  := a.array[index]
+	a.array = append(a.array[ : index], a.array[index + 1 : ]...)
+	return value
 }
 
 // 追加数据项

g/container/garray/garray_interface.go

@@ -59,16 +59,18 @@ func (a *Array) InsertBefore(index int, value interface{}) {
 func (a *Array) InsertAfter(index int, value interface{}) {
     a.mu.Lock()
     defer a.mu.Unlock()
-    rear   := append([]interface{}{}, a.array[index+1 : ]...)
-    a.array = append(a.array[0 : index+1], value)
+    rear   := append([]interface{}{}, a.array[index + 1 : ]...)
+    a.array = append(a.array[0 : index + 1], value)
     a.array = append(a.array, rear...)
 }
 
 // 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *Array) Remove(index int) {
+func (a *Array) Remove(index int) interface{} {
     a.mu.Lock()
     defer a.mu.Unlock()
+    value  := a.array[index]
     a.array = append(a.array[ : index], a.array[index + 1 : ]...)
+    return value
 }
 
 // 追加数据项

g/container/garray/garray_sorted_int.go

@@ -21,7 +21,7 @@ type SortedIntArray struct {
 }
 
 // 创建一个排序的int数组
-func NewSortedIntArray(size int, cap int, safe...bool) *SortedIntArray {
+func NewSortedIntArray(cap int, safe...bool) *SortedIntArray {
     return &SortedIntArray {
         mu          : rwmutex.New(safe...),
         array       : make([]int, 0, cap),
@@ -43,15 +43,15 @@ func (a *SortedIntArray) Add(values...int) {
     if len(values) == 0 {
         return
     }
+    a.mu.Lock()
+    defer a.mu.Unlock()
     for _, value := range values {
-        index, cmp := a.Search(value)
+        index, cmp := a.binSearch(value, false)
         if a.unique.Val() && cmp == 0 {
             continue
         }
-        a.mu.Lock()
         if index < 0 {
             a.array = append(a.array, value)
-            a.mu.Unlock()
             continue
         }
         // 加到指定索引后面
@@ -61,7 +61,6 @@ func (a *SortedIntArray) Add(values...int) {
         rear   := append([]int{}, a.array[index : ]...)
         a.array = append(a.array[0 : index], value)
         a.array = append(a.array, rear...)
-        a.mu.Unlock()
     }
 }
 
@@ -74,10 +73,31 @@ func (a *SortedIntArray) Get(index int) int {
 }
 
 // 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *SortedIntArray) Remove(index int) {
+func (a *SortedIntArray) Remove(index int) int {
     a.mu.Lock()
     defer a.mu.Unlock()
+    value  := a.array[index]
     a.array = append(a.array[ : index], a.array[index + 1 : ]...)
+    return value
+}
+
+// 将最左端(索引为0)的数据项移出数组，并返回该数据项
+func (a *SortedIntArray) PopLeft() int {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    value  := a.array[0]
+    a.array = a.array[1 : ]
+    return value
+}
+
+// 将最右端(索引为length - 1)的数据项移出数组，并返回该数据项
+func (a *SortedIntArray) PopRight() int {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    length := len(a.array)
+    value  := a.array[length - 1]
+    a.array = a.array[: length - 1]
+    return value
 }
 
 // 数组长度
@@ -107,10 +127,17 @@ func (a *SortedIntArray) Slice() []int {
 // 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
 // 返回值: 最后比较位置, 比较结果
 func (a *SortedIntArray) Search(value int) (int, int) {
+    return a.binSearch(value, true)
+}
+
+func (a *SortedIntArray) binSearch(value int, lock bool) (int, int) {
     if len(a.array) == 0 {
         return -1, -2
     }
-    a.mu.RLock()
+    if lock {
+        a.mu.RLock()
+        defer a.mu.RUnlock()
+    }
     min := 0
     max := len(a.array) - 1
     mid := 0
@@ -127,7 +154,6 @@ func (a *SortedIntArray) Search(value int) (int, int) {
             break
         }
     }
-    a.mu.RUnlock()
     return mid, cmp
 }
 

g/container/garray/garray_sorted_interface.go

@@ -34,15 +34,15 @@ func (a *SortedArray) Add(values...interface{}) {
     if len(values) == 0 {
         return
     }
+    a.mu.Lock()
+    defer a.mu.Unlock()
     for _, value := range values {
-        index, cmp := a.Search(value)
+        index, cmp := a.binSearch(value, false)
         if a.unique.Val() && cmp == 0 {
             continue
         }
-        a.mu.Lock()
         if index < 0 {
             a.array = append(a.array, value)
-            a.mu.Unlock()
             continue
         }
         // 加到指定索引后面
@@ -52,7 +52,6 @@ func (a *SortedArray) Add(values...interface{}) {
         rear   := append([]interface{}{}, a.array[index : ]...)
         a.array = append(a.array[0 : index], value)
         a.array = append(a.array, rear...)
-        a.mu.Unlock()
     }
 }
 
@@ -65,10 +64,31 @@ func (a *SortedArray) Get(index int) interface{} {
 }
 
 // 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *SortedArray) Remove(index int) {
+func (a *SortedArray) Remove(index int) interface{} {
     a.mu.Lock()
     defer a.mu.Unlock()
+    value  := a.array[index]
     a.array = append(a.array[ : index], a.array[index + 1 : ]...)
+    return value
+}
+
+// 将最左端(索引为0)的数据项移出数组，并返回该数据项
+func (a *SortedArray) PopLeft() interface{} {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    value  := a.array[0]
+    a.array = a.array[1 : ]
+    return value
+}
+
+// 将最右端(索引为length - 1)的数据项移出数组，并返回该数据项
+func (a *SortedArray) PopRight() interface{} {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    length := len(a.array)
+    value  := a.array[length - 1]
+    a.array = a.array[: length - 1]
+    return value
 }
 
 // 数组长度
@@ -98,10 +118,19 @@ func (a *SortedArray) Slice() []interface{} {
 // 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
 // 返回值: 最后比较位置, 比较结果
 func (a *SortedArray) Search(value interface{}) (int, int) {
+    return a.binSearch(value, true)
+}
+
+// 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
+// 返回值: 最后比较位置, 比较结果
+func (a *SortedArray) binSearch(value interface{}, lock bool) (int, int) {
     if len(a.array) == 0 {
         return -1, -2
     }
-    a.mu.RLock()
+    if lock {
+        a.mu.RLock()
+        defer a.mu.RUnlock()
+    }
     min := 0
     max := len(a.array) - 1
     mid := 0
@@ -118,7 +147,6 @@ func (a *SortedArray) Search(value interface{}) (int, int) {
             break
         }
     }
-    a.mu.RUnlock()
     return mid, cmp
 }
 
@@ -134,6 +162,7 @@ func (a *SortedArray) SetUnique(unique bool) {
 // 清理数组中重复的元素项
 func (a *SortedArray) doUnique() {
     a.mu.Lock()
+    defer a.mu.Unlock()
     i := 0
     for {
         if i == len(a.array) - 1 {
@@ -145,7 +174,6 @@ func (a *SortedArray) doUnique() {
             i++
         }
     }
-    a.mu.Unlock()
 }
 
 // 清空数据数组

g/container/garray/garray_sorted_string.go

@@ -34,27 +34,27 @@ func NewSortedStringArray(cap int, safe...bool) *SortedStringArray {
 
 // 添加加数据项
 func (a *SortedStringArray) Add(values...string) {
-    if len(values) > 0 {
-        for _, value := range values {
-            index, cmp := a.Search(value)
-            if a.unique.Val() && cmp == 0 {
-                continue
-            }
-            a.mu.Lock()
-            if index < 0 {
-                a.array = append(a.array, value)
-                a.mu.Unlock()
-                continue
-            }
-            // 加到指定索引后面
-            if cmp > 0 {
-                index++
-            }
-            rear   := append([]string{}, a.array[index : ]...)
-            a.array = append(a.array[0 : index], value)
-            a.array = append(a.array, rear...)
-            a.mu.Unlock()
+    if len(values) == 0 {
+        return
+    }
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    for _, value := range values {
+        index, cmp := a.binSearch(value, false)
+        if a.unique.Val() && cmp == 0 {
+            continue
         }
+        if index < 0 {
+            a.array = append(a.array, value)
+            continue
+        }
+        // 加到指定索引后面
+        if cmp > 0 {
+            index++
+        }
+        rear   := append([]string{}, a.array[index : ]...)
+        a.array = append(a.array[0 : index], value)
+        a.array = append(a.array, rear...)
     }
 }
 
@@ -67,10 +67,31 @@ func (a *SortedStringArray) Get(index int) string {
 }
 
 // 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *SortedStringArray) Remove(index int) {
+func (a *SortedStringArray) Remove(index int) string {
     a.mu.Lock()
     defer a.mu.Unlock()
+    value  := a.array[index]
     a.array = append(a.array[ : index], a.array[index + 1 : ]...)
+    return value
+}
+
+// 将最左端(索引为0)的数据项移出数组，并返回该数据项
+func (a *SortedStringArray) PopLeft() string {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    value  := a.array[0]
+    a.array = a.array[1 : ]
+    return value
+}
+
+// 将最右端(索引为length - 1)的数据项移出数组，并返回该数据项
+func (a *SortedStringArray) PopRight() string {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    length := len(a.array)
+    value  := a.array[length - 1]
+    a.array = a.array[: length - 1]
+    return value
 }
 
 // 数组长度
@@ -100,10 +121,17 @@ func (a *SortedStringArray) Slice() []string {
 // 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
 // 返回值: 最后比较位置, 比较结果
 func (a *SortedStringArray) Search(value string) (int, int) {
+    return a.binSearch(value, true)
+}
+
+func (a *SortedStringArray) binSearch(value string, lock bool) (int, int) {
     if len(a.array) == 0 {
         return -1, -2
     }
-    a.mu.RLock()
+    if lock {
+        a.mu.RLock()
+        defer a.mu.RUnlock()
+    }
     min := 0
     max := len(a.array) - 1
     mid := 0
@@ -120,7 +148,6 @@ func (a *SortedStringArray) Search(value string) (int, int) {
             break
         }
     }
-    a.mu.RUnlock()
     return mid, cmp
 }
 

g/container/garray/garray_string.go

@@ -51,8 +51,8 @@ func (a *StringArray) Set(index int, value string) {
 func (a *StringArray) InsertBefore(index int, value string) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]string{}, a.array[index:]...)
-	a.array = append(a.array[0:index], value)
+	rear   := append([]string{}, a.array[index : ]...)
+	a.array = append(a.array[0 : index], value)
 	a.array = append(a.array, rear...)
 }
 
@@ -60,16 +60,18 @@ func (a *StringArray) InsertBefore(index int, value string) {
 func (a *StringArray) InsertAfter(index int, value string) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]string{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], value)
+	rear   := append([]string{}, a.array[index + 1:]...)
+	a.array = append(a.array[ 0: index + 1], value)
 	a.array = append(a.array, rear...)
 }
 
 // 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *StringArray) Remove(index int) {
+func (a *StringArray) Remove(index int) string {
 	a.mu.Lock()
 	defer a.mu.RUnlock()
-	a.array = append(a.array[:index], a.array[index+1:]...)
+	value  := a.array[index]
+	a.array = append(a.array[ : index], a.array[index + 1 : ]...)
+	return value
 }
 
 // 追加数据项

geg/other/test.go

@@ -1,14 +1,12 @@
 package main
 
 import (
-    "gitee.com/johng/gf/g/os/gtime"
     "fmt"
+    "gitee.com/johng/gf/g/encoding/gurl"
+    "gitee.com/johng/gf/g/encoding/ghtml"
 )
 
 func main() {
-    t := gtime.Now()
-    err := t.ToZone("Asia/Aden")
-    fmt.Println(err)
-    fmt.Println(t.String())
-    //fmt.Println(string([]byte{112,108,97,121,101,114,105,100}))
+    fmt.Println(gurl.Decode("<"))
+    fmt.Println(ghtml.SpecialChars("<"))
 }