A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 赵国刚 中级黑马   /  2013-8-13 08:12  /  2411 人查看  /  7 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

一个数组
int [] arr = new int[]{1,6,5,9,8,2,7};
进行排序
下面是我学习的方法;

这是 普通排序
//选择排序法之升序,反之(<)就是降序
  public static void sort(int [] arr){
  
   int temp=0;
   
   for(int x=0;x<arr.length-1;x++){
   
            for(int y=x+1;y<arr.length;y++){
   
                     if(arr[x]>arr[y])
                      {
                          temp=arr[x];
                         arr[x]=arr[y];
                          arr[y]=temp;
                       }
     
                }
   
         }
  }

这是 冒泡排序
public static void maopaosort(int [] arr){
  
   for(int x=0;x<arr.length-1;x++){
        for(int y=0;y<arr.length-x-1;y++){
                 if(arr[y]>arr[y+1]){
                    int temp = arr[y];
                    arr[y]=arr[y+1];
                   arr[y+1]=temp;
                                   }
   
                         }
             }
  }

问题是:这两种排序方法哪种更高效率,还有比这两种更高效的嘛?写出来让我学习下
               请大家指教

评分

参与人数 2技术分 +1 黑马币 +3 收起 理由
田磊阳 + 1
以防万一 + 3 神马都是浮云

查看全部评分

7 个回复

正序浏览
其实那两个效率都差不多,使用的都是蛮力法,时间复杂度是O(n^2),可以说效率很低。而且没有改进,选择排序可以减少移动的次数,从而提高性能。而冒泡排序也可以改进,在一趟冒泡排序过程中,如果有多个记录交换到最终位置,则下一趟冒泡排序将不处理这些记录;另外,在一趟冒泡排序过程中,如果没有记录想交换,那么表明这个数组已经有序,算法终止,可以在你的算法基础上加个标志位就能够改进。
下面我给出这两个改进的算法:
改进的选择排序算法:
void SelectSort(int r [],int n)  {
  for(int i = 0;i<n-1;i++){
  int index = i;
  for(int j = i+1;i<n;j++){  //在无序区中找最小记录
  if(r[j]<r[index]);
  index = j;
  i(index != i){
  b = a^b;a = a^b;b = a^b; //若最小记录不在最终位置则交换
  }
  }
  }
}
改进的冒泡排序算法:
Void BubbleSort(int r [] ,int n){
  int exchange = n;
  while(exchange){
  int bound = exchange;exchange= 0;
  ror(int j = 1;j<bound;j++)
  if(r[j]>r[j+1]){
  r[j+1];= r[j]^r[j+1];
  r[j] = r[j]^r[j+1];
  r[j+1];= r[j]^r[j+1];
  exchange = j;
  }
  }
}
希望对你有用!
回复 使用道具 举报
亲,如问题已解决请将分类的未解决改为已解决。

以后的问题贴也要及时更改分类哦~

