2. 程式人生 > >erlang下lists模塊sort（排序）方法源碼解析

erlang下lists模塊sort（排序）方法源碼解析

阿新 • • 發佈：2018-05-22
簡單的 我們 asc HR 最簡 lse color ble 最小

排序算法一直是各種語言最簡單也是最復雜的算法，例如十大經典排序算法（動圖演示）裏面講的那樣

第一次看lists的sort方法的時候，蒙了，幾百行的代碼，我心想要這麽復雜麽（因為C語言的冒泡排序我記得不超過30行），於是自己就實現了下

結果更蒙了

bubble_sort(L)->
	bubble_sort(L,length(L)).
 
bubble_sort(L,0)->
	L;
bubble_sort(L,N)->
	bubble_sort(do_bubble_sort(L),N-1).
 
do_bubble_sort([A])->
	[A];
do_bubble_sort([A,B|R])->
case A<B of
	true ->
		[A|do_bubble_sort([B|R])];
	false ->
		[B|do_bubble_sort([A|R])]
end.

對比結果如下

6> timer:tc(tt1,bubble_sort,[B]).
{21130,
 [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
  23,24,25,26,27|...]}
7> timer:tc(lists,sort,[B]).     
{162,
 [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
  23,24,25,26,27|...]}
8>

B是一個打亂順序的1到1000的序列，我X，這不是一個數量級的算法啊～～～～，不是說好越簡單的代碼越快麽，三觀被刷新了。

還是老實讀lists的源碼，一共300+行，摘錄於lists.er

-spec sort(List1) -> List2 when
      List1 :: [T],
      List2 :: [T],
      T :: term().

sort([X, Y | L] = L0) when X =< Y ->
    case L of
    [] -> 
        L0;
    [Z] when Y =< Z ->
        L0;
    [Z] when X =< Z ->
        [X, Z, Y];
    [Z] 
 
->
        [Z, X, Y];
    _ when X == Y ->
        sort_1(Y, L, [X]);
    _ ->
        split_1(X, Y, L, [], [])
    end;
sort([X, Y | L]) ->
    case L of
    [] ->
        [Y, X];
    [Z] when X =< Z ->
        [Y, X | L];
    [Z] when Y =< Z ->
        [Y, Z, X];
    [Z] ->
        [Z, Y, X];
    _ ->
        split_2(X, Y, L, [], [])
    end;
sort([_] = L) ->
    L;
sort([] = L) ->
    L.

sort_1(X, [Y | L], R) when X == Y ->
    sort_1(Y, L, [X | R]);
sort_1(X, [Y | L], R) when X < Y ->
    split_1(X, Y, L, R, []);
sort_1(X, [Y | L], R) ->
    split_2(X, Y, L, R, []);
sort_1(X, [], R) ->
    lists:reverse(R, [X]).

%% Ascending.
split_1(X, Y, [Z | L], R, Rs) when Z >= Y ->
%    io:format("here is 131 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p~n",[X, Y, Z, L, R, Rs]),
    split_1(Y, Z, L, [X | R], Rs);
split_1(X, Y, [Z | L], R, Rs) when Z >= X ->
%    io:format("here is 134 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p~n",[X, Y, Z, L, R, Rs]),
    split_1(Z, Y, L, [X | R], Rs);
split_1(X, Y, [Z | L], [], Rs) ->
%    io:format("here is 137  X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p~n",[X, Y, Z, L, [], Rs]),
    split_1(X, Y, L, [Z], Rs);
split_1(X, Y, [Z | L], R, Rs) ->
%    io:format("here is 140 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p~n",[X, Y, Z, L, R, Rs]),
    split_1_1(X, Y, L, R, Rs, Z);
split_1(X, Y, [], R, Rs) ->
%    io:format("here is 143 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p~n",[X, Y, [[Y, X | R] | Rs], [], R, Rs]),
    rmergel([[Y, X | R] | Rs], []).

split_1_1(X, Y, [Z | L], R, Rs, S) when Z >= Y ->
%    io:format("here is 147 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p,S:~p~n",[X, Y, Z, L, R, Rs, S]),
    split_1_1(Y, Z, L, [X | R], Rs, S);
split_1_1(X, Y, [Z | L], R, Rs, S) when Z >= X ->
%    io:format("here is 150 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p,S:~p~n",[X, Y, Z, L, R, Rs, S]),
    split_1_1(Z, Y, L, [X | R], Rs, S);
