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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

1.给定一个数组,按照字典顺序从小到大的顺序。

8 个回复

倒序浏览
public class Test2{
public static void main(String[] args){
          int[] array={1,3,4,5,2,6,0};
          System.out.println("排序前");
          for(int a:array)
          System.out.print(a);
          //冒泡排序
          array=sort(array);
          System.out.println("\n排序后");
          for(int a:array)
          System.out.print(+a);
         }

         public static int[] sort(int[] a) {
          for(int i=0;i<a.length-1;i++){
                  for(int j=0;j<a.length-1-i;j++){
                          if(a[j]>a[j+1]){
                                  int n=a[j];
                                  a[j]=a[j+1];
                                  a[j+1]=n;
                          }
                  }
          }
          return a;
         }
}

评分

参与人数 1黑马币 +5 收起 理由
人心如水 + 5 赞一个!

查看全部评分

回复 使用道具 举报
public void sort(int[] arr){
  sort1(arr,0,arr.length-1);
}
private void  sort1(int[] arr,int a,int b){
int c =0;
if(a<b){
      c= find(arr,a,b);
      sort1(arr,a,c-1);
      sort1(arr,c+1,b);
}
}
private  int find(int[] arr,int a,int b){
int d =arr[b];
while(a<b){
while(a<b && arr[a] <=d)
a++;
arr[b]=arr[a];
while(a<b && arr[b]>=d)
b--;
arr[a]=arr[b];
}
arr[a] =d;
return a;
}
回复 使用道具 举报
刚才忘记注释了
冒泡排序算法的运作如下:
比较相邻的元素。如果第一个比第二个大,就交换他们两个。
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤,除了最后一个(已经是最大的,最后一个不需要再运算比较了)。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较
算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

public static void main(String[] args){
          int[] array={1,3,4,5,2,6,0};
          System.out.println("排序前");
          for(int a:array)
          System.out.print(a);
          //冒泡排序
          array=sort(array);
          System.out.println("\n排序后");
          for(int a:array)
          System.out.print(+a);
         }

         public static int[] sort(int[] a) {
          
                 //length-1是最后一个不需要运算,j+1会比较到最后一个的
                 for(int i=0;i<a.length-1;i++){
                         //每次比较都会选出一个最大的元素沉底,所以每次都会
                         //减少一个需要运算的元素,length-1-i
                  for(int j=0;j<a.length-1-i;j++){
                          //相邻两元素比较
                          if(a[j]>a[j+1]){
                                  int n=a[j];
                                  a[j]=a[j+1];
                                  a[j+1]=n;
                          }
                  }
          }
          return a;
         }
}
回复 使用道具 举报
大家玩的很高兴,我也来凑一下热闹

  1. import java.util.*;

  2. public class Sunday{
  3.         public static void main(String[] args){
  4.                 int arr[]={4,5,2,9,6,3,8};
  5.                 sop("原数组"+Arrays.toString(arr));
  6.                 Arrays.sort(arr);
  7.                 sop("排序后数组"+Arrays.toString(arr));
  8.         }
  9.         public static void sop(Object obj){
  10.                 System.out.println(obj);
  11.         }
  12. }
复制代码

Arrays类的用法请参见毕老师的视频第17天-16

回复 使用道具 举报
我就不献丑了
回复 使用道具 举报
钟伟 高级黑马 2014-7-19 11:06:31
7#
呃呃呃,不错
回复 使用道具 举报
我写了三种方法,就当我面试前的练手:lol//方法一,采用冒泡排序法,两个之间的排序,相邻两个比较,大的放后面,每次循环完最大的放最后
public class ArraySortDemo{
        public static void main(String[] args) {
                int[] arr = {1,4,3,87,43,56,22,-14};
                getSort(arr);
        }
        public static void getSort(int[] arr){
                //外循环仅仅提供内循环循最终能够比较到的最大角标
                for(int i =0;i<arr.length;i++){
                        //整个循环都是内循环来比较,外循环只提供比较到的位置,这里注意j=arr.length-i-1
                        for(int j =0;j<arr.length-i-1;j++){
                                //进行换位
                                if(arr[j]>arr[j+1]){
                                        int temp =arr[j+1];
                                        arr[j+1]=arr[j];
                                        arr[j]=temp;
                                }
                        }
                }
                //应为下面这个循环代码太长,就封装在宁外一个方法里,这样代码显得简单
                getSort2(arr);
        }
        public static void getSort2(int[] arr){
//                按数组的格式输出,这样好看些嘛。
                System.out.print("[");
//                遍历进行过 排序操作后的数组
                for(int m = 0;m<arr.length-1;m++){
//                        写着写着每一步就都出来了,发现最后多个标点,要去掉
                        System.out.print(arr[m]+",");
                }
                System.out.print(arr[arr.length-1]);
                System.out.print("]");
        }
}

//方法二:采用选择排序,从开始角标跟以后的每个角标比较,最小的放第一个
public class ArraySortDemo2 {
        public static void main(String[] args) {
                                int[] arr = {1,4,3,87,43,56,22,-14};
                                getSort(arr);
        }
        private static void getSort(int[] arr) {
                //外循环控制开始进行与后面元素比较的角标位
                for(int i =0;i<arr.length-1;i++){
                        //内循环控制后面要进行比较的元素角标,这里要注意的是j=i+1;
                        for(int j =i+1;j<arr.length;j++){
                                if(arr[i]>arr[j]){
                                        int temp = arr[i];
                                        arr[i]=arr[j];
                                        arr[j]=temp;
                                }
                        }
                }
                getSort2(arr);
        }
        private static void getSort2(int[] arr) {
                System.out.print("[");
                for(int m =0;m<arr.length-1;m++){
                        System.out.print(arr[m]+",");
                }
                System.out.print(arr[arr.length-1]);
                System.out.print("]");
        }
}

//第三种方法:使用工具类快速操作
import java.util.Arrays;

public class ArraySortDemo3{
        public static void main(String[] args) {
                int[] arr = {1,4,3,87,43,56,22,-14};
                getSort(arr);
        }
        private static void getSort(int[] arr) {
                //Arrays是util包下面一个操作数组(例如搜索和排序)的静态功能类,sort()方法提供排序升序排序
                Arrays.sort(arr);
                System.out.print("[");
                for(int i =0; i<arr.length-1;i++){
                        System.out.print(arr[i]+",");
                }
                System.out.print(arr[arr.length-1]);
                System.out.println("]");               
        }
}
               



回复 使用道具 举报
字典排序应该要看是什么样的数组吧,如果是字符串排序的话得用COMPARETO方法
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马