保持队形,谢谢合作
回复 使用道具 举报
毕老师好像提到过要快的还是希尔排序,我也还是在学习中,就从百度给找了个例子
  1. public class Test {
  2.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 };
  3.   public static void main(String args[]) {
  4.   int i; // 循环计数变量
  5.   int Index = a.length;// 数据索引变量
  6.   System.out.print("排序前: ");
  7.   for (i = 0; i < Index - 1; i++)
  8.   System.out.printf("%3s ", a[i]);
  9.   System.out.println("");
  10.   ShellSort(Index - 1); // 选择排序
  11.   // 排序后结果
  12.   System.out.print("排序后: ");
  13.   for (i = 0; i < Index - 1; i++)
  14.   System.out.printf("%3s ", a[i]);
  15.   System.out.println("");
  16.   }
  17.   public static void ShellSort(int Index) {
  18.   int i, j, k; // 循环计数变量
  19.   int Temp; // 暂存变量
  20.   boolean Change; // 数据是否改变
  21.   int DataLength; // 分割集合的间隔长度
  22.   int Pointer; // 进行处理的位置
  23.   DataLength = (int) Index / 2; // 初始集合间隔长度
  24.   while (DataLength != 0) // 数列仍可进行分割
  25.   {
  26.   // 对各个集合进行处理
  27.   for (j = DataLength; j < Index; j++) {
  28.   Change = false;
  29.   Temp = a[j]; // 暂存Data[j]的值,待交换值时用
  30.   Pointer = j - DataLength; // 计算进行处理的位置
  31.   // 进行集合内数值的比较与交换值
  32.   while (Temp < a[Pointer] && Pointer >= 0 && Pointer <= Index) {
  33.   a[Pointer + DataLength] = a[Pointer];
  34.   // 计算下一个欲进行处理的位置
  35.   Pointer = Pointer - DataLength;
  36.   Change = true;
  37.   if (Pointer < 0 || Pointer > Index)
  38.   break;
  39.   }
  40.   // 与最后的数值交换
  41.   a[Pointer + DataLength] = Temp;
  42.   if (Change) {
  43.   // 打印目前排序结果
  44.   System.out.print("排序中: ");
  45.   for (k = 0; k < Index; k++)
  46.   System.out.printf("%3s ", a[k]);
  47.   System.out.println("");
  48.   }
  49.   }
  50.   DataLength = DataLength / 2; // 计算下次分割的间隔长度
  51.   }
  52.   }
  53. }
复制代码
回复 使用道具 举报
亲,如问题已解决请将分类的未解决改为已解决。

以后的问题贴也要及时更改分类哦~


保持队形,谢谢合作
回复 使用道具 举报
一个数组
int [] arr = new int[]{1,6,5,9,8,2,7};
进行排序
下面是我学习的方法;

这是 普通排序
//选择排序法之升序,反之(<)就是降序
  public static void sort(int [] arr){
  
   int temp=0;
   
   for(int x=0;x<arr.length-1;x++){
   
            for(int y=x+1;y<arr.length;y++){
   
                     if(arr[x]>arr[y])
                      {
                          temp=arr[x];
                         arr[x]=arr[y];
                          arr[y]=temp;
                       }
     
                }
   
         }
  }

这是 冒泡排序
public static void maopaosort(int [] arr){
  
   for(int x=0;x<arr.length-1;x++){
        for(int y=0;y<arr.length-x-1;y++){
                 if(arr[y]>arr[y+1]){
                    int temp = arr[y];
                    arr[y]=arr[y+1];
                   arr[y+1]=temp;
                                   }
   
                         }
             }
  }

问题是:这两种排序方法哪种更高效率,还有比这两种更高效的嘛?写出来让我学习下
               请大家指教
////////这俩种排序,冒泡排序效率要高。
比这俩种排序效率更高的有啊,只要保证排序的时候,每一个元素访问的次数最少,那效率就会最高!

评分

参与人数 1技术分 +1 收起 理由
张俊生 + 1 神马都是浮云

查看全部评分

回复 使用道具 举报
还有一个毕老师讲过的排序  选择排序
1 public static int[] selectSort(int[] args){
2                 for (int i=0;i<args.length-1 ;i++ ){
3                         int min=i;
4                         for (int j=i+1;j<args.length ;j++ ){
5                                 if (args[min]>args[j]){
6                                         min=j;
7                                 }
8                         }
9                         if (min!=i){
10                         int temp=args[i];
11                         args[i]=args[min];
12                         args[min]=temp;        
13                         }
14                 }
15                 return args;
16         }

评分

参与人数 1技术分 +1 收起 理由
薛鹏鹏 + 1

查看全部评分

回复 使用道具 举报
1  public static int[] insertSort(int[] args){//插入排序算法
2                 for(int i=1;i<args.length;i++){
3                         for(int j=i;j>0;j--){
4                                 if (args[j]<args[j-1]){
5                                         int temp=args[j-1];
6                                         args[j-1]=args[j];
7                                         args[j]=temp;        
8                                 }else break;
9                         }
10                 }
11                 return args;
12         }
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马