split_1_1(X, Y, [Z | L], R, Rs, S) when S =< Z ->
%    io:format("here is 153 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p,S:~p~n",[X, Y, Z, L, R, Rs, S]),
    split_1(S, Z, L, [], [[Y, X | R] | Rs]);
split_1_1(X, Y, [Z | L], R, Rs, S) ->
%    io:format("here is 156 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p,S:~p~n",[X, Y, Z, L, R, Rs, S]),
    split_1(Z, S, L, [], [[Y, X | R] | Rs]);
split_1_1(X, Y, [], R, Rs, S) ->    
%    io:format("here is 159 X:~p,Y:~p,Z:~p,L:~p,R:~p,Rs:~p,S:~p~n",[X, Y, [[S], [Y, X | R] | Rs], [], R, Rs, S]),
    rmergel([[S], [Y, X | R] | Rs], []).

%% Descending.
split_2(X, Y, [Z | L], R, Rs) when Z =< Y ->
    split_2(Y, Z, L, [X | R], Rs);
split_2(X, Y, [Z | L], R, Rs) when Z =< X ->
    split_2(Z, Y, L, [X | R], Rs);
split_2(X, Y, [Z | L], [], Rs) ->
    split_2(X, Y, L, [Z], Rs);
split_2(X, Y, [Z | L], R, Rs) ->
    split_2_1(X, Y, L, R, Rs, Z);
split_2(X, Y, [], R, Rs) ->
    mergel([[Y, X | R] | Rs], []).

split_2_1(X, Y, [Z | L], R, Rs, S) when Z =< Y ->
    split_2_1(Y, Z, L, [X | R], Rs, S);
split_2_1(X, Y, [Z | L], R, Rs, S) when Z =< X ->
    split_2_1(Z, Y, L, [X | R], Rs, S);
split_2_1(X, Y, [Z | L], R, Rs, S) when S > Z ->
    split_2(S, Z, L, [], [[Y, X | R] | Rs]);
split_2_1(X, Y, [Z | L], R, Rs, S) ->
    split_2(Z, S, L, [], [[Y, X | R] | Rs]);
split_2_1(X, Y, [], R, Rs, S) ->
    mergel([[S], [Y, X | R] | Rs], []).

%% merge/1

mergel([[] | L], Acc) ->
    mergel(L, Acc);
mergel([T1, [H2 | T2], [H3 | T3] | L], Acc) ->
    mergel(L, [merge3_1(T1, [], H2, T2, H3, T3) | Acc]);
mergel([T1, [H2 | T2]], Acc) ->
    rmergel([merge2_1(T1, H2, T2, []) | Acc], []);
mergel([L], []) ->
    L;
mergel([L], Acc) ->
    rmergel([lists:reverse(L, []) | Acc], []);
mergel([], []) ->
    [];
mergel([], Acc) ->
    rmergel(Acc, []);
mergel([A, [] | L], Acc) ->
    mergel([A | L], Acc);
mergel([A, B, [] | L], Acc) ->
    mergel([A, B | L], Acc).

rmergel([[H3 | T3], [H2 | T2], T1 | L], Acc) ->
    rmergel(L, [rmerge3_1(T1, [], H2, T2, H3, T3) | Acc]);
rmergel([[H2 | T2], T1], Acc) ->
    mergel([rmerge2_1(T1, H2, T2, []) | Acc], []);
rmergel([L], Acc) ->
    mergel([lists:reverse(L, []) | Acc], []);
rmergel([], Acc) ->
    mergel(Acc, []).

%% merge3/3

%% Take L1 apart.
merge3_1([H1 | T1], M, H2, T2, H3, T3) when H1 =< H2 ->
    merge3_12(T1, H1, H2, T2, H3, T3, M);
merge3_1([H1 | T1], M, H2, T2, H3, T3) ->
    merge3_21(T1, H1, H2, T2, H3, T3, M);
merge3_1([], M, H2, T2, H3, T3) when H2 =< H3 ->
    merge2_1(T2, H3, T3, [H2 | M]);
merge3_1([], M, H2, T2, H3, T3) ->
    merge2_2(T2, H3, T3, M, H2).

%% Take L2 apart.
merge3_2(T1, H1, M, [H2 | T2], H3, T3) when H1 =< H2 ->
    merge3_12(T1, H1, H2, T2, H3, T3, M);
