- 浏览: 347879 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
pacoson:
感谢楼主。请受小生一拜。
ANT预编译JSP -
zhuhongming123:
一楼的同学Lucene4.* 以上的 已经改成了Numeric ...
Lucene日期排序及组合查询 -
ywjk520:
RangeQuery在哪个包里?
Lucene日期排序及组合查询 -
willwen:
有个疑问,楼主,为何初始化bits 从txt读取已有的网址是直 ...
布隆过滤器(Bloom Filter)之java实例 -
yu_226528:
还不如没有呢
jFreeChart 在jsp页上实现简单的折线图、柱状图
1. package sort; 2. 3. import java.util.Random; 4. 5. /** 6. * 排序测试类 7. * 8. * 排序算法的分类如下: 1.插入排序(直接插入排序、折半插入排序、希尔排序); 2.交换排序(冒泡泡排序、快速排序); 9. * 3.选择排序(直接选择排序、堆排序); 4.归并排序; 5.基数排序。 10. * 11. * 关于排序方法的选择: (1)若n较小(如n≤50),可采用直接插入或直接选择排序。 12. * 当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。 13. * (2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜; 14. * (3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。 15. * 16. */ 17. /** 18. * @corporation 北京环亚 19. * @author HDS 20. * @date Nov 19, 2009 10:43:44 AM 21. * @path sort 22. * @description JAVA排序汇总 23. */ 24. public class SortTest { 25. 26. // //////==============================产生随机数==============================/////////////////// 27. /** 28. * @description 生成随机数 29. * @date Nov 19, 2009 30. * @author HDS 31. * @return int[] 32. */ 33. public int[] createArray() { 34. Random random = new Random(); 35. int[] array = new int[10]; 36. for (int i = 0; i < 10; i++) { 37. array[i] = random.nextInt(100) - random.nextInt(100);// 生成两个随机数相减,保证生成的数中有负数 38. } 39. System.out.println("==========原始序列=========="); 40. printArray(array); 41. return array; 42. } 43. 44. /** 45. * @description 打印出随机数 46. * @date Nov 19, 2009 47. * @author HDS 48. * @param data 49. */ 50. public void printArray(int[] data) { 51. for (int i : data) { 52. System.out.print(i + " "); 53. } 54. System.out.println(); 55. } 56. 57. /** 58. * @description 交换相邻两个数 59. * @date Nov 19, 2009 60. * @author HDS 61. * @param data 62. * @param x 63. * @param y 64. */ 65. public void swap(int[] data, int x, int y) { 66. int temp = data[x]; 67. data[x] = data[y]; 68. data[y] = temp; 69. } 70. 71. /** 72. * 冒泡排序----交换排序的一种 73. * 方法:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似操作。 74. * 性能:比较次数O(n^2),n^2/2;交换次数O(n^2),n^2/4 75. * 76. * @param data 77. * 要排序的数组 78. * @param sortType 79. * 排序类型 80. * @return 81. */ 82. public void bubbleSort(int[] data, String sortType) { 83. if (sortType.equals("asc")) { // 正排序,从小排到大 84. // 比较的轮数 85. for (int i = 1; i < data.length; i++) { // 数组有多长,轮数就有多长 86. // 将相邻两个数进行比较,较大的数往后冒泡 87. for (int j = 0; j < data.length - i; j++) {// 每一轮下来会将比较的次数减少 88. if (data[j] > data[j + 1]) { 89. // 交换相邻两个数 90. swap(data, j, j + 1); 91. } 92. } 93. } 94. } else if (sortType.equals("desc")) { // 倒排序,从大排到小 95. // 比较的轮数 96. for (int i = 1; i < data.length; i++) { 97. // 将相邻两个数进行比较,较大的数往后冒泡 98. for (int j = 0; j < data.length - i; j++) { 99. if (data[j] < data[j + 1]) { 100. // 交换相邻两个数 101. swap(data, j, j + 1); 102. } 103. } 104. } 105. } else { 106. System.out.println("您输入的排序类型错误!"); 107. } 108. printArray(data);// 输出冒泡排序后的数组值 109. } 110. 111. /** 112. * 直接选择排序法----选择排序的一种 方法:每一趟从待排序的数据元素中选出最小(或最大)的一个元素, 113. * 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。 性能:比较次数O(n^2),n^2/2 交换次数O(n),n 114. * 交换次数比冒泡排序少多了,由于交换所需CPU时间比比较所需的CUP时间多,所以选择排序比冒泡排序快。 115. * 但是N比较大时,比较所需的CPU时间占主要地位,所以这时的性能和冒泡排序差不太多,但毫无疑问肯定要快些。 116. * 117. * @param data 118. * 要排序的数组 119. * @param sortType 120. * 排序类型 121. * @return 122. */ 123. public void selectSort(int[] data, String sortType) { 124. if (sortType.endsWith("asc")) {// 正排序,从小排到大 125. int index; 126. for (int i = 1; i < data.length; i++) { 127. index = 0; 128. for (int j = 1; j <= data.length - i; j++) { 129. if (data[j] > data[index]) { 130. index = j; 131. } 132. } 133. // 交换在位置data.length-i和index(最大值)两个数 134. swap(data, data.length - i, index); 135. } 136. } else if (sortType.equals("desc")) { // 倒排序,从大排到小 137. int index; 138. for (int i = 1; i < data.length; i++) { 139. index = 0; 140. for (int j = 1; j <= data.length - i; j++) { 141. if (data[j] < data[index]) { 142. index = j; 143. } 144. } 145. // 交换在位置data.length-i和index(最大值)两个数 146. swap(data, data.length - i, index); 147. } 148. } else { 149. System.out.println("您输入的排序类型错误!"); 150. } 151. printArray(data);// 输出直接选择排序后的数组值 152. } 153. 154. /** 155. * 插入排序 方法:将一个记录插入到已排好序的有序表(有可能是空表)中,从而得到一个新的记录数增1的有序表。 性能:比较次数O(n^2),n^2/4 156. * 复制次数O(n),n^2/4 比较次数是前两者的一般,而复制所需的CPU时间较交换少,所以性能上比冒泡排序提高一倍多,而比选择排序也要快。 157. * 158. * @param data 159. * 要排序的数组 160. * @param sortType 161. * 排序类型 162. */ 163. public void insertSort(int[] data, String sortType) { 164. if (sortType.equals("asc")) { // 正排序,从小排到大 165. // 比较的轮数 166. for (int i = 1; i < data.length; i++) { 167. // 保证前i+1个数排好序 168. for (int j = 0; j < i; j++) { 169. if (data[j] > data[i]) { 170. // 交换在位置j和i两个数 171. swap(data, i, j); 172. } 173. } 174. } 175. } else if (sortType.equals("desc")) { // 倒排序,从大排到小 176. // 比较的轮数 177. for (int i = 1; i < data.length; i++) { 178. // 保证前i+1个数排好序 179. for (int j = 0; j < i; j++) { 180. if (data[j] < data[i]) { 181. // 交换在位置j和i两个数 182. swap(data, i, j); 183. } 184. } 185. } 186. } else { 187. System.out.println("您输入的排序类型错误!"); 188. } 189. printArray(data);// 输出插入排序后的数组值 190. } 191. 192. /** 193. * 反转数组的方法 194. * 195. * @param data 196. * 源数组 197. */ 198. public void reverse(int[] data) { 199. int length = data.length; 200. int temp = 0;// 临时变量 201. for (int i = 0; i < length / 2; i++) { 202. temp = data[i]; 203. data[i] = data[length - 1 - i]; 204. data[length - 1 - i] = temp; 205. } 206. printArray(data);// 输出到转后数组的值 207. } 208. 209. /** 210. * 快速排序 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。 步骤为: 211. * 1. 从数列中挑出一个元素,称为 "基准"(pivot), 2. 212. * 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。 213. * 3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。 214. * 递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。 215. * 216. * @param data 217. * 待排序的数组 218. * @param low 219. * @param high 220. * @see SortTest#qsort(int[], int, int) 221. * @see SortTest#qsort_desc(int[], int, int) 222. */ 223. public void quickSort(int[] data, String sortType) { 224. if (sortType.equals("asc")) { // 正排序,从小排到大 225. qsort_asc(data, 0, data.length - 1); 226. } else if (sortType.equals("desc")) { // 倒排序,从大排到小 227. qsort_desc(data, 0, data.length - 1); 228. } else { 229. System.out.println("您输入的排序类型错误!"); 230. } 231. } 232. 233. /** 234. * 快速排序的具体实现,排正序 235. * 236. * @param data 237. * @param low 238. * @param high 239. */ 240. private void qsort_asc(int data[], int low, int high) { 241. int i, j, x; 242. if (low < high) { // 这个条件用来结束递归 243. i = low; 244. j = high; 245. x = data[i]; 246. while (i < j) { 247. while (i < j && data[j] > x) { 248. j--; // 从右向左找第一个小于x的数 249. } 250. if (i < j) { 251. data[i] = data[j]; 252. i++; 253. } 254. while (i < j && data[i] < x) { 255. i++; // 从左向右找第一个大于x的数 256. } 257. if (i < j) { 258. data[j] = data[i]; 259. j--; 260. } 261. } 262. data[i] = x; 263. qsort_asc(data, low, i - 1); 264. qsort_asc(data, i + 1, high); 265. } 266. } 267. 268. /** 269. * 快速排序的具体实现,排倒序 270. * 271. * @param data 272. * @param low 273. * @param high 274. */ 275. private void qsort_desc(int data[], int low, int high) { 276. int i, j, x; 277. if (low < high) { // 这个条件用来结束递归 278. i = low; 279. j = high; 280. x = data[i]; 281. while (i < j) { 282. while (i < j && data[j] < x) { 283. j--; // 从右向左找第一个小于x的数 284. } 285. if (i < j) { 286. data[i] = data[j]; 287. i++; 288. } 289. while (i < j && data[i] > x) { 290. i++; // 从左向右找第一个大于x的数 291. } 292. if (i < j) { 293. data[j] = data[i]; 294. j--; 295. } 296. } 297. data[i] = x; 298. qsort_desc(data, low, i - 1); 299. qsort_desc(data, i + 1, high); 300. } 301. } 302. 303. /** 304. * 二分查找特定整数在整型数组中的位置(递归) 查找线性表必须是有序列表 305. * 306. * @paramdataset 307. * @paramdata 308. * @parambeginIndex 309. * @paramendIndex 310. * @returnindex 311. */ 312. public int binarySearch(int[] dataset, int data, int beginIndex, 313. int endIndex) { 314. int midIndex = (beginIndex + endIndex) >>> 1; // 相当于mid = (low + high) 315. // / 2,但是效率会高些 316. if (data < dataset[beginIndex] || data > dataset[endIndex] 317. || beginIndex > endIndex) 318. return -1; 319. if (data < dataset[midIndex]) { 320. return binarySearch(dataset, data, beginIndex, midIndex - 1); 321. } else if (data > dataset[midIndex]) { 322. return binarySearch(dataset, data, midIndex + 1, endIndex); 323. } else { 324. return midIndex; 325. } 326. } 327. 328. /** 329. * 二分查找特定整数在整型数组中的位置(非递归) 查找线性表必须是有序列表 330. * 331. * @paramdataset 332. * @paramdata 333. * @returnindex 334. */ 335. public int binarySearch(int[] dataset, int data) { 336. int beginIndex = 0; 337. int endIndex = dataset.length - 1; 338. int midIndex = -1; 339. if (data < dataset[beginIndex] || data > dataset[endIndex] 340. || beginIndex > endIndex) 341. return -1; 342. while (beginIndex <= endIndex) { 343. midIndex = (beginIndex + endIndex) >>> 1; // 相当于midIndex = 344. // (beginIndex + 345. // endIndex) / 2,但是效率会高些 346. if (data < dataset[midIndex]) { 347. endIndex = midIndex - 1; 348. } else if (data > dataset[midIndex]) { 349. beginIndex = midIndex + 1; 350. } else { 351. return midIndex; 352. } 353. } 354. return -1; 355. } 356. 357. // /////////////////////===================================测试====================////////////////// 358. public static void main(String[] args) { 359. SortTest ST = new SortTest(); 360. int[] array = ST.createArray(); 361. System.out.println("==========冒泡排序后(正序)=========="); 362. ST.bubbleSort(array, "asc"); 363. System.out.println("==========冒泡排序后(倒序)=========="); 364. ST.bubbleSort(array, "desc"); 365. 366. array = ST.createArray(); 367. System.out.println("==========选择排序后(正序)=========="); 368. ST.selectSort(array, "asc"); 369. System.out.println("==========选择排序后(倒序)=========="); 370. ST.selectSort(array, "desc"); 371. 372. array = ST.createArray(); 373. System.out.println("==========插入排序后(正序)=========="); 374. ST.insertSort(array, "asc"); 375. System.out.println("==========插入排序后(倒序)=========="); 376. ST.insertSort(array, "desc"); 377. 378. array = ST.createArray(); 379. System.out.println("==========快速排序后(正序)=========="); 380. ST.quickSort(array, "asc"); 381. ST.printArray(array); 382. System.out.println("==========快速排序后(倒序)=========="); 383. ST.quickSort(array, "desc"); 384. ST.printArray(array); 385. System.out.println("==========数组二分查找=========="); 386. System.out.println("您要找的数在第" + ST.binarySearch(array, 74)+ "个位子。(下标从0计算)"); 387. 388. } 389. 390. }
发表评论
-
java用绑定变量调用Oracle
2011-03-11 16:59 1085在JAVA中的SQL 语句的编 ... -
java 实现压缩与解压缩ZIP
2010-08-18 10:17 852压缩的 import java.io.BufferedIn ... -
Java中对TreeMap中文排序
2010-08-17 18:20 1888package org.hsyd.test; ... -
java 卸载动态链接库
2010-06-21 11:53 1914import java.lang.reflect.Field; ... -
java数据库连接池实现
2010-02-05 11:21 767.package cc.vicp.eden.plug; ... -
Java NIO原理和使用
2010-01-16 14:29 1646Java NIO非堵塞应用通常适用用在I/O读写等方面,我们知 ... -
Java对各种文件的操作
2009-12-12 22:23 988java中提供了io类库,可以轻松的用java实现对文件的各种 ... -
直接由Java获取文件的创建时间
2009-11-11 11:22 3027import java.io.*; public cla ... -
非常实用的myeclipse快捷键
2009-08-13 22:24 1204技巧:取消自动validation validation有一堆 ... -
计算工作日和自然日
2009-06-24 19:21 3332用Java写一个倒计时程序,比如输入一个日期,格式为20090 ... -
文件排序后进行文本复制
2009-06-24 18:48 990现将TEXT1.TXT中的文本内容 复制到TEXT2.TXT中 ... -
getResourceAsStream的用法
2009-06-24 18:28 2592getResourceAsStream 用法大致有以下几种: ... -
将一首古诗竖着排序从右往左读
2009-06-24 17:36 3138import java.util.ArrayList; ... -
计算两个日期之间相差的天数
2009-06-24 16:47 2020程序经过一系列处理,得到两个string类型的时间值,一个值的 ... -
如何得到一年的所有星期二的日期?
2009-06-24 16:42 1444import java.text.DateFormat; ... -
根据格式日期转换
2009-06-24 16:39 909根据一个TimeZone的时间,比如一个“Africa/Acc ... -
当输入一个年月份的时候,输出这个月份的最后一天,比如输入: 2006年5月 就输出5月份的最后一个日
2009-06-24 16:00 1165import java.text.ParseException ... -
读取一个文本文档,例如有1~10行,要求按10~1行的顺序输出.并保存予原文件.
2009-06-24 15:49 1353import java.io.File; import ... -
编写一个辅助小学生学习乘法的程序
2009-06-22 16:39 1625编写一个辅助小学生学习乘法的程序。使用一个Random对象产生 ... -
输入一个字符串,按相反顺序输出该字符串。如输入1234,输出4321。
2009-06-22 16:18 4514package test25; import ...
相关推荐
Java排序算法实现 Java排序算法实现 Java排序算法实现
Java实现归并排序 Java 实现归并排序是一种常用的排序算法,通过分治策略将原始数组分成小组,然后对每个小组进行排序,最后将排序好的小组合并成一个有序数组。下面是 Java 实现归并排序的知识点总结: 基本思想 ...
堆排序7.java 使用java实现的堆排序堆排序7.java 使用java实现的堆排序堆排序7.java 使用java实现的堆排序堆排序7.java 使用java实现的堆排序堆排序7.java 使用java实现的堆排序堆排序7.java 使用java实现的堆排序堆...
本文将详细探讨标题所提及的几种排序算法:合并排序、插入排序、希尔排序、快速排序、冒泡排序以及桶排序,并结合Java语言的实现进行解析。 1. **合并排序(Merge Sort)**: 合并排序是一种基于分治策略的排序算法...
本篇将详细讲解如何使用Java实现快速排序。 首先,理解快速排序的步骤至关重要。快速排序的主要步骤包括: 1. **选择枢轴元素(Pivot Selection)**:在待排序的数组中选取一个元素作为枢轴,通常选择第一个或最后...
总结一下,Java实现拖拽列表项的排序功能主要包括以下步骤: 1. 启用UI组件的拖放功能,如设置`AllowDrop`、`CanReorderItems`和`IsSwipeEnabled`属性。 2. 监听并处理拖放事件,更新数据模型以反映拖放操作。 3. ...
在Java中实现二叉排序树,我们通常会定义一个`Node`类来表示树的节点,它包含键、值以及左右子节点的引用。例如: ```java class Node { int key; Object value; Node left, right; public Node(int item) { ...
排序实现 文件中给出了冒泡排序和选择排序的具体实现。这些方法都接受一个待排序的数组和一个字符串参数`sortType`,用于指定排序的方向(升序或降序)。例如: ```java public void bubbleSort(int[] data, ...
堆排序12.java 使用java代码实现堆排序12.java 使用java代码实现堆排序12.java 使用java代码实现堆排序12.java 使用java代码实现堆排序12.java 使用java代码实现堆排序12.java 使用java代码实现堆排序12.java 使用...
堆排序10.java 使用java来实现堆排序10.java 使用java来实现堆排序10.java 使用java来实现堆排序10.java 使用java来实现堆排序10.java 使用java来实现堆排序10.java 使用java来实现堆排序10.java 使用java来实现堆...
在Java编程环境中,我们也可以模拟实现这种排序规则。Java提供了丰富的类库和方法来处理文件操作,包括对文件的排序。以下是关于如何在Java中实现Windows文件排序规则的详细解释: 1. **文件对象的创建**: 在Java...
快速排序 java实现
冒泡排序:应用Java和Python实现冒泡排序算法 冒泡排序:应用Java和Python实现冒泡排序算法 冒泡排序:应用Java和Python实现冒泡排序算法 冒泡排序:应用Java和Python实现冒泡排序算法 冒泡排序:应用Java和Python...
本文将介绍两种常见的排序算法:直接插入排序和希尔排序,并通过Java代码实现来帮助理解。 1. 直接插入排序(直接插入排序) 直接插入排序是一种简单的排序方法,它的工作原理类似于我们平时手动整理扑克牌。在排序...
在Java中实现插入排序,主要涉及数组操作和循环控制,我们可以从以下几个方面来理解这个过程。 1. **基本概念** 插入排序在实际操作中类似于打扑克牌,每拿到一张新牌(数组中的元素),就将其插入到已排序的序列...
Java ip 地址排序Java ip 地址排序Java ip 地址排序Java ip 地址排序
下面是一个简单的Java冒泡排序实现: ```java public class BubbleSort { public static void bubbleSort(int[] array) { int n = array.length; for (int i = 0; i ; i++) { // 外层循环控制遍历次数 for (int...
本篇文章将详细探讨标题为“8种常用排序方法Java类实现”的主题,主要基于描述中的内容,即8种业务中常见的排序方法在Java语言中的实现。 1. **冒泡排序(Bubble Sort)**:冒泡排序是一种简单直观的排序算法,通过...
本篇文章将深入探讨在Java中实现两种经典的排序算法:冒泡排序和快速排序。 首先,让我们从冒泡排序开始。冒泡排序是一种简单直观的排序算法,它重复地遍历待排序的数列,一次比较两个元素,如果他们的顺序错误就把...
在Java编程语言中,排序是数据处理中非常基础且重要的操作。本文将全面解析Java中的各种排序算法,帮助你理解并掌握它们的核心概念、实现...同时,也可以研究并对比其他编程语言中的排序实现,以增强跨语言编程能力。