第一种方法
- public static void maoPao() {
- int[] arr = { 6, 3, 8, 2, 9, 1 };
- System.out.println("排序前数组为:");
- for (int num : arr) {
- System.out.print(num + " ");
- }
- for (int i = 0; i <arr.length - 1; i++) {// 外层循环控制排序趟数 , 因为 6 个数, 只需要循环 5 次就行. 所以减 1
- for (int j = 0; j < arr.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
- // 外圈循环: arr.length - 1
- // 例如长度为 6; 说明是 6 个数进行比较, 因此只需要比较 5 次就可以了.
- // 内圈循环: arr.length - 1 - i
- // 减 1: 因为下面是 (arr[j]> arr[j + 1] 比较, 如果不减 1,
- // 当 j 最大的时候, arr[j + 1] 就会报错, 超出数组长度
- // 减 i : 例如当 i = 1 时, 说明第一次循环结束, 刚开始第二次外循环,
- // 经过第一次循环之后, 最后一个数就是最大的,
- // 没有必要每次循环都在此进行和最后一个最大的比较的.
- // 比较原理
- // 相邻的两两比较.
- // 例如: 内循环开始时, j=0;arr[j] 和 arr[j+1] 就是
- //arr[0] 和 arr[1] 比较, 如果 arr[0] 大于 arr[1] 就让两个数的值互换,
- //arr[0] 获得数值较小值, arr[1] 获得较大的值. 当内循环开始第二次, j=1,
- //arr[0] 就不再比较, arr[1] 和 arr[2]
- // 比较, 直到最大值到最后一位. 然后再次开始外循环, 获得第二小的最大值. 直到结束.
- if (arr[j]> arr[j + 1]) {
- int temp = arr[j];
- arr[j] = arr[j + 1];
- arr[j + 1] = temp;
- }
- }
- }
- System.out.println();
- System.out.println("排序后的数组为:");
- for (int num : arr) {
- System.out.print(num + " ");
- }
- }
第二种方法
- public static void maoPao2() {
- int[] unsorted = { 6, 3, 8, 2, 9, 1 };
- System.out.println("排序前数组为:");
- for (int num : unsorted) {
- System.out.print(num + " ");
- }
- System.out.println(unsorted.length);
- for (int i = 0; i <unsorted.length - 1; i++) {
- // 当 j=i; 说明先比较第一个, 第一个比较完成之后, 后面的循环就不在比较了.
- // 当 i=0;unsorted[i] 就是 unsorted[0], 说明这是第一次循环,
- // 把 unsorted[0] 和 unsorted[j](j 从 1 一直变化到最大值)
- // 期间 unsorted[0] 依次和它们比较, 如果 unsorted[0] 大于其中一个就相互换值
- // , 直到 unsorted[0] 是最小的
- // 当第二次循环开始的时候, i=1; 内循环直接放弃 unsorted[0] 的比较,
- // 直接从 unsorted[1] 开始和 unsorted[j] 开始进行比较, 然后确定第二小的值
- // 直到循环结束, 从小到大
- for (int j = i; j < unsorted.length; j++) {
- if (unsorted[i]> unsorted[j+1]) {
- int temp = unsorted[i];
- unsorted[i] = unsorted[j+1];
- unsorted[j+1] = temp;
- }
- }
- }
- System.out.println();
- System.out.println("排序后的数组为:");
- for (int num : unsorted) {
- System.out.print(num + " ");
- }
- }
第三种方法
- // 前面两个方法都是先获得最大的数放在最后, 然后获得第二小的数.
- // 这个方法是先获得最小的数, 然后依次获得第二小的数.
- private void core(int[] array) {
- int arrayLength = array.length;
- for (int i = 0; i <arrayLength; i++) {
- for (int j = arrayLength - 2; j>= i; j--) {
- if (array[j]> array[j + 1]) {
- ArrayUtils.swap(array, j, j + 1);
- }
- }
- }
- }
第四种方法 (双向冒泡排序)
说明: 从一个数组的开头和结尾同时开始排序, 当到中间时结束.
同时获得最大的数和最小的数, 分别放在开始和结尾. 然后获得第二
小的数和第二大的数放在第二位和倒数第二位, 直到中间碰头.
- private void core(int[] array) {
- int arrayLength = array.length;
- int preIndex = 0;
- int backIndex = arrayLength - 1;
- while(preIndex <backIndex) {
- preSort(array, arrayLength, preIndex);
- preIndex++;
- if (preIndex>= backIndex) {
- break;
- }
- backSort(array, backIndex);
- backIndex--;
- }
- }
- // 从前向后排序
- private void preSort(int[] array, int length, int preIndex) {
- for (int i = preIndex + 1; i <length; i++) {
- if (array[preIndex]> array[i]) {
- ArrayUtils.swap(array, preIndex, i);
- }
- }
- }
- // 从后向前排序
- private void backSort(int[] array, int backIndex) {
- for (int i = backIndex - 1; i>= 0; i--) {
- if (array[i]> array[backIndex]) {
- ArrayUtils.swap(array, i, backIndex);
- }
- }
- }
来源: http://www.bubuko.com/infodetail-2705202.html