merge3_2(T1, H1, M, [H2 | T2], H3, T3) ->
    merge3_21(T1, H1, H2, T2, H3, T3, M);
merge3_2(T1, H1, M, [], H3, T3) when H1 =< H3 ->
    merge2_1(T1, H3, T3, [H1 | M]);
merge3_2(T1, H1, M, [], H3, T3) ->
    merge2_2(T1, H3, T3, M, H1).

% H1 =< H2. Inlined.
merge3_12(T1, H1, H2, T2, H3, T3, M) when H1 =< H3 ->
    merge3_1(T1, [H1 | M], H2, T2, H3, T3);
merge3_12(T1, H1, H2, T2, H3, T3, M) ->
    merge3_12_3(T1, H1, H2, T2, [H3 | M], T3).

% H1 =< H2, take L3 apart.
merge3_12_3(T1, H1, H2, T2, M, [H3 | T3]) when H1 =< H3 ->
    merge3_1(T1, [H1 | M], H2, T2, H3, T3);
merge3_12_3(T1, H1, H2, T2, M, [H3 | T3]) ->
    merge3_12_3(T1, H1, H2, T2, [H3 | M], T3);
merge3_12_3(T1, H1, H2, T2, M, []) ->
    merge2_1(T1, H2, T2, [H1 | M]).

% H1 > H2. Inlined.
merge3_21(T1, H1, H2, T2, H3, T3, M) when H2 =< H3 ->
    merge3_2(T1, H1, [H2 | M], T2, H3, T3);
merge3_21(T1, H1, H2, T2, H3, T3, M) ->
    merge3_21_3(T1, H1, H2, T2, [H3 | M], T3).

% H1 > H2, take L3 apart.
merge3_21_3(T1, H1, H2, T2, M, [H3 | T3]) when H2 =< H3 ->
    merge3_2(T1, H1, [H2 | M], T2, H3, T3);
merge3_21_3(T1, H1, H2, T2, M, [H3 | T3]) ->
    merge3_21_3(T1, H1, H2, T2, [H3 | M], T3);
merge3_21_3(T1, H1, H2, T2, M, []) ->
    merge2_2(T1, H2, T2, M, H1).

%% rmerge/3

%% Take L1 apart.
rmerge3_1([H1 | T1], M, H2, T2, H3, T3) when H1 =< H2 ->
    rmerge3_12(T1, H1, H2, T2, H3, T3, M);
rmerge3_1([H1 | T1], M, H2, T2, H3, T3) ->
    rmerge3_21(T1, H1, H2, T2, H3, T3, M);
rmerge3_1([], M, H2, T2, H3, T3) when H2 =< H3 ->
    rmerge2_2(T2, H3, T3, M, H2);
rmerge3_1([], M, H2, T2, H3, T3) ->
    rmerge2_1(T2, H3, T3, [H2 | M]).

%% Take L2 apart.
rmerge3_2(T1, H1, M, [H2 | T2], H3, T3) when H1 =< H2 ->
    rmerge3_12(T1, H1, H2, T2, H3, T3, M);
rmerge3_2(T1, H1, M, [H2 | T2], H3, T3) ->
    rmerge3_21(T1, H1, H2, T2, H3, T3, M);
rmerge3_2(T1, H1, M, [], H3, T3) when H1 =< H3 ->
    rmerge2_2(T1, H3, T3, M, H1);
rmerge3_2(T1, H1, M, [], H3, T3) ->
    rmerge2_1(T1, H3, T3, [H1 | M]).

% H1 =< H2. Inlined.
rmerge3_12(T1, H1, H2, T2, H3, T3, M) when H2 =< H3 ->
    rmerge3_12_3(T1, H1, H2, T2, [H3 | M], T3);
rmerge3_12(T1, H1, H2, T2, H3, T3, M) ->
    rmerge3_2(T1, H1, [H2 | M], T2, H3, T3).

% H1 =< H2, take L3 apart.
rmerge3_12_3(T1, H1, H2, T2, M, [H3 | T3]) when H2 =< H3 ->
    rmerge3_12_3(T1, H1, H2, T2, [H3 | M], T3);
rmerge3_12_3(T1, H1, H2, T2, M, [H3 | T3]) ->
    rmerge3_2(T1, H1, [H2 | M], T2, H3, T3);
rmerge3_12_3(T1, H1, H2, T2, M, []) ->
    rmerge2_2(T1, H2, T2, M, H1).

