数组排序

数组排序(冒泡/选择/插入)

在未了解掌握数据结构之前，我们现在可以用数组写出三种排序。

一、冒泡排序

1.1算法思想：

在未排序的一组数中,重复访问未排序的元素,从第一个未排序元素开始,比较相邻两个元素大小,若上一元素大于(小于)下一元素,对调两元素位置,直至每一趟不能再交换(即排序完成)。

1.2算法原理:

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

1.3代码实现：

package Test.arraysort;
import java.util.Arrays;
public class bubbleSort {
    public static void main(String[] args) {
        
        /*冒泡排序
            2 0 1 5 3 8
        一: 0 1 2 5 3 8
        二  0 1 2 3 5 8
         */
		System.out.println("未排序:"+Arrays.toString(a));
        int [] a={2,0,1,5,3,8};//声明初始化数组
        for(int i=0;i<a.length-1;i++){//从第0个元素开始到第length-1个为止,相邻两个元素依次比较
            for(int j=0;j<a.length-1-i;j++){//外层每循环1次,下一次交换次数少比上次1次
                if(a[j]>a[j+1]){//前面元素比后面大,交换两元素
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        System.out.println("排序后:"+Arrays.toString(a));
    }
}

运行结果:

二、选择排序(直接选择)

2.1算法思想:

从未排序第一个元素开始到最后一个中,选出最小(大)的元素,将其与第一个未排序元素交换,交换后第一元素变为已排序元素,第二元素为未排序第一个元素,继续重复这个步骤,直至排序完成

2.2算法原理

1. 从a[0]开始遍历至[a.length-1],找到最大元素,将它与a[0]交换,下次起始位置+1

2. 从a[1]开始遍历至[a.length-1],找打最大元素,将它与a[1]交换,下次起始位置+1

3. 重复这个步骤,直至最后两个数据完成交换,排序完成

2.3代码实现

package Test.arraysort;
import java.util.Arrays;
public class selectSort {
    public static void main(String[] args) {
        int[] a={3,1,5,0,6};
        System.out.println("未排序:"+Arrays.toString(a));
        for (int i = 0; i < a.length-1; i++) {//从第i个下标开始遍历
            for (int j = i+1; j < a.length; j++) {
                //从第i+1个下标开始遍历,i+1最大为a.length,访问数组会越界,将i设为小于a.length-1
                if(a[j]<a[i]){
                   change(a,i,j);//若未排序的大于已排序的末元素,交换两值
                }
            }
        }
        System.out.println("已排序:"+Arrays.toString(a));
    }
    public static void change(int[] arr,int a,int b){
        int temp=arr[a];
        arr[a]=arr[b];
        arr[b]=temp;
    }
}

运行结果:

上面的代码虽然实现了排序功能,但当未排序元素中,小于已排序末元素的有多个时,会交换多次,执行多行代码

我们可以将其改一改,使其少执行几行代码

package Test.arraysort;
import java.util.Arrays;
public class selectSort {
    public static void main(String[] args) {
        int[] a={3,1,5,0,6};
        System.out.println("未排序:"+Arrays.toString(a));
        for (int i = 0; i < a.length-1; i++) {//已排序元素
            int minIndex=i;//将最小值索引设为i,i为已排序末元素
            for (int j = i+1; j <a.length; j++) {//未排序元素
                if(a[j]<a[i]){
                    minIndex=j;//若未排序小于已排序末元素,将其索引赋给最小值索引
                }
            }
            //当每次找到最小元素后再交换,相比于遇到一个小于已排序末元素的就交换,减少了执行代码次数
            int t=a[i];
            a[i]=a[minIndex];
            a[minIndex]=t;     //在未排序元素中找到最小元素后,将它与已排序末元素交换
        }
        System.out.println("已排序:"+Arrays.toString(a));
    }
}

运行结果:

三、插入排序

3.1算法思想

在未排序元素中,将元素在已排序元素中找到合适位置,依次插入到已排序元素中,使得每次插入后,已排序元素都是有序的,重复这样的步骤,直到排序完毕

3.2算法原理

1. 将第一个元素设为已排序的元素,从未排序的最后一个元素(待排元素)往前遍历
2. 若待排元素与前面的元素依次比较,

3.3代码实现

package JavaSE.JavaArray.Sort;

import java.util.Arrays;

/*
        插入排序
        从第二个位置开始向前比较,到第0个,完成一次循环
        从后往前,将后面的数与前面所有数比较,若前面大,记录,一趟完成后,插入
 */
public class insertSort {
    public static void main(String[] args) {
        int[] a = {5, 4, 2, 1, 3};
        int current=0;//当前要排序的元素
        for (int i = 0; i < a.length-1; i++) {
            current=a[i+1];         //a[i+1]max=a[length],外循环需length-1
            int preIndex=i;         //当前所比较的位置
            for(;preIndex>=0&&current<a[preIndex];preIndex--){
                //当preIndex==0时,preIndex--==-1 结束循环
                a[preIndex+1]=a[preIndex];
            }
            a[preIndex+1]=current;
        }
        System.out.println(Arrays.toString(a));
    }
}

运行结果: