十大經典排序演算法

部分內容引用自：https://www.cnblogs.com/onepixel/articles/7674659.html

感謝作者貢獻，如需刪除請聯絡本人！

0、排序演算法說明

0.1 排序分類

 

非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O(nlogn)，因此稱為非線性時間比較類排序。

線性時間非比較類排序：不通過比較來決定元素間的相對次序，它可以突破基於比較排序的時間下界，以線性時間執行，因此稱為線性時間非比較類排序。

 

0.2 術語說明

• 穩定：如果a原本在b前面，而a=b，排序之後a仍然在b的前面；
• 不穩定：如果a原本在b的前面，而a=b，排序之後a可能會出現在b的後面；
• 內排序：所有排序操作都在記憶體中完成；
• 外排序：由於資料太大，因此把資料放在磁碟中，而排序通過磁碟和記憶體的資料傳輸才能進行；
• 時間複雜度： 一個演算法執行所耗費的時間。
• 空間複雜度：執行完一個程式所需記憶體的大小。

0.3 演算法總結

圖片名詞解釋：

• n: 資料規模
• k: “桶”的個數
• In-place: 佔用常數記憶體，不佔用額外記憶體
• Out-place: 佔用額外記憶體

 

1、氣泡排序（Bubble Sort）

氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。 

1.1 演算法描述

• 比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
• 針對所有的元素重複以上的步驟，除了最後一個；
• 重複步驟1~3，直到排序完成。

1.2 動圖演示

1.3 程式碼實現

1. package cn.fuqiang.arithmetic;

2.  

3. import java.util.Comparator;

4. /**

5. * 氣泡排序

6. * @author 王福強

7. * @Title: BubbleSort.java

8. * @Package cn.fuqiang.arithmetic

9. * @Description 氣泡排序 實現

10. * @date 2018年6月8日 下午4:18:37

11. */

12. public class BubbleSort<T> {

13. public static void main(String[] args) {

14. int[] arr = {4,1,5,3,8,10,28,2};

15. sort(arr);

16. so(arr);

17.  
18.  

19. Integer[] arr2 = {4,1,5,3,8,10,28,2};

20. sort(arr2,(a,b)-> b.compareTo(a));

21. so(arr2);

22. }

23. /**

24. * 氣泡排序 (特點：從後往前)

25. * 原理：前後元素兩兩之間進行比較 把大的往後扔

26. * 升序 (從後往前，從大到小)

27. * 外層迴圈是控制內層迴圈的次數，也就是說外層迴圈每迴圈一遍，讓內層迴圈每次迴圈的次數減一次

28. * 這樣就保證內層迴圈每次迴圈結束後最後面一個都是最大

29. * 例如 ： 3 6 4 1

30. * 外迴圈第一次 結束後，內迴圈 會把6放到最後面 3 4 1 6

31. * 外迴圈第二次開始時，內迴圈的迴圈次數會減一 也就是說 6 不會在參與比較

32. * 外迴圈第二次結束時， 內迴圈 會把4放到最後面 3 1 4

33. * 以此類推。。。。

34. * 外迴圈第三次結束時 內迴圈 1 3 4

35. * .。。。。 1 3

36. * .。。。。 1

37. * 最終結果 1 3 4 6

38. * @param t

39. */

40. public static void sort(int[] t) {

41. for(int i=0;i<t.length;i++) {

42. int temp;

43. for(int j = 0;j<t.length-1-i;j++) {

44. if(t[j]>t[j+1]) {

45. temp = t[j];

46. t[j]=t[j+1];

47. t[j+1]=temp;

48. }

49. }

50. }

51.  

52. }

53.  

54. /**

55. * 氣泡排序 物件型別排序

56. * 物件必須實現Comparator介面

57. * @param t 要遍歷的陣列

58. * @param comparator 定製的遍歷規則

59. */

60. public static <T>void sort(T[] t,Comparator<? super T> comparator) {

61. for(int i = 0;i<t.length-1;i++) {

62. T temp;

63. for(int j = 1;j<t.length-i;j++) {

64. if(comparator.compare(t[j-1], t[j])<0) {

65. temp = t[j-1];

66. t[j-1]=t[j];

67. t[j]=temp;

68. }

69. }

70. }

71. }

72.  

73. /**

74. * 傳入任意陣列或物件 輸出到控制檯

75. * @author 王福強

76. * @Description 前提是傳入的物件必須重寫 toString()方法

77. * @date 2018年6月8日 下午4:26:06

78. * @param obj

79. */

80. public static void so(Object obj) {

81. String str = "";

82. if(obj instanceof int[]) {

83. int[] arr = (int[])obj;

84. StringBuilder sb = new StringBuilder();

85. sb.append("[");

86. for (int i : arr) {

87. sb.append(i+",");

88. }

89. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

90.  

91. }else if(obj instanceof long[]) {

92. long[] arr = (long[])obj;

93. StringBuilder sb = new StringBuilder();

94. sb.append("[");

95. for (long i : arr) {

96. sb.append(i+",");

97. }

98. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

99. }else if(obj instanceof char[]) {

100. char[] arr = (char[])obj;

101. StringBuilder sb = new StringBuilder();

102. sb.append("[");

103. for (char i : arr) {

104. sb.append(i+",");

105. }

106. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

107. }else if(obj instanceof short[]) {

108. short[] arr = (short[])obj;

109. StringBuilder sb = new StringBuilder();

110. sb.append("[");

111. for (short i : arr) {

112. sb.append(i+",");

113. }

114. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

115. }else if(obj instanceof double[]) {

116. double[] arr = (double[])obj;

117. StringBuilder sb = new StringBuilder();

118. sb.append("[");

119. for (double i : arr) {

120. sb.append(i+",");

121. }

122. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

123. }else if(obj instanceof float[]) {

124. float[] arr = (float[])obj;

125. StringBuilder sb = new StringBuilder();

126. sb.append("[");

127. for (float i : arr) {

128. sb.append(i+",");

129. }

130. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

131. }else if(obj instanceof Object[]) {

132. Object[] arr = (Object[])obj;

133. StringBuilder sb = new StringBuilder();

134. sb.append("[");

135. for (Object i : arr) {

136. sb.append(i.toString()+",");

137. }

138. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

139. }else {

140. str=obj.toString();

141. }

142. System.out.println(str);;

143. }

144.  

145. }

 

