java 数组冒泡排序、转置（降序）

1.java 数组冒泡排序

排序的基本原理（升序）：

• 　　原始数据：  2 、1 、9 、0 、5 、3 、7 、6 、8；
• 第一次排序： 1  、2 、0 、5 、3 、7 、6 、8 、9 ；
• 第二次排序： 1  、0 、2 、3 、5 、6 、7 、8 、9 ；
• 第三次排序 ： 1 、 2 、3 、4 、5 、6 、7 、8 、9 ；

　以上是基础的原理过程，但是有一个问题，数据的不同可能排序的次数出现不同，但是有多少个数据，总的排序次数不会超过数组的长度。只要排序的次数达到长度*长度的次数，那么所有的数据就可以排序成功。

进行冒泡排序：

public class 数组的排序 {
    public static void main(String[] args) {
        int data[] = new int[]{2,1,9,0,5,3,7,6,8};
        get(data);
        //外层控制排序的总次数
        for (int y = 0 ; y < data.length ; y++){
            //内层控制每次的排序控制
            for (int x = 0 ; x <data.length-1 ; x++) {
                if (data[x] > data[x+1]){
                    int t = data[x];
                    data[x] = data[x+1];
                    data[x+1] = t;
                }
            }
        }

        get(data);
    }
    //输出数据的方法
    public static void get(int temp[] ){
        for (int i = 0 ; i < temp.length ; i++) {
            System.out.print(temp[i]+ "、");
        }
        System.out.println();
    }
}

　　改善设计：主方法设计上是作为程序的起点，既然是起点，所有的代码编写一定尽量简单，那么我们可以单独定义方法进行复杂操作。

 public class 数组的排序 {
     public static void main(String[] args) {
         int data[] = new int[]{2,1,9,0,5,3,7,6,8};
         get(data);
         sort(data);
         get(data);
     }
     //输出数据的方法
     public static void get(int temp[] ){
         for (int i = 0 ; i < temp.length ; i++) {
             System.out.print(temp[i]+ "、");
         }
         System.out.println();
     }
     //负责排序的方法
     public static void sort(int s[]){
         //外层控制排序的总次数
         for (int y = 0 ; y < s.length ; y++){
             //内层控制每次的排序控制
             for (int x = 0 ; x <s.length-1 ; x++) {
                 if (s[x] > s[x+1]){
                     int t = s[x];
                     s[x] = s[x+1];
                     s[x+1] = t;
                 }
             }
         }
     }
 }

2.数组转置

• 　　原始数据   ：  1 、 2 、3 、4 、5 、6 、7 、8  ；
• 转置后数据 ： 8 、 7 、6 、5 、4 、3 、2 、1   ；

要实现转置的操作有两个思路：

　　　　定义一个新的数组，而后将原始数组按照排序的方式插入到新的数组之中，随后改变原始数组的引用；

 public class 数组的排序 {
     public static void main(String[] args) {
         int data[] = new int[]{1,2,3,4,5,6,7,8};
         //首先定义一个新的数组，长度与原始数组一致
         int temp[] = new int[data.length];
         int foot = data.length -1 ;
         //对于新的数组按照索引由小到大的顺序循环
         for (int i = 0 ; i < temp.length ; i++) {
             temp[i] = data[foot];
             foot--;
         }
         data = temp; //data转向temp ，而data的原始数据就成为了垃圾
         get(data);

     }
     //输出数据的方法
     public static void get(int temp[] ){
         for (int i = 0 ; i < temp.length ; i++) {
             System.out.print(temp[i]+ "、");
         }
         System.out.println();
     }
 }

　　　　虽然上面的算法实现了转置的操作，但是代码里会产生垃圾 data的原始数据就是垃圾。

• 　　利用算法，再一个数组上直接完成转置操作
  • 　　原始数据：  1 、 2 、3 、4 、5 、6 、7 、8  ；     //转换次数：数组长度 ÷ 2  记住不管数组是技术还是偶数转置次数一样
  • 第一次转置： 8 、 2 、3 、4 、5 、6 、7 、1  ；
  • 第二次转置 ： 8 、 7 、3 、4 、5 、6 、2 、1  ；
  • 第三次转置： 8 、 7 、6 、4 、5 、3 、2 、1   ；
  • 第四次转置 ： 8 、 7 、6 、5 、4 、3 、2 、1    ；

转置：

 public class 数组的转置 {
     public static void main(String[] args) {
         int data[] = new int[]{1,2,3,4,5,6,7,8,9};
         reverse(data);
         get(data);
     }
     //负责转置操作
     public static void reverse(int arr[]){
         int start = 0;
         int end = arr.length -1;
         for (int i = 0; i < arr.length/2 ; i++) {
             int temp = arr[start];
             arr[start] = arr[end];
             arr[end] = temp;
             start ++;
             end --;
         }
     }
     //此方法负责输出
     public static void get(int temp[]){
         for(int i = 0 ; i < temp.length ; i++) {
             System.out.print(temp [i]+"、");
         }
         System.out.println();
     }
 }