整理: 整理readme && 文件结构

Change-Id: Ib69836e77756e97cb37462ad6d38ba4a1e57ee80

Author: qieguo2016

README.md

@@ -40,89 +40,66 @@ golang源码的双向链表实现(代码在container/list/)亮点：
 2. 节点元素与链表分开两种数据结构
 
 
-#### [线性表：数组与链表、队列与栈](/md/数组与链表，堆栈与队列.md)
-
-介绍了基本数据结构之线性表的特点和原理以及js的算法实现。
-由于js语言本身的特点，线性表在js中主要以数组的应用为主，而js数组本身也并不是传统意义上的连续线性表。
-
-#### [哈希表：js对象与哈希表](/md/js对象与哈希表.md)
-
-js对象大家都用的很多，但其底层的哈希表特性你是否清楚？
-在这篇文章里，小茄会用最平白易懂的语言来讲哈希结构的原理、构造方法，当然，还有哈希表在js中的应用。
-
-#### [树：js中的树与二叉树](/md/js中的树.md)
-
-树是一种带有层次的数据结构，分层特性可以用于实现数据存储和快速查找。
-比较常见的应用场景就是各种目录结构，如文件目录、DOM结构等，由于每指定一层就是一层筛选，所以可以用于快速查找。
-js中可以通过对象的哈希结构来实现树结构，两种数据结构结合，速度更快。
-
 ## 算法部分
 
 > ***做任何算法的时候，都要先弄清需求！如果是需要构造一个函数，那一定要弄清楚函数的调用方式、各参数的含义，多举几个例子说明。只有弄懂了这个函数应该是怎样的，才有可能写出符合要求的函数***
 
