码迷，mamicode.com
首页 > 编程语言 > 详细

Java常用的排序算法

时间：2017-09-23 21:17:38      阅读：200      评论：0      收藏：0      [点我收藏+]

标签：soft   down   效率   boa   很多   覆盖   sof   ble   这一   

转载自博客http://blog.csdn.net/xsf50717

 

排序算法

重要性不言而喻，很多算法问题往往选择一个好的排序算法往往问题可以迎刃而解

 

1、冒泡算法

技术分享

 

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。也就是双重循环就可以搞定的问题但是需要注意下一边界

算法步骤：

1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3）针对所有的元素重复以上的步骤，除了最后一个。

4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

[java] view plain copy
 
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">public void BubbleSort(int[] a) {  
  2.         int temp = 0;  
  3.         int len = a.length;  
  4.         for (int i = 0; i < len; i++) {  
  5.             for (int j = 1; j < len - i; j++)  
  6.                 if (a[j - 1] > a[j]) {  
  7.                     //注意分清是a[j-1]还是a[j]不然容易出现边界问题  
  8.                     // 从小到大排序  
  9.                     temp = a[j - 1];  
  10.                     a[j - 1] = a[j];  
  11.                     a[j] = temp;  
  12.                 }  
  13.         }  
  14.     }</span>  

优化的冒泡排序

由于可能在前几次就已经排好序，但是在上一种冒泡排序中仍然需要一直遍历到最后。

优化措施：设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。

[java] view plain copy
 
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">public void BubbleSort1(int[] a) {  
  2.         int temp = 0;  
  3.         int len = a.length;  
  4.         boolean flag = true;  
  5.         while (flag) {  
  6.             flag = false;  
  7.             for (int j = 1; j < len - 1; j++)  
  8.                 if (a[j - 1] > a[j]) {  
  9.                     // 注意分清是a[j-1]还是a[j]不然容易出现边界问题  
  10.                     // 从小到大排序  
  11.                     temp = a[j - 1];  
  12.                     a[j - 1] = a[j];  
  13.                     a[j] = temp;  
  14.                     // 设置标志位  
  15.                     flag = true;  
  16.                 }  
  17.         }  
  18.     }</span>  

 

2、快速排序

技术分享

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

算法步骤：
1） 从数列中挑出一个元素，称为 “基准”（pivot），
2 ）重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3 ）递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

[java] view plain copy
 
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">    private static void quick_sort(int[] arr, int low, int high) {  
  2.         // 解决和合并  
  3.         if (low <= high) {  
  4.             int mid = partition(arr, low, high);  
  5.             // 递归  
  6.             quick_sort(arr, low, mid - 1);  
  7.             quick_sort(arr, mid + 1, high);  
  8.         }  
  9.   
  10.     }  
  11.   
  12.     private static int partition(int[] arr, int low, int high) {  
  13.         // 分解  
  14.         int pivot = arr[high];  
  15.         int i = low - 1;  
  16.         int temp;  
  17.         for (int j = low; j < high; j++) {  
  18.   
  19.             if (arr[j] < pivot) {  
  20.                 i++;  
  21.                 temp = arr[i];  
  22.                 arr[i] = arr[j];  
  23.                 arr[j] = temp;  
  24.             }  
  25.         }  
  26.         // 交换中间元素和privot  
  27.         temp = arr[i + 1];  
  28.         arr[i + 1] = arr[high];  
  29.         arr[high] = temp;  
  30.         return i + 1;  
  31.   
  32.     }</span>  



3、归并排序

技术分享

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

算法步骤：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4. 重复步骤3直到某一指针达到序列尾

5. 将另一序列剩下的所有元素直接复制到合并序列尾

[java] view plain copy
 
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">  public static int[] sort(int[] nums, int low, int high) {    
  2.         int mid = (low + high) / 2;    
  3.         if (low < high) {    
  4.             // 左边    
  5.             sort(nums, low, mid);    
  6.             // 右边    
  7.             sort(nums, mid + 1, high);    
  8.             // 左右归并    
  9.             merge(nums, low, mid, high);    
  10.         }    
  11.         return nums;    
  12.     }    
  13.     
  14.     public static void merge(int[] nums, int low, int mid, int high) {    
  15.         int[] temp = new int[high - low + 1];    
  16.         int i = low;// 左指针    
  17.         int j = mid + 1;// 右指针    
  18.         int k = 0;    
  19.     
  20.         // 把较小的数先移到新数组中    
  21.         while (i <= mid && j <= high) {    
  22.             if (nums[i] < nums[j]) {    
  23.                 temp[k++] = nums[i++];    
  24.             } else {    
  25.                 temp[k++] = nums[j++];    
  26.             }    
  27.         }    
  28.     
  29.         // 把左边剩余的数移入数组    
  30.         while (i <= mid) {    
  31.             temp[k++] = nums[i++];    
  32.         }    
  33.     
  34.         // 把右边边剩余的数移入数组    
  35.         while (j <= high) {    
  36.             temp[k++] = nums[j++];    
  37.         }    
  38.     
  39.         // 把新数组中的数覆盖nums数组    
  40.         for (int k2 = 0; k2 < temp.length; k2++) {    
  41.             nums[k2 + low] = temp[k2];    
  42.         }    
  43.     }  </span>  

 

4、选择排序

技术分享

选择排序(Selection sort)也是一种简单直观的排序算法。
算法步骤：
1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3）重复第二步，直到所有元素均排序完毕。

[java] view plain copy
 
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">  public int[] ChoseSort(int[] intArr){    
  2.         for(int i=0;i<intArr.length;i++){    
  3.             int lowIndex = i;    
  4.                 
  5.             for(int j=i+1;j<intArr.length;j++){    
  6.                 if(intArr[j]<intArr[lowIndex]){    
  7.                     lowIndex = j;    
  8.                 }    
  9.             }    
  10.                 
  11.             //将当前第一个元素与它后面序列中的最小的一个 元素交换，也就是将最小的元素放在最前端    
  12.             int temp = intArr[i];               
  13.             intArr[i] = intArr[lowIndex];    
  14.             intArr[lowIndex] = temp;    
  15.         }    
  16.             
  17.         return intArr;    
  18.     } </span>  

 

5、堆排序

技术分享

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
堆排序的平均时间复杂度为Ο(nlogn) 。
算法步骤：
1）创建一个堆H[0..n-1]
2）把堆首（最大值）和堆尾互换
3）把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置
4） 重复步骤2，直到堆的尺寸为1

调整堆部分不太好写建议参考http://blog.csdn.net/jdream314/article/details/6634863

最后给出一张各算法的性能比较图

技术分享

Java常用的排序算法

标签：soft   down   效率   boa   很多   覆盖   sof   ble   这一   

原文地址：http://www.cnblogs.com/CodingAndRiding/p/7582243.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！