package com.itheima;

import java.util.Arrays;

/**
*
* 【黑马程序员训练营基础测试】
*  2、 请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。
*
* 第一种：Arrays类里提供的由小到大排序
* 第二种：选择排序
* 第三种：冒泡排序
*
*/
public class Test2 {
        
                public static void main(String[] args) {
                        int[] arr = new int[] { 12, 31, 53, 11, 7, 101 };
                        
                        //打印原数组
                        System.out.println("原数组为:");
                        print(arr);
                        
                        // 方法一：调用Arrays里的方法由小到大排序：
                        System.out.println("方法一：调用Arrays里方法由小到大排序：");
                        Arrays.sort(arr);
                        print(arr);
                        
                        //方法二： 调用自定义的选择排序方法：
                        System.out.println("方法二：选择排序");
                        selectSort(arr);
                        print(arr);
                        
                                       
                        //方法三： 调用自定义的冒泡排序方法：
                        System.out.println("方法三：冒泡排序");
                        bubbleSort(arr);
                        print(arr);
                        
                }
               

                /*
                 * 选择排序：外循环确定比较开始的索引，每一次循环结束，最小索引对应的是该次循环的最小值。
                 * 从外循环确定的比较开始的位置开始，依次与其他元素比较，只要开始位置的值大于其他位置的值，交换元素的位置。
                 *
                 */
               
                public static void selectSort(int[] arr) {
                        for (int x = 0; x < arr.length - 1; x++) {
                                for (int y = x + 1; y < arr.length; y++) {
                                        if (arr[x] > arr[y]) {
//                                                int temp =arr[x];
//                                                arr[x]=arr[y];
//                                                arr[y]=temp;
                                                
                                                //调用swap方法交换数组中元素的位置
                                                swap(arr,x,y);
                                        }
                                }
                        }
                }
        
        
                /*定义冒泡排序:外循环确定每次循环的结束位置，每一次循环结束，最大索引值对应的是该次循环的最大值。
                 * 内循环的相邻元素进行比较，较大的元素在较大的索引值处,否则交换位置。
                 * 每次循环都能保证该次循环的最大值在最大索引的位置
                 *
                 */
               
        public static void bubbleSort(int[] arr) {
                        for (int x = arr.length-1; x >0; x--) {
                                for (int y = 0; y < x; y++) {
                                        if (arr[y] > arr[y + 1]) {
                                                int temp = arr[y];
                                                arr[y]= arr[y+1];
                                                arr[y+1]=temp;
                                        }
                                }
                        }
                }
        
        //定义swap方法，交换两个数组的位置。
        private static void swap(int[] array, int i, int j) {
                        int temp = array;
                        array = array[j];
                        array[j] = temp;
                        
                }
               
        //定义方法print，将数组输出在控制台。
                public static void print(int[] arr) {
                        System.out.print("遍历的数组为：[");
                        for (int x = 0; x < arr.length; x++) {
                                if (x < arr.length - 1)
                                        System.out.print(arr[x] + ",");
                                else
                                        System.out.println(arr[x] + "]");
                        }
                }

}

package com.itheima;

import java.util.Arrays;

/**
*
* 【黑马程序员训练营基础测试】
*  2、 请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。
*
* 第一种：Arrays类里提供的由小到大排序
* 第二种：选择排序
* 第三种：冒泡排序
*
*/
public class Test2 {
        
                public static void main(String[] args) {
                        int[] arr = new int[] { 12, 31, 53, 11, 7, 101 };
                        
                        //打印原数组
                        System.out.println("原数组为:");
                        print(arr);
                        
                        // 方法一：调用Arrays里的方法由小到大排序：
                        System.out.println("方法一：调用Arrays里方法由小到大排序：");
                        Arrays.sort(arr);
                        print(arr);
                        
                        //方法二： 调用自定义的选择排序方法：
                        System.out.println("方法二：选择排序");
                        selectSort(arr);
                        print(arr);
                        
                                       
                        //方法三： 调用自定义的冒泡排序方法：
                        System.out.println("方法三：冒泡排序");
                        bubbleSort(arr);
                        print(arr);
                        
                }
               

                /*
                 * 选择排序：外循环确定比较开始的索引，每一次循环结束，最小索引对应的是该次循环的最小值。
                 * 从外循环确定的比较开始的位置开始，依次与其他元素比较，只要开始位置的值大于其他位置的值，交换元素的位置。
                 *
                 */
               
                public static void selectSort(int[] arr) {
                        for (int x = 0; x < arr.length - 1; x++) {
                                for (int y = x + 1; y < arr.length; y++) {
                                        if (arr[x] > arr[y]) {
//                                                int temp =arr[x];
//                                                arr[x]=arr[y];
//                                                arr[y]=temp;
                                                
                                                //调用swap方法交换数组中元素的位置
                                                swap(arr,x,y);
                                        }
                                }
                        }
                }
        
        
                /*定义冒泡排序:外循环确定每次循环的结束位置，每一次循环结束，最大索引值对应的是该次循环的最大值。
                 * 内循环的相邻元素进行比较，较大的元素在较大的索引值处,否则交换位置。
                 * 每次循环都能保证该次循环的最大值在最大索引的位置
                 *
                 */
               
        public static void bubbleSort(int[] arr) {
                        for (int x = arr.length-1; x >0; x--) {
                                for (int y = 0; y < x; y++) {
                                        if (arr[y] > arr[y + 1]) {
                                                int temp = arr[y];
                                                arr[y]= arr[y+1];
                                                arr[y+1]=temp;
                                        }
                                }
                        }
                }
        
        //定义swap方法，交换两个数组的位置。
        private static void swap(int[] array, int i, int j) {
                        int temp = array;
                        array = array[j];
                        array[j] = temp;
                        
                }
               
        //定义方法print，将数组输出在控制台。
                public static void print(int[] arr) {
                        System.out.print("遍历的数组为：[");
                        for (int x = 0; x < arr.length; x++) {
                                if (x < arr.length - 1)
                                        System.out.print(arr[x] + ",");
                                else
                                        System.out.println(arr[x] + "]");
                        }
                }

}