-- [数组相关](#array)
-
+- [LeetCode](#LeetCode)
+- [设计模式](#design)
 - [排序相关](#sort)
-
 - [递归相关](#recursive)
-
+- [数组相关](#array)
 - [其他](#other)
 
-- [leetcode (golang)] (#leetcode)
+### [LeetCode](/go/leetcode)
 
-### Array [array.js](/js/array.js)
+LeetCode解题(golang)
 
-- indexOfArray：数组子串位置查询
-
-- arrayFilter：数组筛选
-
-- arrayUnique: 数组去重
+### [design](/go/basic)
 
-- combineArray: 数组归并排序
+- [并发安全单例实现](/go/basic/concurrency/singleton.go)
+- [once实现](/go/basic/concurrency/once.go)
+- [两个线程交替输出](/go/basic/concurrency/alternate.go)
 
-- longestSubArray: 数组最长无重复子串查找
+### [sort](/go/basic/sort)
 
-- longestSubArrayHash: 利用哈希表去重的数组最长无重复子串查找
-
-### sort [sort.js](/js/sort.js)
+golang实现：
+- [bubbleSort：冒泡排序](/go/basic/sort/sort.go#L5)
+- [selectSort：选择排序](/go/basic/sort/sort.go#L21)
+- [quickSort：快速排序](/go/basic/sort/sort.go#L39)
+- [quickSort：原地快速排序](/go/basic/sort/sort.go#L61)
 
+js实现：
 - [bubbleSort：冒泡排序](/js/sort.js#L20)
-
 - [selectSort：选择排序](/js/sort.js#L36)
-
 - [straightInsertionSort: 直接插入排序](/js/sort.js#L52)
-
 - [shellSort：希尔排序](/js/sort.js#L72)
-
 - [quickSort：快速排序](/js/sort.js#L101)
-
 - [inPlaceQuickSort：原地快速排序](/js/sort.js#L127)
-
 - [mergeSort：归并排序](/js/sort.js#L159)
-
 - [heapSort：堆排序](/js/sort.js#L192)
 
-### recursive[recursive.js](/md/递归.md)
+### recursive [recursive.js](/md/递归.md)
 
 - [阶梯问题](/js/recursive.js#L10)
-
 - [链式函数](/js/recursive.js#L36)
-
 - [汉诺塔问题](/js/recursive.js#L47)
 
+### [Array](/js/array.js)
+
+- indexOfArray：数组子串位置查询
+- arrayFilter：数组筛选
+- arrayUnique: 数组去重
+- combineArray: 数组归并排序
+- longestSubArray: 数组最长无重复子串查找
+- longestSubArrayHash: 利用哈希表去重的数组最长无重复子串查找
+
 ### other
 
 - [订阅发布者事件模型](/js/event.js)
-
 - [节流函数](/js/others.js#L7)
-
 - [防抖函数](/js/others.js#L21)
 
-### leetcode
-
-LeetCode的golang解题：[leetcode](/go/leetcode)
-
-
 
 
 

go/basic/concurrency/concurrency.go renamed to go/basic/concurrency/alternate.go

@@ -8,33 +8,6 @@ import (
 	"time"
 )
 
-// sync底层使用锁和原子自增实现once效果
-type Once struct {
-	mu    sync.Mutex
-	count int32
-}
-
-// 提供一个do方法
-func (o *Once) Do(f func()) {
-	// 使用cas限制第一次也OK？
-	// 不ok，因为两个g同时进来的时候，其中一个没有执行f，另外一个执行了f，两个g后面取到的值是有差异的，一致性不满足
-	// 而采用源码的方式，在抢互斥锁的时候另外一个线程堵塞，保证后续运行时都是在f执行后的状态
-	// if atomic.CompareAndSwapInt32(&o.count, 0, 1) {
-	// 	f()
-	// }
-
-	// 源码实现，先原子取数，然后再抢锁，抢到之后判断是否执行过f，若未执行则调用f，然后再原子+1
-	if atomic.LoadInt32(&o.count) == 1 {
-		return
-	}
-	o.mu.Lock()
-	if o.count == 0 {
-		f()
-		atomic.StoreInt32(&o.count, 1)
-	}
-	o.mu.Unlock()
-}
-
 /*
 	多线程交替输出：
 	新开两个子线程，分别输出1,3,5,7,9...和2,4,6,8,10...，主线程接受子线程的值，输出1,2,3,4,5...

go/basic/concurrency/concurrency_test.go

@@ -4,32 +4,10 @@ import (
 	"fmt"
 	"runtime"
 
-	"sync"
 	"testing"
 	"time"
 )
 
-type Single struct {
-	Value int32
-}
-
-var i int32
-var s *Single
-
-var _ = new(sync.Once)
-var once = new(Once)
-
-// 获取全局单例
-func GetGlobalSingle() *Single {
-	once.Do(func() {
-		s = &Single{
-			Value: i,
-		}
-		i++ // 方便检查是否单例
-	})
-	return s
-}
-
 func TestGlobalSingle(t *testing.T) {
 	n := runtime.NumCPU()
 	fmt.Println("cup num=", n)

go/basic/concurrency/once.go

@@ -0,0 +1,33 @@
+package concurrency
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// Once sync底层使用锁和原子自增实现once效果
+type Once struct {
+	mu    sync.Mutex
+	count int32
+}
+
+// Do 提供一个do方法
+func (o *Once) Do(f func()) {
+	// 使用cas限制第一次也OK？
+	// 不ok，因为两个g同时进来的时候，其中一个没有执行f，另外一个执行了f，两个g后面取到的值是有差异的，一致性不满足
+	// 而采用源码的方式，在抢互斥锁的时候另外一个线程堵塞，保证后续运行时都是在f执行后的状态
+	// if atomic.CompareAndSwapInt32(&o.count, 0, 1) {
+	// 	f()
+	// }
+
+	// 源码实现，先原子取数，然后再抢锁，抢到之后判断是否执行过f，若未执行则调用f，然后再原子+1
+	if atomic.LoadInt32(&o.count) == 1 {
+		return
+	}
+	o.mu.Lock()
+	if o.count == 0 {
+		f()
+		atomic.StoreInt32(&o.count, 1)
+	}
+	o.mu.Unlock()
+}

go/basic/concurrency/singleton.go

@@ -0,0 +1,26 @@
+package concurrency
+
+import (
+	"sync"
+	"time"
+)
+
+// Singleton 单例
+type Singleton struct {
+	Value int64
+}
+
+var s *Singleton
+
+var _ = new(sync.Once)
+var once = new(Once)
+
+// GetGlobalSingle 使用once来实现全局单例
+func GetGlobalSingle() *Singleton {
+	once.Do(func() {
+		s = &Singleton{
+			Value: time.Now().Unix(),
+		}
+	})
+	return s
+}