diff --git a/list/arraylist/arraylist.go b/list/arraylist/arraylist.go
index 17eb610..aa52a9e 100644
--- a/list/arraylist/arraylist.go
+++ b/list/arraylist/arraylist.go
@@ -1,218 +1,302 @@
 package arraylist
 
-import (
-	"fmt"
-	"strings"
-
-	"github.com/emirpasic/gods/lists"
-	"github.com/emirpasic/gods/utils"
-)
-
-func assertListImplementation() {
-	var _ lists.List = (*ArrayList)(nil)
-}
+import "log"
 
 type ArrayList struct {
-	data []interface{}
-	size int
+	data          []interface{}
+	hidx          uint
+	tidx          uint
+	size          uint
+	growSizePoint uint
 }
 
 const (
+	listLimit    = uint(1) << 63
+	initCap      = uint(8)
 	growthFactor = float32(2.0)  // growth by 100%
 	shrinkFactor = float32(0.25) // shrink when size is 25% of capacity (0 means never shrink)
 )
 
 // New instantiates a new list and adds the passed values, if any, to the list
-func New(values ...interface{}) *ArrayList {
-	list := &ArrayList{}
-	if len(values) > 0 {
-		list.Add(values...)
-	}
-	return list
+func New() *ArrayList {
+	l := &ArrayList{}
+	l.data = make([]interface{}, initCap, initCap)
+	l.tidx = initCap / 2
+	l.hidx = l.tidx - 1
+	return l
 }
 
-// Add appends a value at the end of the list
-func (list *ArrayList) Add(values ...interface{}) {
-	list.growBy(len(values))
-	for _, value := range values {
-		list.data[list.size] = value
-		list.size++
+func (l *ArrayList) Clear() {
+	l.data = make([]interface{}, 8, 8)
+	l.tidx = initCap / 2
+	l.hidx = l.tidx - 1
+	l.size = 0
+}
+
+func (l *ArrayList) Empty() bool {
+	return l.size == 0
+}
+
+func (l *ArrayList) Size() uint {
+	return l.size
+}
+
+func (l *ArrayList) shrink() {
+
+}
+
+// 后续需要优化 growth 策略
+func (l *ArrayList) growth(flag int) {
+
+	if l.size >= listLimit {
+		log.Panic("list size is over limit", listLimit)
+	}
+
+	switch flag {
+	case -1:
+		growthsize := l.size << 1
+		temp := make([]interface{}, growthsize, growthsize)
+
+		ghidx := l.size / 2
+		gtidx := ghidx + l.size + 1
+		copy(temp[ghidx+1:], l.data[l.hidx+1:l.tidx])
+		l.data = temp
+		l.hidx = ghidx
+		l.tidx = gtidx
+	case 1:
+		growthsize := l.size << 1
+		temp := make([]interface{}, growthsize, growthsize)
+
+		ghidx := l.size / 2
+		gtidx := ghidx + l.size + 1
+		copy(temp[ghidx+1:], l.data[l.hidx+1:l.tidx])
+		l.data = temp
+		l.hidx = ghidx
+		l.tidx = gtidx
+	case 0:
+		growthsize := l.size << 1
+		temp := make([]interface{}, growthsize, growthsize)
+
+		ghidx := l.size / 2
+		gtidx := ghidx + l.size + 1
+		copy(temp[ghidx+1:], l.data[l.hidx+1:l.tidx])
+		l.data = temp
+		l.hidx = ghidx
+		l.tidx = gtidx
 	}
 }
 
-// Get returns the element at index.
-// Second return parameter is true if index is within bounds of the array and array is not empty, otherwise false.
-func (list *ArrayList) Get(index int) (interface{}, bool) {
+func (l *ArrayList) PushFront(values ...interface{}) {
+	psize := uint(len(values))
+	if l.hidx+1-psize > listLimit {
+		l.growth(-1)
+		// panic("growth -1")
+	}
 
-	if !list.withinRange(index) {
+	for _, v := range values {
+		l.data[l.hidx] = v
+		l.hidx--
+	}
+	l.size += psize
+}
+
+func (l *ArrayList) PushBack(values ...interface{}) {
+	psize := uint(len(values))
+	if l.tidx+psize >= uint(len(l.data)) {
+		l.growth(1)
+	}
+
+	for _, v := range values {
+		l.data[l.tidx] = v
+		l.tidx++
+	}
+	l.size += psize
+}
+
+func (l *ArrayList) PopFront() (result interface{}, found bool) {
+	if l.size != 0 {
+		l.size--
+		l.hidx++
+		return l.data[l.hidx], true
+	}
+	return nil, false
+}
+
+func (l *ArrayList) PopBack() (result interface{}, found bool) {
+	if l.size != 0 {
+		l.size--
+		l.tidx--
+		return l.data[l.tidx], true
+	}
+	return nil, false
+}
+
+func (l *ArrayList) Index(idx uint) (interface{}, bool) {
+	if idx < l.size {
+		return l.data[idx+l.hidx+1], true
+	}
+	return nil, false
+}
+
+func (l *ArrayList) Remove(idx uint) (result interface{}, isfound bool) {
+
+	if idx < l.size {
 		return nil, false
 	}
 
-	return list.data[index], true
+	offset := l.hidx + 1 + idx
+
+	isfound = true
+	result = l.data[offset]
+	l.data[offset] = nil // cleanup reference
+
+	copy(l.data[offset:], l.data[idx+1:l.size]) // shift to the left by one (slow operation, need ways to optimize this)
+	l.size--
+	l.shrink()
+
+	return
 }
 
-// Remove removes the element at the given index from the list.
-func (list *ArrayList) Remove(index int) {
+// func (list *ArrayList) Contains(values ...interface{}) bool {
 
-	if !list.withinRange(index) {
-		return
-	}
+// 	for _, searchValue := range values {
+// 		found := false
+// 		for _, element := range list.data {
+// 			if element == searchValue {
+// 				found = true
+// 				break
+// 			}
+// 		}
+// 		if !found {
+// 			return false
+// 		}
+// 	}
+// 	return true
+// }
 
-	list.data[index] = nil                                // cleanup reference
-	copy(list.data[index:], list.data[index+1:list.size]) // shift to the left by one (slow operation, need ways to optimize this)
-	list.size--
-
-	list.shrink()
-}
-
-// Contains checks if elements (one or more) are present in the set.
-// All elements have to be present in the set for the method to return true.
-// Performance time complexity of n^2.
-// Returns true if no arguments are passed at all, i.e. set is always super-set of empty set.
-func (list *ArrayList) Contains(values ...interface{}) bool {
-
-	for _, searchValue := range values {
-		found := false
-		for _, element := range list.data {
-			if element == searchValue {
-				found = true
-				break
-			}
-		}
-		if !found {
-			return false
-		}
-	}
-	return true
-}
-
-// Values returns all elements in the list.
-func (list *ArrayList) Values() []interface{} {
-	newElements := make([]interface{}, list.size, list.size)
-	copy(newElements, list.data[:list.size])
+func (l *ArrayList) Values() []interface{} {
+	newElements := make([]interface{}, l.size, l.size)
+	copy(newElements, l.data[l.hidx+1:l.tidx])
 	return newElements
 }
 
-//IndexOf returns index of provided element
-func (list *ArrayList) IndexOf(value interface{}) int {
-	if list.size == 0 {
-		return -1
-	}
-	for index, element := range list.data {
-		if element == value {
-			return index
-		}
-	}
-	return -1
-}
+// func (list *ArrayList) IndexOf(value interface{}) int {
+// 	if list.size == 0 {
+// 		return -1
+// 	}
+// 	for index, element := range list.data {
+// 		if element == value {
+// 			return index
+// 		}
+// 	}
+// 	return -1
+// }
 
-// Empty returns true if list does not contain any elements.
-func (list *ArrayList) Empty() bool {
-	return list.size == 0
-}
+// func (list *ArrayList) Empty() bool {
+// 	return list.size == 0
+// }
 
-// Size returns number of elements within the list.
-func (list *ArrayList) Size() int {
-	return list.size
-}
+// func (list *ArrayList) Size() int {
+// 	return list.size
+// }
 
-// Clear removes all elements from the list.
-func (list *ArrayList) Clear() {
-	list.size = 0
-	list.data = []interface{}{}
-}
+// // Clear removes all elements from the list.
+// func (list *ArrayList) Clear() {
+// 	list.size = 0
+// 	list.data = []interface{}{}
+// }
 
-// Sort sorts values (in-place) using.
-func (list *ArrayList) Sort(comparator utils.Comparator) {
-	if len(list.data) < 2 {
-		return
-	}
-	utils.Sort(list.data[:list.size], comparator)
-}
+// // Sort sorts values (in-place) using.
+// func (list *ArrayList) Sort(comparator utils.Comparator) {
+// 	if len(list.data) < 2 {
+// 		return
+// 	}
+// 	utils.Sort(list.data[:list.size], comparator)
+// }
 
-// Swap swaps the two values at the specified positions.
-func (list *ArrayList) Swap(i, j int) {
-	if list.withinRange(i) && list.withinRange(j) {
-		list.data[i], list.data[j] = list.data[j], list.data[i]
-	}
-}
+// // Swap swaps the two values at the specified positions.
+// func (list *ArrayList) Swap(i, j int) {
+// 	if list.withinRange(i) && list.withinRange(j) {
+// 		list.data[i], list.data[j] = list.data[j], list.data[i]
+// 	}
+// }
 
-// Insert inserts values at specified index position shifting the value at that position (if any) and any subsequent elements to the right.
-// Does not do anything if position is negative or bigger than list's size
-// Note: position equal to list's size is valid, i.e. append.
-func (list *ArrayList) Insert(index int, values ...interface{}) {
+// // Insert inserts values at specified index position shifting the value at that position (if any) and any subsequent elements to the right.
+// // Does not do anything if position is negative or bigger than list's size
+// // Note: position equal to list's size is valid, i.e. append.
+// func (list *ArrayList) Insert(index int, values ...interface{}) {
 
-	if !list.withinRange(index) {
-		// Append
-		if index == list.size {
-			list.Add(values...)
-		}
-		return
-	}
+// 	if !list.withinRange(index) {
+// 		// Append
+// 		if index == list.size {
+// 			list.Add(values...)
+// 		}
+// 		return
+// 	}
 
-	l := len(values)
-	list.growBy(l)
-	list.size += l
-	copy(list.data[index+l:], list.data[index:list.size-l])
-	copy(list.data[index:], values)
-}
+// 	l := len(values)
+// 	list.growBy(l)
+// 	list.size += l
+// 	copy(list.data[index+l:], list.data[index:list.size-l])
+// 	copy(list.data[index:], values)
+// }
 
-// Set the value at specified index
-// Does not do anything if position is negative or bigger than list's size
-// Note: position equal to list's size is valid, i.e. append.
-func (list *ArrayList) Set(index int, value interface{}) {
+// // Set the value at specified index
+// // Does not do anything if position is negative or bigger than list's size
+// // Note: position equal to list's size is valid, i.e. append.
+// func (list *ArrayList) Set(index int, value interface{}) {
 
-	if !list.withinRange(index) {
-		// Append
-		if index == list.size {
-			list.Add(value)
-		}
-		return
-	}
+// 	if !list.withinRange(index) {
+// 		// Append
+// 		if index == list.size {
+// 			list.Add(value)
+// 		}
+// 		return
+// 	}
 
-	list.data[index] = value
-}
+// 	list.data[index] = value
+// }
 
-// String returns a string representation of container
-func (list *ArrayList) String() string {
-	str := "ArrayList\n"
-	values := []string{}
-	for _, value := range list.data[:list.size] {
-		values = append(values, fmt.Sprintf("%v", value))
-	}
-	str += strings.Join(values, ", ")
-	return str
-}
+// // String returns a string representation of container
+// func (list *ArrayList) String() string {
+// 	str := "ArrayList\n"
+// 	values := []string{}
+// 	for _, value := range list.data[:list.size] {
+// 		values = append(values, fmt.Sprintf("%v", value))
+// 	}
+// 	str += strings.Join(values, ", ")
+// 	return str
+// }
 
-// Check that the index is within bounds of the list
-func (list *ArrayList) withinRange(index int) bool {
-	return index >= 0 && index < list.size
-}
+// // Check that the index is within bounds of the list
+// func (list *ArrayList) withinRange(index int) bool {
+// 	return index >= 0 && index < list.size
+// }
 
-func (list *ArrayList) resize(cap int) {
-	newElements := make([]interface{}, cap, cap)
-	copy(newElements, list.data)
-	list.data = newElements
-}
+// func (list *ArrayList) resize(cap int) {
+// 	newElements := make([]interface{}, cap, cap)
+// 	copy(newElements, list.data)
+// 	list.data = newElements
+// }
 
-// Expand the array if necessary, i.e. capacity will be reached if we add n elements
-func (list *ArrayList) growBy(n int) {
-	// When capacity is reached, grow by a factor of growthFactor and add number of elements
-	currentCapacity := cap(list.data)
-	if list.size+n >= currentCapacity {
-		newCapacity := int(growthFactor * float32(currentCapacity+n))
-		list.resize(newCapacity)
-	}
-}
+// // Expand the array if necessary, i.e. capacity will be reached if we add n elements
+// func (list *ArrayList) growBy(n int) {
+// 	// When capacity is reached, grow by a factor of growthFactor and add number of elements
+// 	currentCapacity := cap(list.data)
+// 	if list.size+n >= currentCapacity {
+// 		newCapacity := int(growthFactor * float32(currentCapacity+n))
+// 		list.resize(newCapacity)
+// 	}
+// }
 
-// Shrink the array if necessary, i.e. when size is shrinkFactor percent of current capacity
-func (list *ArrayList) shrink() {
-	if shrinkFactor == 0.0 {
-		return
-	}
-	// Shrink when size is at shrinkFactor * capacity
-	currentCapacity := cap(list.data)
-	if list.size <= int(float32(currentCapacity)*shrinkFactor) {
-		list.resize(list.size)
-	}
-}
+// // Shrink the array if necessary, i.e. when size is shrinkFactor percent of current capacity
+// func (list *ArrayList) shrink() {
+// 	if shrinkFactor == 0.0 {
+// 		return
+// 	}
+// 	// Shrink when size is at shrinkFactor * capacity
+// 	currentCapacity := cap(list.data)
+// 	if list.size <= int(float32(currentCapacity)*shrinkFactor) {
+// 		list.resize(list.size)
+// 	}
+// }
diff --git a/list/arraylist/arraylist_test.go b/list/arraylist/arraylist_test.go
index 92ea55d..aa77f4c 100644
--- a/list/arraylist/arraylist_test.go
+++ b/list/arraylist/arraylist_test.go
@@ -8,80 +8,90 @@ import (
 
 func TestPush(t *testing.T) {
 	l := New()
-	for i := 0; i < 5; i++ {
-		l.Push(i)
+	for i := 0; i < 2; i++ {
+		l.PushFront(1)
 	}
 	var result string
 	result = spew.Sprint(l.Values())
-	if result != "[4 3 2 1 0]" {
+	if result != "[1 1]" {
 		t.Error(result)
 	}
 
-	l.Push(0)
+	for i := 0; i < 2; i++ {
+		l.PushBack(2)
+	}
 	result = spew.Sprint(l.Values())
-	if result != "[0 4 3 2 1 0]" {
+	if result != "[1 1 2 2]" {
 		t.Error(result)
 	}
 }
 
+func TestGrowth(t *testing.T) {
+	l := New()
+	for i := 0; i < 5; i++ {
+		l.PushFront(1)
+	}
+
+	var result string
+	result = spew.Sprint(l.Values())
+	if result != "[1 1]" {
+		t.Error(result)
+	}
+
+	l = New()
+	for i := 0; i < 7; i++ {
+		l.PushBack(1)
+	}
+
+	result = spew.Sprint(l.Values())
+	if result != "[1 1]" {
+		t.Error(result)
+	}
+
+	// for i := 0; i < 2; i++ {
+	// 	l.PushBack(2)
+	// }
+	// result = spew.Sprint(l.Values())
+	// if result != "[1 1 2 2]" {
+	// 	t.Error(result)
+	// }
+}
+
 func TestPop(t *testing.T) {
 	l := New()
 	for i := 0; i < 5; i++ {
-		l.Push(i)
+		l.PushFront(i)
 	}
 
-	if v, ok := l.Pop(); ok {
-		if v != 4 {
-			t.Error(v)
-		}
-	} else {
-		t.Error("Pop should ok, but is not ok")
-	}
-
-	var result string
-	result = spew.Sprint(l.Values())
-	if result != "[3 2 1 0]" {
-		t.Error(result)
-	}
-
-	for i := 3; l.Size() != 0; i-- {
-		if v, ok := l.Pop(); ok {
+	for i := 4; i >= 0; i-- {
+		if v, ok := l.PopFront(); ok {
 			if v != i {
-				t.Error(i, v, "is not equals")
+				t.Error("should be ", v)
 			}
 		} else {
-			t.Error("Pop should ok, but is not ok", i)
+			t.Error("should be ok, value is", v)
 		}
 	}
 
-	l.Push(0)
-	result = spew.Sprint(l.Values())
-	if result != "[0]" {
-		t.Error(result)
-	}
-
-	if l.Size() != 1 {
-		t.Error("l.Size() == 1, but is error, size = ", l.Size())
-	}
-}
-
-func TestRemove(t *testing.T) {
-	l := New()
-	for i := 0; i < 5; i++ {
-		l.Push(i)
+	if v, ok := l.PopFront(); ok {
+		t.Error("should not be ok, v = ", v)
 	}
 
 	for i := 0; i < 5; i++ {
-		if n, ok := l.Remove(0); ok {
-			if n != 4-i {
-				t.Error(n)
+		l.PushFront(i)
+	}
+
+	for i := 0; i < 5; i++ {
+		if v, ok := l.PopBack(); ok {
+			if v != i {
+				t.Error("should be ", v)
 			}
 		} else {
-			t.Error("Pop should ok, but is not ok", i)
+			t.Error("should be ok, value is", v)
 		}
 	}
 
-	if l.Size() != 0 {
-		t.Error("l.Size() == 0, but is error, size = ", l.Size())
+	if v, ok := l.PopBack(); ok {
+		t.Error("should not be ok, v = ", v)
 	}
 }
diff --git a/list/linkedlist/linkedlist.go b/list/linkedlist/linkedlist.go
index f939247..6d22c4a 100644
--- a/list/linkedlist/linkedlist.go
+++ b/list/linkedlist/linkedlist.go
@@ -37,6 +37,16 @@ func New() *LinkedList {
 	return l
 }
 
+func (l *LinkedList) Clear() {
+	l.head.next = nil
+	l.tail.prev = nil
+	l.size = 0
+}
+
+func (l *LinkedList) Empty() bool {
+	return l.size == 0
+}
+
 func (l *LinkedList) Size() uint {
 	return l.size
 }
diff --git a/list/linkedlist/linkedlist_test.go b/list/linkedlist/linkedlist_test.go
index 4123794..d00083e 100644
--- a/list/linkedlist/linkedlist_test.go
+++ b/list/linkedlist/linkedlist_test.go
@@ -507,65 +507,3 @@ func BenchmarkInsert(b *testing.B) {
 		}
 	}
 }
-
-// func TestPop(t *testing.T) {
-// 	l := New()
-// 	for i := 0; i < 5; i++ {
-// 		l.Push(i)
-// 	}
-
-// 	if v, ok := l.Pop(); ok {
-// 		if v != 4 {
-// 			t.Error(v)
-// 		}
-// 	} else {
-// 		t.Error("Pop should ok, but is not ok")
-// 	}
-
-// 	var result string
-// 	result = spew.Sprint(l.Values())
-// 	if result != "[3 2 1 0]" {
-// 		t.Error(result)
-// 	}
-
-// 	for i := 3; l.Size() != 0; i-- {
-// 		if v, ok := l.Pop(); ok {
-// 			if v != i {
-// 				t.Error(i, v, "is not equals")
-// 			}
-// 		} else {
-// 			t.Error("Pop should ok, but is not ok", i)
-// 		}
-// 	}
-
-// 	l.Push(0)
-// 	result = spew.Sprint(l.Values())
-// 	if result != "[0]" {
-// 		t.Error(result)
-// 	}
-
-// 	if l.Size() != 1 {
-// 		t.Error("l.Size() == 1, but is error, size = ", l.Size())
-// 	}
-// }
-
-// func TestRemove(t *testing.T) {
-// 	l := New()
-// 	for i := 0; i < 5; i++ {
-// 		l.Push(i)
-// 	}
-
-// 	for i := 0; i < 5; i++ {
-// 		l.Remove(0)
-// 		if l.head != nil {
-// 			if l.head.Value() != 4-i-1 {
-// 				t.Error("l.head is error")
-// 			}
-// 		}
-// 		t.Error(l.Size())
-// 	}
-
-// 	if l.Size() != 0 {
-// 		t.Error("l.Size() == 0, but is error, size = ", l.Size())
-// 	}
-// }