% H1 > H2. Inlined.
rmerge3_21(T1, H1, H2, T2, H3, T3, M) when H1 =< H3 ->
    rmerge3_21_3(T1, H1, H2, T2, [H3 | M], T3);
rmerge3_21(T1, H1, H2, T2, H3, T3, M) ->
    rmerge3_1(T1, [H1 | M], H2, T2, H3, T3).

% H1 > H2, take L3 apart.
rmerge3_21_3(T1, H1, H2, T2, M, [H3 | T3]) when H1 =< H3 ->
    rmerge3_21_3(T1, H1, H2, T2, [H3 | M], T3);
rmerge3_21_3(T1, H1, H2, T2, M, [H3 | T3]) ->
    rmerge3_1(T1, [H1 | M], H2, T2, H3, T3);
rmerge3_21_3(T1, H1, H2, T2, M, []) ->
    rmerge2_1(T1, H2, T2, [H1 | M]).

%% merge/2

merge2_1([H1 | T1], H2, T2, M) when H1 =< H2 ->
    merge2_1(T1, H2, T2, [H1 | M]);
merge2_1([H1 | T1], H2, T2, M) ->
    merge2_2(T1, H2, T2, M, H1);
merge2_1([], H2, T2, M) ->
    lists:reverse(T2, [H2 | M]).

merge2_2(T1, HdM, [H2 | T2], M, H1) when H1 =< H2 ->
    merge2_1(T1, H2, T2, [H1, HdM | M]);
merge2_2(T1, HdM, [H2 | T2], M, H1) ->
    merge2_2(T1, H2, T2, [HdM | M], H1);
merge2_2(T1, HdM, [], M, H1) ->
    lists:reverse(T1, [H1, HdM | M]).

%% rmerge/2

rmerge2_1([H1 | T1], H2, T2, M) when H1 =< H2 ->
    rmerge2_2(T1, H2, T2, M, H1);
rmerge2_1([H1 | T1], H2, T2, M) ->
    rmerge2_1(T1, H2, T2, [H1 | M]);
rmerge2_1([], H2, T2, M) ->
    lists:reverse(T2, [H2 | M]).

rmerge2_2(T1, HdM, [H2 | T2], M, H1) when H1 =< H2 ->
    rmerge2_2(T1, H2, T2, [HdM | M], H1);
rmerge2_2(T1, HdM, [H2 | T2], M, H1) ->
    rmerge2_1(T1, H2, T2, [H1, HdM | M]);
rmerge2_2(T1, HdM, [], M, H1) ->
    lists:reverse(T1, [H1, HdM | M]).

好，這是我見過最復雜的排序算法了。

這個算法和歸並排序有點像，可是由於erlang的特性，變量不能變，使得和大部分的排序方法有很大的區別，這個算法的復雜度應該是0(2n)

這個算法可以份3大塊，第一塊是sort_*函數，第二塊是split_*,第3塊是rmergel和mergel

首先

sort([X, Y | L] = L0) when X =< Y ->　　%當list是3個對比會返回，當list超過3個進入sort_1或者splite_*函數
..........
sort([X, Y | L]) ->　　　　　　　　　　　　%分了2種情況，第一個元素大於第二個 或者 第一個元素小於等於第二個
.......
sort([_] = L) ->　　　　　　　　　%list只有1個也直接返回　　　
    L;
sort([] = L) ->　　　　　　　　　　%list為空直接返回
    L.

sort_1(X, [Y | L], R) when X == Y ->
    sort_1(Y, L, [X | R]);
sort_1(X, [Y | L], R) when X < Y ->
    split_1(X, Y, L, R, []);
sort_1(X, [Y | L], R) ->
    split_2(X, Y, L, R, []);
sort_1(X, [], R) ->
    lists:reverse(R, [X]).

當這段代碼還是比較清晰的，就說把超過3個元素的list傳入split_*

下面看split_1系列

%% Ascending.

split_1(X, Y, [Z | L], R, Rs) when Z >= Y ->　　%這裏的時候是X<Y，也就是Z>=Y就是說這時X<Y<=Z，我們把最小X的放到R裏面，而且Y,Z替換X,Y

　　split_1(Y, Z, L, [X | R], Rs);

split_1(X, Y, [Z | L], R, Rs) when Z >= X ->　　%這裏的時候Z>=X，也就是X<=Z<Y，我們把最小的X放到R裏面，而且Z替代X成了Z,Y

　　split_1(Z, Y, L, [X | R], Rs);

split_1(X, Y, [Z | L], [], Rs) ->　　　　　　　　%這裏的時候Z<X，也就是Z<X<Y，我們把最小的Z放到R裏面(R目前為空)

　　split_1(X, Y, L, [Z], Rs);

split_1(X, Y, [Z | L], R, Rs) ->　　　　　　　　　%這裏的時候Z<X，也就是Z<X<Y，我們把最小的Z放到最後的參數（R不為空的時候），調用split_1_1，為什麽？？？

　　split_1_1(X, Y, L, R, Rs, Z);

split_1(X, Y, [], R, Rs) ->　　　　　　　　　　　　%當列表完成後調用下個函數rmerge1，這個後面再講

　　rmergel([[Y, X | R] | Rs], []).

WTF，這些到底在幹什麽，erlang又沒有調試跟蹤，又沒說明，完全就蒙了，仔細研究下終於明白了這2個函數的意義，不得說寫源碼的真是大神啊～～～

通過上面的分析，我們知道了一個規律，每次都會比較3個數的大小，而且還會處理其中最小的數

X:下樁 Y：上樁， Z：目前list的第一個元素 R:經過排序了的list，Rs和S是split_1_1使用的變量

split_1這個函數的左右是把X,Y,Z中最小的放到R中，同時要保證這個數比R中現有的元素都大，

這個怎麽保證呢，當Z>X（包括Z>X和Z>Y兩種情況）的時候把直接X放進去R，

原因就是X一直小於Y，而且R裏面的元素都比X小才放進去的，而且整個過程X和Y的值都是增加的，所以X肯定大於R中的任何一個

開始是R代表R中任何一個)，假設Z0>Y0

  1. R0<X0<Y0<Z0 開始R0為空，比較成立
  2. R1<X1<Y1<Z1 這時R1=[X0|R0],X1=Y0,Y1=Z0，當Z1>Y1，比較還是成立
  3. R2<X2<Y2<Z2 這時R2=[X1|R1],X2=Y1,Y2=Z1，當Z2>Y2，比較還是成立
  4. 。。。。。。。

當Z>X的時候也一樣，於是當Z>X或者Z>Y的時候，只要把X的值放到R中就行，R裏面的元素越來越大，是排好序的（從大到小），於是上面綠色的註釋的代碼就能理解了

藍色的註釋代碼當R為空， Z<X<Y，當然R<Z<X<Y，於是也能理解了

主要是褐色的代碼模塊當R不為空，我們知道R<X<Y,而且Z<X<Y,可是R裏面的元素和Z不能確定，

於是我們知道了當前最小的是Z，可是Z不一定大於R的所有元素，上面的split_1函數的邏輯就不通了，然後把Z存入到最後一個參數進入split_1_1

我們來查看split_1_1

split_1_1(X, Y, [Z | L], R, Rs, S) when Z >= Y ->　　　　%這時候X<Y<=Z，R<X, S<X我們這裏不管S於是R<X<Y<=Z,按照上面邏輯，X存入R，Y,Z替換X，Y
    split_1_1(Y, Z, L, [X | R], Rs, S);
split_1_1(X, Y, [Z | L], R, Rs, S) when Z >= X ->　　　　%這時候X<=Z<Y，R<X, S<X我們這裏不管S於是R<X<=Z<Y,按照上面邏輯，X存入R，Z替換X
    split_1_1(Z, Y, L, [X | R], Rs, S);
split_1_1(X, Y, [Z | L], R, Rs, S) when S =< Z -> 　　　 %這時候S<=Z<X<Y，R<X,在這裏我們知道Y>X>R,這裏S,Z設置為X,Y，因為X,Y被重新設置，所以後面沒有比較性
    split_1(S, Z, L, [], [[Y, X | R] | Rs]);　　　　　　　%於是我們把Y,X存入R（R裏面的還是有序的），然後把R存入RS，清空R，返回到開始split_1的函數
split_1_1(X, Y, [Z | L], R, Rs, S) ->　　　　　　　　　　　%當S>Z一樣
    split_1(Z, S, L, [], [[Y, X | R] | Rs]);
split_1_1(X, Y, [], R, Rs, S) ->    
    rmergel([[S], [Y, X | R] | Rs], []).

我們可以看到，紫色註釋的代碼，當S<=Z<X<Y，R<X我們知道最小的數是S,然後是Z，可是我們不能比較R裏面的元素與這2個數的大小，

