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

字典排序应该要看是什么样的数组吧，如果是字符串排序的话得用COMPARETO方法

我写了三种方法，就当我面试前的练手: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("]");               
        }
}
               

呃呃呃，不错

我就不献丑了

大家玩的很高兴，我也来凑一下热闹

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

复制代码

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

刚才忘记注释了
冒泡排序算法的运作如下：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个（已经是最大的，最后一个不需要再运算比较了）。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
算法稳定性

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

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;
         }
}

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 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;
         }
}