最佳情況：T(n) = O(n)   最差情況：T(n) = O(n2)   平均情況：T(n) = O(n2)

2、選擇排序（Selection Sort）

表現最穩定的排序演算法之一，因為無論什麼資料進去都是O(n2)的時間複雜度，所以用到它的時候，資料規模越小越好。唯一的好處可能就是不佔用額外的記憶體空間了吧。理論上講，選擇排序可能也是平時排序一般人想到的最多的排序方法了吧。

選擇排序(Selection-sort)是一種簡單直觀的排序演算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。 

2.1 演算法描述

n個記錄的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。具體演算法描述如下：

• 初始狀態：無序區為R[1..n]，有序區為空；
• 第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別為R[1..i-1]和R(i..n）。該趟排序從當前無序區中-選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R[i+1..n)分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區；
• n-1趟結束，陣列有序化了。

2.2 動圖演示

　　

2.3 程式碼實現

1. package cn.fuqiang.arithmetic;

2.  

3. import java.util.Comparator;

4.  

5. /**

6. * 選擇排序 的兩種實現方式

7. * (在這裡要注意，因為最後一個位置的數絕對是最後迴圈後最大的值，

8. * 所以外層迴圈的迴圈次數 最好是arr.length-1).

9. * @author 王福強

10. * @Title: SelectionSort.java

11. * @Package cn.fuqiang.arithmetic

12. * @Description

13. * @date 2018年6月8日 下午5:30:59

14. */

15. public class SelectionSort {

16. public static void main(String[] args) {

17. int[] arr = {4,1,5,3,8,10,28,2};

18. sort(arr);

19. so(arr);

20.  
21.  

22. Integer[] arr2 = {4,1,5,3,8,10,28,2};

23. sort(arr2,(a,b)-> b.compareTo(a));

24. so(arr2);

25. }

26.  
27.  

28. /**

29. * 選擇排序 第一種實現方式 (賦值) 升序 （特點 ：從小到大）

30. * 原理: 每次把最小的都放在前面，

31. * 外層迴圈控制每次遍歷的次數，內層迴圈替換每次找出來的最小值，放在 arr[i]的位置

32. * 這樣當內層比較和替換的時候，就保證每次最小的都在最前面

33. * 例如：3 2 6 1

34. * 第一次外層迴圈為 i 為 0 第一個就是最小的值放最小的值

35. * 內層循換會把每次找出的最小值放在arr[0] 的位置

36. * 第二次外層迴圈為 i 為 1

37. * 內層迴圈會把每次找出最小的值放在 arr[1] 的位置

38. *

39. * 外迴圈 第一次 i=0

40. * 內部迴圈

41. * 第一次 2 3 6 1

42. * 第二次 2 3 6 1

43. * 第三次 1 3 6 2

44. *

45. * 外迴圈 第二次 i=1

46. * 內部迴圈

47. * 第一次 3 6 1

48. * 第二次 1 6 3

49. *

50. * 外迴圈 第三次 i=2

51. * 內部迴圈

52. * 第一次 3 6

53. *

54. *

55. * @author 王福強

56. * @Description

57. * @date 2018年6月8日 下午6:36:42

58. * @param arr int型別陣列

59. */

60. public static void sort(int[] arr) {

61. for(int i = 0;i<arr.length-1;i++) {

62. int temp;

63. for(int j = i+1 ; j <arr.length ; j++) {

64. if(arr[i]>arr[j]) {

65. temp = arr[i];

66. arr[i] = arr[j];

67. arr[j] = temp;

68. }

69. }

70. }

71. }

72.  
73.  
74.  

75. /**

76. * 選擇排序 第二種實現(記錄下標) 升序 （特點 ：從小到大）

77. * 每次迴圈記錄最小的下標 min 最後跟 arr[i] 位置的下標交換位置

78. * 這樣當外層迴圈每次迴圈一次 會先記下 arr[i] 的下標，

79. * 然後讓內層迴圈從 i+1 開始比較去比較 arr[min] 與 arr[j]

80. * 如果 min下表對應的值 比 j下標對應的值大， 則記錄 j的下標 min = j

81. * 然後拿新的 min下標去跟後面比較，依此類推。

82. * 當內層迴圈迴圈結束後記錄的下標是剩餘數中最小的呢個值的下標

83. * 然後用一個零時變數將他們的值交換過來，就算本身是最小的，也是替換自己

84. * 例如 1 3 6 2

85. *

86. * 第一次外層迴圈結束後

87. * 1 3 6 2

88. * 第二次外循開始時，會記錄i的下標

89. * 然後開始內層迴圈，會記錄2的下標

90. * 內層迴圈結束後，會把 3 與 2的位置調換

91. * 2 6 3

92. * 。。。。。

93. * 。。。。

94. * 3 6

95. *

96. * @author 王福強

97. * @Description

98. * @date 2018年6月9日 下午2:13:42

99. * @param arr

100. * @param comparator

101. */

102. public static <T>void sort(T[] arr,Comparator<T> comparator) {

103. for(int i = 0;i<arr.length-1;i++) {

104. int min=i;

105. T temp=null;

106. for(int j = i+1 ; j <arr.length ; j++) {

107. if(comparator.compare(arr[min], arr[j])<0) {

108. min = j;

109. }

110. }

111. temp = arr[i];

112. arr[i] = arr[min];

113. arr[min] = temp;

114. }

115. }

116.  

117. /**

118. * 傳入任意陣列或物件 輸出到控制檯

119. * @author 王福強

120. * @Description 前提是傳入的物件必須重寫 toString()方法

121. * @date 2018年6月8日 下午4:26:06

122. * @param obj

123. */

124. public static void so(Object obj) {

125. String str = "";

126. if(obj instanceof int[]) {

127. int[] arr = (int[])obj;

128. StringBuilder sb = new StringBuilder();

129. sb.append("[");

130. for (int i : arr) {

131. sb.append(i+",");

132. }

133. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

134.  

135. }else if(obj instanceof long[]) {

136. long[] arr = (long[])obj;

137. StringBuilder sb = new StringBuilder();

138. sb.append("[");

139. for (long i : arr) {

140. sb.append(i+",");

141. }

142. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

143. }else if(obj instanceof char[]) {

144. char[] arr = (char[])obj;

145. StringBuilder sb = new StringBuilder();

146. sb.append("[");

147. for (char i : arr) {

148. sb.append(i+",");

149. }

150. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

151. }else if(obj instanceof short[]) {

152. short[] arr = (short[])obj;

153. StringBuilder sb = new StringBuilder();

154. sb.append("[");

155. for (short i : arr) {

156. sb.append(i+",");

157. }

158. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

159. }else if(obj instanceof double[]) {

160. double[] arr = (double[])obj;

161. StringBuilder sb = new StringBuilder();

162. sb.append("[");

163. for (double i : arr) {

164. sb.append(i+",");

165. }

166. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

167. }else if(obj instanceof float[]) {

168. float[] arr = (float[])obj;

169. StringBuilder sb = new StringBuilder();

170. sb.append("[");

171. for (float i : arr) {

172. sb.append(i+",");

173. }

174. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

175. }else if(obj instanceof Object[]) {

176. Object[] arr = (Object[])obj;

177. StringBuilder sb = new StringBuilder();

178. sb.append("[");

179. for (Object i : arr) {

180. sb.append(i.toString()+",");

181. }

182. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

183. }else {

184. str=obj.toString();

185. }

186. System.out.println(str);;

187. }

188.  

189. }

 

2.4 演算法分析

最佳情況：T(n) = O(n2)  最差情況：T(n) = O(n2)  平均情況：T(n) = O(n2)

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的演算法描述是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。

3.1 演算法描述

一般來說，插入排序都採用in-place在陣列上實現。具體演算法描述如下：

• 從第一個元素開始，該元素可以認為已經被排序；
• 取出下一個元素，在已經排序的元素序列中從後向前掃描；
• 如果該元素（已排序）大於新元素，將該元素移到下一位置；
• 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
• 將新元素插入到該位置後；
• 重複步驟2~5。

3.2 動圖演示

3.2 程式碼實現

1. package cn.fuqiang.arithmetic;

2.  

3. import java.util.Comparator;

4.  

5. /**

6. * 插入排序

7. * @author 王福強

8. * @Title: InsertionSort.java

9. * @Package cn.fuqiang.arithmetic

10. * @Description

11. * @date 2018年6月11日 下午2:19:55

12. */

13. public class InsertionSort {

14. public static void main(String[] args) {

15. int[] arr = {4,1,5,3,8,10,28,2};

16. sort(arr);

17. so(arr);

18.  
19.  

20. Integer[] arr2 = {4,1,5,3,8,10,28,2};

21. sort(arr2,(a,b)-> b.compareTo(a));

22. so(arr2);

23. }

24. /**

25. * 插入排序 升序(特點:拿當前下標值與前面的值比較，將小的值排在對應的位置，把大的往後移)

26. * 迴圈從 i=1 開始 用temp記錄當前位置的值arr[i]，

27. * 然後設定內部迴圈控制下標，通過迴圈將下標每次減一。

28. * 然後判斷temp與arr[index]的大小， 如果temp小於arr[index]則將arr[index-1]值移動到下一個位置，

29. * 然後將下標往前挪一位 也就是 index-1 (因為第一次比較時記錄了 temp = arr[i] 所以不用擔心會將值覆蓋)

30. * 如果不進入內迴圈則說明，下標已經移動到最前面了沒有比該值更小的了，

31. * 這時候就把記錄的 temp 賦值給 index+1 的位置上(因為index已經減到前一個了)

32. * 比較第一個位置 和第二個位置的

33. * 例如 3 1 6 2

34. * 外迴圈第一次 i=1

35. * 外層迴圈直接從 下標為一的開始

36. * 比較1 與3的大小，然後把3的位置移動到後面一位，

37. * 應為內層迴圈index--後小於0了，所以不在迴圈，

38. * 然後因為把3移動到後面一位的時候前面空了一個位置，所以就把1插入

39. * 1 3 6 2

40. * 。。。。

41. * 外迴圈第三次 i=3

42. * 比較 2 與 6 然後把6往後移

43. * 比較 2與3把三往後移

44. * 然後比較2與1 把 2 插入到空缺位置

45. *

46. * @author 王福強

47. * @Description

48. * @date 2018年6月11日 下午4:22:41

49. * @param arr

50. */

51. public static void sort(int[] arr) {

52. for(int i = 1 ; i < arr.length ; i ++) {

53. int index = i-1;

54. int temp = arr[i];

55. while(index>=0 && arr[index]>temp) {

56. arr[index+1] = arr[index--];

57. }

58. arr[index+1] = temp;

59. }

60. }

61.  

62. /**

63. * 對任意物件排序

64. * @author 王福強

65. * @Description

66. * @date 2018年6月13日 上午10:52:31

67. * @param arr

68. * @param comparator

69. */

70. public static <T>void sort(T[] arr,Comparator<T> comparator) {

71. for(int i = 1;i<arr.length;i++) {

72. T temp=arr[i];

73. int index;

74. for(index = i-1;index>=0 && comparator.compare(arr[index], temp)<0;index--) {

75. arr[index+1]=arr[index];

76. }

77. arr[index+1] =temp;

78. }

79. }

80.  
81.  

82. /**

83. * 傳入任意陣列或物件 輸出到控制檯

84. * @author 王福強

85. * @Description 前提是傳入的物件必須重寫 toString()方法

86. * @date 2018年6月8日 下午4:26:06

87. * @param obj

88. */

89. public static void so(Object obj) {

90. String str = obj.toString();

91. if(obj instanceof int[]) {

92. int[] arr = (int[])obj;

93. StringBuilder sb = new StringBuilder();

94. sb.append("[");

95. for (int i : arr) {

96. sb.append(i+",");

97. }

98. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

99.  

100. }else if(obj instanceof long[]) {

101. long[] arr = (long[])obj;

102. StringBuilder sb = new StringBuilder();

103. sb.append("[");

104. for (long i : arr) {

105. sb.append(i+",");

106. }

107. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

108. }else if(obj instanceof char[]) {

109. char[] arr = (char[])obj;

110. StringBuilder sb = new StringBuilder();

111. sb.append("[");

112. for (char i : arr) {

113. sb.append(i+",");

114. }

115. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

116. }else if(obj instanceof short[]) {

117. short[] arr = (short[])obj;

118. StringBuilder sb = new StringBuilder();

119. sb.append("[");

120. for (short i : arr) {

121. sb.append(i+",");

122. }

123. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

124. }else if(obj instanceof double[]) {

125. double[] arr = (double[])obj;

126. StringBuilder sb = new StringBuilder();

127. sb.append("[");

128. for (double i : arr) {

129. sb.append(i+",");

130. }

131. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

132. }else if(obj instanceof float[]) {

133. float[] arr = (float[])obj;

134. StringBuilder sb = new StringBuilder();

135. sb.append("[");

136. for (float i : arr) {

137. sb.append(i+",");

138. }

139. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

140. }else if(obj instanceof Object[]) {

141. Object[] arr = (Object[])obj;

142. StringBuilder sb = new StringBuilder();

143. sb.append("[");

144. for (Object i : arr) {

145. sb.append(i.toString()+",");

146. }

147. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

148. }else {

149. str=obj.toString();

150. }

151. System.out.println(str);;

152. }

153.  

154. }

 

3.4 演算法分析

最佳情況：T(n) = O(n)   最壞情況：T(n) = O(n2)   平均情況：T(n) = O(n2)

4、希爾排序（Shell Sort）

1959年Shell發明，第一個突破O(n^2)的排序演算法，是簡單插入排序的改進版。它與插入排序的不同之處在於，它會優先比較距離較遠的元素。希爾排序又叫縮小增量排序。

希爾排序的核心在於間隔序列的設定。既可以提前設定好間隔序列，也可以動態的定義間隔序列。動態定義間隔序列的演算法是《演算法（第4版》的合著者Robert Sedgewick提出的。　

4.1 演算法描述

先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，具體演算法描述：

• 選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列個數k，對序列進行k 趟排序；
• 每趟排序，根據對應的增量ti，將待排序列分割成若干長度為m 的子序列，分別對各子表進行直接插入排序。僅增量因子為1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。

4.2 過程演示

4.3 程式碼實現

1. package cn.fuqiang.arithmetic;

2.  

3. import java.util.Comparator;

4.  

5. /**

6. * 希爾排序

7. * (建議：研究希爾排序前先理解插入排序)

8. * @author 王福強

9. * @Title: ShellSort.java

10. * @Package cn.fuqiang.arithmetic

11. * @Description

12. * @date 2018年6月11日 下午7:23:24

13. */

14. public class ShellSort {

15. public static void main(String[] args) {

16. int[] arr = {4,1,5,3,8,10,28,2};

17. sort(arr);

18. so(arr);

19. Integer[] arr2 = {4,1,5,3,8,10,28,2};

20. sort(arr2,(a,b)-> a.compareTo(b));

21. so(arr2);

22.  

23. }

24. /**

25. * 希爾排序 升序(特點：縮小增量排序 ，是插入排序的改進版)

26. * increment是用來記錄增量的

27. *講解：

28. * while(increment > 1)

29. * 最外層的 while迴圈是用來控制增量的。增量要從大到小

30. * increment =increment/3+1;

31. * 當每次迴圈後都吧增量除以一個數(改數不能是2和1 否則會死迴圈)加一

32. * 保證最後除盡後不能小於一，應為最後增量縮小為一後需要兩兩之間進行比較(此處也就是縮小增量)

33. *

34. * for (int i = increment; i < arr.length; i++) {

35. * 中間for迴圈，控制每次要取出的比較的元素，從增量開始，每次加一

36. * int temp = arr[i];

37. * 用一個零是變數接受要比較的值

38. * arr[j+increment] = temp;

39. * 因為在內層迴圈中已將前面的值移動到後面了，在最後一次 迴圈結束後 j -= increment 已經少了一個增量

40. * 所以j+increment 正好是移動後最後空出來的一個 所以把temp替換給該值，完成交換

41. * 就算沒有進入內層迴圈，呢j=i-incement後再+incement就還是 i本身temp也就是arr[i]本身

42. *

43. * for (j = i-increment; j >= 0 && arr[j]> temp ; j-=increment) {

44. * 最內層的for迴圈是用來控制temp 與每個j-increment個值比較，從 j=i-increment開始 也就是中層循中 i減去一個增量後的下標(與插入排序相同，只不過是每次跟前increment個值比較)

45. * j >= 0 && arr[j]> temp

46. * 該判斷是防止j減到負下標並且每次替換的實話 只有temp小於arr[j]才可以進入

47. * arr[j+increment] = arr[j];

48. * 如果arr[j]> temp 呢麼與將 arr[j]的值移動道後面

49. *

50. * 例如

51. * 4,1,5,3,8,10,28,2 長度為 8

52. * while迴圈第一次

53. * increment = 3

54. * 中層for迴圈 i從 3開始

55. * temp = arr[3]

56. * 內層for迴圈從j=i-increment 也就是從前increment個值開始

57. * 就會拿出arr[3-3]>temp 比較

58. * 如果temp小則 把 arr[3-3] 的值與 的值賦給arr[0+3] 也就是 arr[j+increment] = arr[j]

59. * 因為arr[3]已經記錄，所以當 j-=increment時 j=-3此時已經不滿足 j >= 0 所以內層迴圈結束

60. * 內層迴圈結束後 arr的值就從4,1,5,3,8,10,28,2 變為了 4,1,5,4,8,10,28,2

61. * 因為在內層迴圈中只是把 0下標的值賦給了3下標 所以說 0位置的值還是4

62. * 此時中層迴圈中的 arr[j+increment] = temp; 就是把原來記錄的 arr[3]----3 賦給0下標，

63. * 因為j已經被減了increment 變成了-3所以此時加上increment正好等於0下標

64. * 所以arr就變成了 3,1,5,4,8,10,28,2

65. *

66. * 中層for迴圈 i變為了4

67. * temp = arr[4]

68. * 內層for迴圈從j=i-increment 也就是從前increment個值開始

69. * 就會拿出arr[4-3]>temp 比較

70. * 因為arr[1]小於temp所以 而且j也已經=-1所以迴圈結束

71. * 。。。。。。。。。 以此類推

72. *

73. *

74. * @author 王福強

75. * @Description

76. * @date 2018年6月14日 下午5:33:04

77. * @param arr

78. */

79. public static void sort(int[] arr) {

80. int increment = arr.length;

81. while(increment > 1) { //動態定義間隔序列

82. increment =increment/3+1;

83. for (int i = increment; i < arr.length; i++) {

84. int temp = arr[i];

85. int j ;

86. for (j = i-increment; j >= 0 && arr[j]> temp ; j-=increment) {

87. arr[j+increment] = arr[j];

88. }

89. arr[j+increment] = temp;

90. }

91. }

92. }

93.  

94. /**

95. * 任意物件排序，將上面排序中 內部的迴圈替換為了while迴圈

96. * @author 王福強

97. * @Description

98. * @date 2018年6月15日 下午3:45:06

99. * @param arr

100. * @param comparator

101. */

102. public static <T>void sort(T[] arr,Comparator<T> comparator){

103. int increment = arr.length;

104. while(increment > 1) { //動態定義間隔序列

105. increment =increment/3+1;

106. for (int i = increment; i < arr.length; i++) {

107. T temp = arr[i];

108. int j = i-increment;

109. while ( j >= 0 && comparator.compare(arr[j], temp)>0 ) {

110. arr[j+increment] = arr[j];

111. j-=increment;

112. }

113. arr[j+increment] = temp;

114. }

115. }

116. }

117. /**

118. * 傳入任意陣列或物件 輸出到控制檯

119. * @author 王福強

120. * @Description 前提是傳入的物件必須重寫 toString()方法

121. * @date 2018年6月8日 下午4:26:06

122. * @param obj

123. */

124. public static void so(Object obj) {

125. String str = obj.toString();

126. if(obj instanceof int[]) {

127. int[] arr = (int[])obj;

128. StringBuilder sb = new StringBuilder();

129. sb.append("[");

130. for (int i : arr) {

131. sb.append(i+",");

132. }

133. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

134.  

135. }else if(obj instanceof long[]) {

136. long[] arr = (long[])obj;

137. StringBuilder sb = new StringBuilder();

138. sb.append("[");

139. for (long i : arr) {

140. sb.append(i+",");

141. }

142. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

143. }else if(obj instanceof char[]) {

144. char[] arr = (char[])obj;

145. StringBuilder sb = new StringBuilder();

146. sb.append("[");

147. for (char i : arr) {

148. sb.append(i+",");

149. }

150. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

151. }else if(obj instanceof short[]) {

152. short[] arr = (short[])obj;

153. StringBuilder sb = new StringBuilder();

154. sb.append("[");

155. for (short i : arr) {

156. sb.append(i+",");

157. }

158. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

159. }else if(obj instanceof double[]) {

160. double[] arr = (double[])obj;

161. StringBuilder sb = new StringBuilder();

162. sb.append("[");

163. for (double i : arr) {

164. sb.append(i+",");

165. }

166. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

167. }else if(obj instanceof float[]) {

168. float[] arr = (float[])obj;

169. StringBuilder sb = new StringBuilder();

170. sb.append("[");

171. for (float i : arr) {

172. sb.append(i+",");

173. }

174. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

175. }else if(obj instanceof Object[]) {

176. Object[] arr = (Object[])obj;

177. StringBuilder sb = new StringBuilder();

178. sb.append("[");

179. for (Object i : arr) {

180. sb.append(i.toString()+",");

181. }

182. str = sb.substring(0,sb.lastIndexOf(","))+"]" ;

183. }else {

184. str=obj.toString();

185. }

186. System.out.println(str);

187. }

188.  

189. }

 

4.4 演算法分析

最佳情況：T(n) = O(nlog2 n)  最壞情況：T(n) = O(nlog2 n)  平均情況：T(n) =O(nlog n)　

5、歸併排序（Merge Sort）

和選擇排序一樣，歸併排序的效能不受輸入資料的影響，但表現比選擇排序好的多，因為始終都是O(n log n）的時間複雜度。代價是需要額外的記憶體空間。

歸併排序是建立在歸併操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。歸併排序是一種穩定的排序方法。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱為2-路歸併。 

5.1 演算法描述

• 把長度為n的輸入序列分成兩個長度為n/2的子序列；
• 對這兩個子序列分別採用歸併排序；
• 將兩個排序好的子序列合併成一個最終的排序序列。

5.2 動圖演示

5.3 程式碼實現

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 28 29 30 31

function mergeSort(arr) { //採用自上而下的遞迴方法     var len = arr.length;     if(len < 2) {         return arr;     }     var middle = Math.floor(len / 2),         left = arr.slice(0, middle),         right = arr.slice(middle);     return merge(mergeSort(left), mergeSort(right)); }   function merge(left, right) {     var result = [];       while (left.length>0 && right.length>0) {         if (left[0] <= right[0]) {             result.push(left.shift());         }else {             result.push(right.shift());         }     }       while (left.length)         result.push(left.shift());       while (right.length)         result.push(right.shift());       return result; }

5. 4 演算法分析

最佳情況：T(n) = O(n)  最差情況：T(n) = O(nlogn)  平均情況：T(n) = O(nlogn)

6、快速排序（Quick Sort）

快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。

6.1 演算法描述

快速排序使用分治法來把一個串（list）分為兩個子串（sub-lists）。具體演算法描述如下：

• 從數列中挑出一個元素，稱為 “基準”（pivot）；
• 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割槽退出之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作；
• 遞迴地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

5.2 動圖演示

5.3 程式碼實現

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 28 29 30 31 32

function quickSort(arr, left, right) {     var len = arr.length,         partitionIndex,         left =typeof left !='number' ? 0 : left,         right =typeof right !='number' ? len - 1 : right;       if (left < right) {         partitionIndex = partition(arr, left, right);         quickSort(arr, left, partitionIndex-1);         quickSort(arr, partitionIndex+1, right);     }     return arr; }   function partition(arr, left ,right) {    //分割槽操作     var pivot = left,                     //設定基準值（pivot）         index = pivot + 1;     for (var i = index; i <= right; i++) {         if (arr[i] < arr[pivot]) {             swap(arr, i, index);             index++;         }            }     swap(arr, pivot, index - 1);     return index-1; }   function swap(arr, i, j) {     var temp = arr[i];     arr[i] = arr[j];     arr[j] = temp; }

5.4 演算法分析

最佳情況：T(n) = O(nlogn)   最差情況：T(n) = O(n2)   平均情況：T(n) = O(nlogn)　

7、堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆這種資料結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

7.1 演算法描述

• 將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆為初始的無序區；
• 將堆頂元素R[1]與最後一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且滿足R[1,2…n-1]<=R[n]；
• 由於交換後新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整為新堆，然後再次將R[1]與無序區最後一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數為n-1，則整個排序過程完成。

7.2 動圖演示

7.3 程式碼實現

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 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

var len;   //因為宣告的多個函式都需要資料長度，所以把len設定成為全域性變數   function buildMaxHeap(arr) {  //建立大頂堆     len = arr.length;     for (var i = Math.floor(len/2); i >= 0; i--) {         heapify(arr, i);     } }   function heapify(arr, i) {    //堆調整     var left = 2 * i + 1,         right = 2 * i + 2,         largest = i;       if (left < len && arr[left] > arr[largest]) {         largest = left;     }       if (right < len && arr[right] > arr[largest]) {         largest = right;     }       if (largest != i) {         swap(arr, i, largest);         heapify(arr, largest);     } }   function swap(arr, i, j) {     var temp = arr[i];     arr[i] = arr[j];     arr[j] = temp; }   function heapSort(arr) {     buildMaxHeap(arr);       for (var i = arr.length-1; i > 0; i--) {         swap(arr, 0, i);         len--;         heapify(arr, 0);     }     return arr; }

7.4 演算法分析

最佳情況：T(n) = O(nlogn) 最差情況：T(n) = O(nlogn) 平均情況：T(n) = O(nlogn)

8、計數排序（Counting Sort）

計數排序的核心在於將輸入的資料值轉化為鍵儲存在額外開闢的陣列空間中。 作為一種線性時間複雜度的排序，計數排序要求輸入的資料必須是有確定範圍的整數。

計數排序(Counting sort)是一種穩定的排序演算法。計數排序使用一個額外的陣列C，其中第i個元素是待排序陣列A中值等於i的元素的個數。然後根據陣列C來將A中的元素排到正確的位置。它只能對整數進行排序。

8.1 演算法描述

• 找出待排序的陣列中最大和最小的元素；
• 統計陣列中每個值為i的元素出現的次數，存入陣列C的第i項；
• 對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）；
• 反向填充目標陣列：將每個元素i放在新陣列的第C(i)項，每放一個元素就將C(i)減去1。

8.2 動圖演示

8.3 程式碼實現

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

function countingSort(arr, maxValue) {     var bucket =new Array(maxValue+1),         sortedIndex = 0;         arrLen = arr.length,         bucketLen = maxValue + 1;       for (var i = 0; i < arrLen; i++) {         if 相關推薦 史上最容易理解的《十大經典演算法（動態圖展示）》 十大經典排序演算法 部分內容引用自：https://www.cnblogs.com/onepixel/articles/7674659.html 感謝作者貢獻，如需刪除請聯絡本人！ 0、排序演算法說明 0.1 排序分類   非線性時間比較類排序：通過比較來 十大經典排序（動圖演示） 帶我初步地瞭解了排序，但是沒有轉載功能，只能自己手動轉載，侵權必刪。原文地址：https://www.cnblogs.com/onepixel/articles/7674659.html 0、演算法概述 0.1 演算法分類 十種常見排序演算法可以分為兩大類： 非線性時間比較類排序：通 資料探勘十大經典演算法（詳解）                                                        資料探勘十大經典演算法  一、 C4.5 C4.5演算法是機器學習演算法中的一種分類決策樹演算法,其核心演算法是ID3 演算法.   C4.5演算法繼承了ID3演算 史上最詳細c語言學生管理系統（完整的原始碼） #include<stdio.h> #include<stdlib.h> #include<string.h> #include<conio.h> struct student { char sno[12]; char n 高新技術企業認定，史上最詳細的申請攻略！（深度好文） 相關 str 直接 方式 項目 微信 組織 名片 數據 在市場廣闊的今天，基本每個省和市地×××府都會建立產業園區或高新技術企業優化孵化帶，提供各種政策支持、稅收優惠以及財政補助。同時，高新技術企業資質對企業來說是一張閃亮的名片，相當於中國的品牌馳名商標，不僅能夠為企業帶來 機器學習之十大經典演算法（八） PageRank演算法 PageRank演算法        （一）  PageRank演算法簡介：        Google的創始人之一LarryPage於1998年提出了PageRank，並應用在Google搜尋引擎的檢索結果排序上，該技術也是Google早期的核心技術之一。        L 史上最強視訊網站真實地址解析（網站視訊獲取） 文章有不當之處，歡迎指正，如果喜歡微信閱讀，你也可以關注我的微信公眾號：好好學java，獲取優質學習資源。 寫此文章旨在學習和討論，請勿濫用… 一、概述 目前網際網路視訊網站，從我解析的地球上十幾個大型的視訊網站來看，90%的網站視訊加密效果不 資料結構十種排序演算法（動圖演示） 0，演算法概述 0.1演算法分類 十種常見排序演算法可以分為兩大類： 非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O（nlogn），因此稱為非線性時間比較類排序。 線性時間非比較類排序：不通過比較來決定元素間的相對次序，它可以突破基於比較排 GitHub上最熱門的十大Vue.js專案 在過去的一個月裡，Mybridge從將近150個Vue.js開源專案中精選出十個熱門專案，旨在幫助開發者找到自己需要的Vue.js開源專案 上榜開源專案所獲得Star數平均為：268 涉及的領域包括：系統設計，移動元件，影象過濾器，圖表，Nuxtjs，元件，錄音機，表格，谷歌地圖，懸停效果 Android Binder機制原理（史上最強理解，沒有之一）（轉） Binder是Android系統程序間通訊（IPC）方式之一。Linux已經擁有的程序間通訊IPC手段包括(Internet Process Connection)： 管道（Pipe）、訊號（Signal）和跟蹤（Trace）、插口（Socket）、報文佇列（Messag 機器學習隨筆五—十大經典演算法—KNN (K最近鄰) 1. K-近鄰演算法原理 K最近鄰(kNN，k-NearestNeighbor)分類演算法，見名思意：找到最近的k個鄰居（樣本），在前k個樣本中選擇頻率最高的類別作為預測類別，什麼？怎麼那麼拗口，沒圖說個JB，下面舉個例子，圖解一下大家就會顯而易見了，如下圖： 資料探勘十大經典演算法之K最近鄰演算法 k-最近鄰演算法是基於例項的學習方法中最基本的，先介紹基於例項學習的相關概念。     基於例項的學習     1.已知一系列的訓練樣例，很多學習方法為目標函式建立起明確的一般化描述；但與此不同，基於例項的學習方法只是簡單地把訓練樣例儲存起來。     從這些例項中泛化 Android Binder機制原理（史上最強理解，沒有之一） Binder是Android系統程序間通訊（IPC）方式之一。Linux已經擁有的程序間通訊IPC手段包括(Internet Process Connection)： 管道（Pipe）、訊號（Signal）和跟蹤（Trace）、插口（Socket）、報文佇列（Messa 史上最全設計模式導學目錄（完整版） 最全 content bsp 書籍 轉載 http 模式 ogr book 該文章是轉載大牛的分享。備忘學習。 http://blog.csdn.net/lovelion/article/details/17517213 GitHu上分享的一些資料 https://zh 可能是史上最全的機器學習和Python（包括數學）速查表 最好 pytorch 資料 sub mat 出了 statistic 遇到 FQ 新手學習機器學習很難，就是收集資料也很費勁。所幸Robbie Allen從不同來源收集了目前最全的有關機器學習、Python和相關數學知識的速查表大全。強烈建議收藏！ 機器學習有很多方面 史上最全java架構師技能圖譜（下） 實戰 試題 能力 資料 系統調優 分庫分表 監控系統 文件存儲 大量 “java架構史上最全技能圖譜分為上下兩篇，這是java架構史上最全圖譜下篇，包含：大數據以及性能、設計模式、UML、中間件、分布式集群、負載均衡、通訊協議、架構設計等技術圖譜等章節。如果需要上篇內容：數 史上最全java架構師技能圖譜（上） 線程數 分支 選擇排序 linu 系統 窮舉 熱部署 batis err java架構師最全技能圖譜上篇，包含：數結構算法、java進階、web開發、框架與工具四大技能圖譜。下篇將包含大數據以及性能、設計模式、UML、中間件、分布式集群、負載均衡、通訊協議、架構設計等技術圖 十大經典排序演算法（動圖演示） 十大經典排序演算法（動圖演示） 十大經典排序演算法（動圖演示）   0、演算法概述 0.1 演算法分類 十種常見排序演算法可以分為兩大類： 非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O(nlogn)，因此稱為非線性時間比較類排序。 線性 資料探勘之十大經典演算法 國際權威的學術組織the IEEE International Conference on Data Mining (ICDM) 2006年12月評選出了資料探勘領域的十大經典演算法：C4.5, k-Means, SVM, Apriori, EM, PageRank, AdaBoost, k 機器學習十大經典演算法：（2）k-means演算法 1.基本Kmeans演算法[1] [cpp]  view plain  copy 選擇K個點作為初始質心   repeat