如果按照上面函數的邏輯，可以在弄個函數split_1_1_1，可這樣函數不是閉環的，於是大神直接把肯定比R大的2個元素存入R（保證了R的有序），再回到split_1，這裏真是太厲害了

 1 X:12,Y:13,Z:54,L:[32,1,4521,32,214,541,1,12,3],R:[],Rs:[]
 2 X:13,Y:54,Z:32,L:[1,4521,32,214,541,1,12,3],R:"\f",Rs:[]
 3 X:32,Y:54,Z:1,L:[4521,32,214,541,1,12,3],R:"\r\f",Rs:[]
 4 X:32,Y:54,Z:4521,L:[32,214,541,1,12,3],R:"\r\f",Rs:[],S:1
 5 X:54,Y:4521,Z:32,L:[214,541,1,12,3],R:" \r\f",Rs:[],S:1
 6 X:1,Y:32,Z:214,L:[541,1,12,3],R:[],Rs:[[4521,54,32,13,12]]
 7 X:32,Y:214,Z:541,L:[1,12,3],R:[1],Rs:[[4521,54,32,13,12]]
 8 X:214,Y:541,Z:1,L:[12,3],R:[32,1],Rs:[[4521,54,32,13,12]]
 9 X:214,Y:541,Z:12,L:[3],R:[32,1],Rs:[[4521,54,32,13,12]],S:1
10 X:1,Y:12,Z:3,L:[],R:[],Rs:[[541,214,32,1],[4521,54,32,13,12]]
11 Rs:[[12,3,1],[541,214,32,1],[4521,54,32,13,12]]
我們看個簡單的例子執行過程，大概就能明白這個邏輯了。
這裏的List = [12,13,54,32,1,4521,32,214,541,1,12,3]，這2個函數執行完成後的結果是[[12,3,1],[541,214,32,1],[4521,54,32,13,12]]
可以看到這裏經過了N次循環（N是List長度），生成了幾個子list，每個子list都是有序的，這樣肯定沒有完成，剩下的就是mergel和rmergel函數的作用了

篇幅太長，不好排版，下面的函數分析放

erlang下lists模塊sort（排序）方法源碼解析(二)

未完待續。。。

erlang下lists模塊sort（排序）方法源碼解析

相關推薦

erlang下lists模塊sort（排序）方法源碼解析

簡單的 我們 asc HR 最簡 lse color ble 最小 排序算法一直是各種語言最簡單也是最復雜的算法，例如十大經典排序算法（動圖演示）裏面講的那樣 第一次看lists的sort方法的時候，蒙了，幾百行的代碼，我心想要這麽復雜麽（因為C語言的冒泡排序我記得不超過3

erlang下lists模塊sort（排序）方法源碼解析(二)

比較 應該 源碼解析 tudou 解析 [] sort bsp 時間差 上接erlang下lists模塊sort（排序）方法源碼解析(一)，到目前為止，list列表已經被分割成N個列表，而且每個列表的元素是有序的（從大到小） 下面我們重點來看看mergel和rmergel模

Java集合幹貨系列-（一）ArrayList源碼解析

div imp ins bject 增加 toa tof capacity == 前言 今天來介紹下ArrayList，在集合框架整體框架一章中，我們介紹了List接口，ArrayList繼承了AbstractList，實現了List。ArrayList在工作中經常用到，所

（轉）spring源碼解析，深入了解spring

運動 重要 art point ioe 魔方 父類 prototype processor 轉自：https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/ Spring 的骨骼架構 Spring 總共

模塊分析（三）

1.7 space 後置 狀態 你在 處理 節點 要點 不同 做設計很重要一點就是要考慮匹配設計，就是你的設計一定要有一個意識，就是要回歸原始狀態；也可以稱之為閉環誰急，而且是小地方的閉環，以及異常情況的閉環；比如傳輸你在一個地方加密，解密一般都會考慮到；但是如果是壓縮，邏

Java知識點模塊化（1）—— 面向對象

只需要 知識 pad 產生 自動裝箱 pri 生存 new 使用 前言 　　這是我整理的Java筆記，分模塊會陸續上齊，具體鏈接如下： 　　1.面向對象：http://www.cnblogs.com/Gabby/p/6857406.html 　　2.集合： 　　3.IO：

模塊使用（一）

