java中的排序与二维数组_java二维数组排序-优快云博客

通过数组中的相邻元素两两比较，大的放右边，比较完一轮，最右边可确认为所有元素中的最大值，然后又从第一个元素开始两两比较，确定了几个元素，比较的次数也减少几次

比如第一轮，确定一个元素比较了10次，第二轮的话只需要比较9次就行，因为最后那个是所有中的最大的。第三轮 8次因为有两个元素已经确定了

由此可知需要两个for循环，外围for循环控制轮数，内部for循环控制每轮比较的次数

案例：

//冒泡排序：相邻元素两两比较；大的放右边，比较完一轮则确定最右边的数最大；
//以此类推，共比较(长度-1)轮
//分析：1.画图分析排序规则    2.编写代码分析规律
int[] a = {3,1,5,2};
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 t = a[j];
            a[j]  = a[j+1];
            a[j+1]  = t;
        }
    }
    System.out.println("第"+(i+1)+"轮："+Arrays.toString(a));
}

3.选择排序：

假定第一个元素最小，然后与后面的元素依此比较，如果后面的元素的值比第一个元素还小，那么让他们的值进行交换，经过一轮比较之后第一个元素的值是最小的，然后从第二个开始比较第二个后面的那些元素

案例:

int[] a = {3,1,5,2};
for(int i=0;i<a.length-1;i++) {//外层比较轮数
    for(int j=i+1;j<a.length;j++) { //内层确定次数
        if(a[i]>a[j]) {//每次的比较都是a[i]和后面的比
            int t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
    System.out.println("第"+(i+1)+"轮："+Arrays.toString(a)); //每轮的打印
}

4.插入排序

案例:

//第一轮先比较前两个元素；第二轮插入一个元素与第一轮最大的比；
//如果比最大的还要大，直接排下来；否则再和前面的比，以此类推，共比较(长度-1)轮
int[] a = {3,1,5,2,8,4,7,6};
for(int i=0;i<a.length-1;i++) { //比较轮数
    for(int j=i+1;j>0;j--) { //倒着进行比较
        if(a[j]<a[j-1]){ //如果后一个比前一个小，则交换
            int t = a[j];
            a[j] = a[j-1];
            a[j-1]= t; 
        }else { //如果插入的元素，比排好序最大的还要大则退出内层循环
            break;
        }
    }
    System.out.println(Arrays.toString(a));
}

5.系统提供的排序

public class Test5 {
	public static void main(String[] args) {
		//系统提供的排序的函数：Arrays.sort
		int[] a = {1,3,5,2};
		//Arrays.sort(a); //数组排序-系统提供
		System.out.println("排序后："+Arrays.toString(a));
	}
}

二、二维数组

概述：一维数组的一维数组，也就是可以看成一维数组的元素又是一维数组

（二维数组里面的元素是一维数组）

二维数组的定义，可以看成是行长度和列长度的空间定义

在操作时，可看成是行下标和列下标的操作；

二维数组的基本操作:

通过二维数组的长度进行循环来得到一维数组的里面的元素

//定义一个整数类型的二维数组
//和一维数组类似，创建空间，有默认值：int-0 String-null double-0.0,,,
int[][] a = new int[2][3];  //创建2行3列的二维数组空间---默认值为0
a[0][0] = 60;
a[0][1] = 30;
a[1][0] = 50;
//a[2][0] = 40; //下标越界-行下标越界
//a[0][3] = 90; //下标越界-列下标越界

System.out.println("行长度："+a.length);
System.out.println("列长度："+a[0].length);

for(int i=0;i<a.length;i++) {  //外层代表行
    for(int j=0;j<a[i].length;j++) { //内层代表列
        System.out.print(a[i][j]+"   ");
    }
    System.out.println();  //回车
}

二维数组的创建方式：

//二维数组创建方式：
//--------动态赋值----------
int[][] a;
a = new int[2][3];  //1.先声明，再创建空间

int[][] b = new int[2][3]; //2.声明的同时创建空间

int[][] c = new int[2][];  //3.先创建行空间，再创建列空间
c[0] = new int[]{1,3,5};
c[1] = new int[]{2,4,6};

//--------静态赋值----------
int[][] d = {{1,3,5},{2,4,6}}; //2行3列的二维数组

不规则列:

二维数组中，行是固定的，但是列可以不规则；不规则列相对用得特别少，因为赋值和取值较麻烦，可读性也会更差

案例:

//不规则列的二维数组：
//1.先创建行空间的方式
/*
	int[][] a = new int[2][]; //确定行长度
	a[0]=new int[]{1,3};  //第一行2列
	a[1]=new int[]{2,4,6}; //第二行3列
*/

//2.静态赋值的方式
int[][] a = {{1,2},{3,5,9}};
//a[0][2] = 5;  //下标越界

//循环遍历取值：
for(int i=0;i<a.length;i++) {
    for(int j=0;j<a[i].length;j++) {
        System.out.print(a[i][j]+" ");
    }
    System.out.println();  //回车
}

三、杨辉三角：

第一列为1 每一行的最后一个元素为1

其余元素为它上一个元素加它上一个元素左侧元素的和

案例:

public static void main(String[] args) {
    //杨辉三角:
    /*
		 *   1
		 *   1  1
		 *   1  2  1
		 *   1  3  3   1
		 *   1  4  6   4   1
		 *   1  5  10  10  5  1  
		 * 
		 * 规则：行和列结构
		 * 第1列都为1，行列相等位置为1；
		 * 其余的当前位置=上一个+上一个左侧 
		 * 
		 * */
    System.out.println("请输入杨辉三角的长度：");
    Scanner sc = new Scanner(System.in);
    int length = sc.nextInt();
    int[][] a = new int[length][length];  //初始都为0
    yangHui(a);  //杨辉三角的赋值
    print(a);    //打印
}

private static void print(int[][] a) {
    for(int i=0;i<a.length;i++) {
        for(int j=0;j<=i;j++) {
            System.out.print(a[i][j]+" ");
        }
        System.out.println();  //回车
    }
}

private static void yangHui(int[][] a) {
    for(int i=0;i<a.length;i++) {
        for(int j=0;j<=i;j++) { //直角三角形的循环次数
            if(j==0||i==j) {//第1列和i,j相等，则为1
                a[i][j]=1;
            }else {
                //当前位置=上一个+上一个左边
                a[i][j]=a[i-1][j]+a[i-1][j-1];
            }
        }
    }

}