語句 自己 所有 一個 組織 另一個 腳本文件 路徑 需要 一、模塊簡介 (1) 一個模塊就相當於一個小功能，一個 python 腳本可以單獨運行，也可以導入到另一個腳本中運行(2) 當腳本被導入運行時，我們將其稱為模塊，所有的 .py 文件都可以作為一個模塊導入(3)

OSGi是什麽：Java語言的動態模塊系統（一）

平臺 使用 數據 osgi servle http cto 優點 重啟 OSGi是什麽 OSGi亦稱做Java語言的動態模塊系統，它為模塊化應用的開發定義了一個基礎架構。OSGi容器已有多家開源實現，比如Knoflerfish、Equinox和Apache的Felix。您可

cocos2d-js動作模塊使用（自用，只有代碼）

his ews btn enc 自用 ota req visible svi // var UIBase = require("src/views/ui/UIBase.js")// cc.loader.loadJs("src/views/ui/UIBase.js")var

HTTP模塊理解（二）

在服務器 服務 客戶端 問題 抽象 mar 應用 pre node.js 這是我在寫，用express+ajax+swig來做一個簡單的應用的時候，遇到的問題。還是不太理解http模塊。 後來在網上看到雲棲社區的一篇《Node.js之HTTP請求與響應》，這裏做簡單的總結。

前端模塊化（六）：CMD規範

cati end dos 屬性 resolv 代碼 滿足 urn target 1 概述 CMD（Common Module Definition）是國內大牛玉伯在開發SeaJS的時候提出來的，屬於CommonJS的一種規範，根據瀏覽器的異步環境做了自己的實現。它和 A

前端模塊化（五）：RequireJs

ons title 對象 ges 開發 fun 異步 efi core模塊 1 概述 RequireJS是一個JS模塊加載器，遵循AMD規範。它主要是為了實現JS文件的異步加載以及管理模塊之間的依賴性。下面，我們通過一下例子來了解requirejs的使用。 2 Requir

硬件系列之超聲波模塊介紹（一）

返回 精度 就是 包括 發送 平時 自動 距離 c-s HC-SR04模塊可提供2cm-40cm的非接觸式距離感測功能，測距精度可達3mm： 模塊包括超聲波發生器，接收器與控制器，檢測角度30度。 控制方式： 采用IO口TRIG觸發測距，給最少10us的高電平信號 模塊自動

pyhon Tkinter模塊學習（二）

#### sina lec com 插入 style res 相關 效果 pyhon之Tkinter實例化學習 1. 產品介紹 界面 　　 功能 通過輸入字符或數字查詢對應的信息 通過選擇列表中的信息查詢對應的信息 回到頂部 2. 設計規劃 規劃

python mock模塊使用（一）

logs reason pos 境界 mark -m 試用 print 測試用例設計 什麽是mock unittest.mock是一個用於在Python中進行單元測試的庫，Mock翻譯過來就是模擬的意思，顧名思義這個庫的主要功能是模擬一些東西。 它的主要功能是使用moc

python collections模塊 計數器（counter）

寫入 print int com size 自己的 for 一個 ont 一、計數器（counter） Counter是對字典類型的補充，用於追蹤值的出現次數。 ps：具備字典的所有功能 + 自己的功能 把我寫入的元素出現的多少次都計算出來 import co

Solr查詢引數sort（排序）

摘要： Solr查詢每一次返回的資料都有一定的順序，特定順序的結果對於業務來說可能非常重要。 不指定排序 一般我們不指定排序規則，這樣的結果能滿足大部分需求，預設是用文件的得分作為排序標準。相當於加上了引數sort=score desc，這裡的score

python之讀取配置文件模塊configparser（二）參數詳解

string cts open mod fix error: 註釋 大於 default configparser.ConfigParser參數詳解 從configparser的__ini__中可以看到有如下參數： def __init__(self, defaul

工具模塊封裝（三）

接口模擬 組件 local 通過 __proto__ 中控 準備 image 比較 封裝 axios 模塊 封裝背景 使用axios發起一個請求是比較簡單的事情，但是axios沒有進行封裝復用，項目越來越大，會引起越來越多的代碼冗余，讓代碼變得越來越難維護。所以我們在這

j2ee（9） HashMap源碼

|| 為什麽 引用 1.7 lin length 機會 lar number 系統環境： JDK1.7 HashMap的基本結構：數組 + 鏈表。主數組不存儲實際的數據，存儲的是鏈表首地址。 成員變量 //默認數組的初始化大小為16 static final i