java数组练习2

/*

• 数据结构简析
• 1数据与数据的逻辑关系分类：
• 1.1集合
• 1.2一对一关系（数组，链表）
• 1.3,一对多（二叉树，三叉树）
• 1.4，多对多（人际关系图）
• 2二数据的储存结构
• 2.1一对一： 线性表，分为顺序表（例如数组)，栈（先进后出），队列（先进先出）），链表
• 2.2一对多：树形结构，二叉树，三叉树，b+树等
• 2.3多对多：图形结构，分有向图与无向图
• 基本算法
• 1，排序算法
• 2，检索算法
• 数组的常见算法
• 1，数组元素的赋值（杨辉三角，回型数组）
• 2，求数值型数组元素的极值，平均数，总和等
• 3,数组的复制，反转，查找（线性查找，二分法查找）
• 4，数组元素的排序算法
  */

package com.atguigu.contact;
import java.util.*;
public class Array3 {
     public static void main(String[] args) {
    	 Scanner scan = new Scanner(System.in);
    	 //练习1，求二维数组所有元素的和
    	 int[][] array = new int[][] {{3,-5,6},{2,8},{9,-2,5,7}};
    	 int sum = 0;
    	 for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				sum +=  array[i][j];
			}
		}
    	 System.out.println("二维数组的所有元素和是" + sum);
    	 
    	 /*练习2，
    	  * int[] x,y [];//此时表示声明x为一维数组，y为二维数组
    	  * 因为 int[] a,b = int[] a 与 int[] b ,也就是 int[] x, int[] y[]
    	  * 在给x与y赋值后，以下选项可以编译通过的是
    	  * 1，x[0] = y; // no
    	  * 2,y[0] = x; // yes
    	  * 3,y[0][0] = x;// no
    	  * 4,x[0][0] = y,// no
    	  * 5,y[0][0] = x[0];// yes
    	  * 6,x = y//no
    	  * 数组赋值需要满足相同类型或者可以自动类型提升
    	  */
    	 
    	 //练习三，使用二维数组打印一个指定行数杨辉三角
		/*
		 * 1，第一行一个元素，第n行n个元素 
		 * 2，每一行的第一个和最后一个是1 
		 * 3，从第三行开始，对于非第一个元素和最后一个元素有
		 * yanghui[i][j]=yanghui[i-1][j-1] + yanghui[i-1][j]
		 */
    	 //思路，对二维数组声明赋值后打印
    	 
    	 //输入行数
    	 System.out.println("请输入要打印的杨辉三角行数");
    	 int line = scan.nextInt();
    	 int[][] array1 = new int[line][];//动态声明二维数组行数
    	 //声明赋值二维数组
    	 for (int i = 0; i < array1.length; i++) {
			array1[i] = new int[i+1];//声明每行列数
			array1[i][0] = 1;//每行第一个元素是1
			array1[i][i] = 1;//每行最后一个元素是1
			//可以写成连续赋值的形式array1[i][0] = array[i][i] = 1;
			//
			for (int j = 0; j < array1[i].length; j++) {
				if(j > 0 && j < i) {
					array1[i][j]=array1[i-1][j-1] + array1[i-1][j];//每行其他元素满足杨辉三角要求
				}
			}
			/*第二种写法，if在外层
			 * if(i > 1){
			 *   for(j = 1;j < array[i].length - 1;j++){
			 *   array1[i][j]=array1[i-1][j-1] + array1[i-1][j];
			 *   }
			 * }
			 */
		 }
        //遍历输出杨辉三角
    	 for (int i = 0; i < array1.length; i++) {
			for (int j = 0; j < array1[i].length; j++) {

				System.out.print(array1[i][j] + " ");
			}
			System.out.println();
		}
    	 
    	 //创建一个长度为15的int型一维数组，要求数组的元素值在1-30之间，随机赋值，要求各个元素不同
    	 //方式一，有重复值则通过i--进行当前循环
    	 int[] array2 = new int[15];//创建动态数组，长度15
    	 for (int i = 0; i < array2.length; i++) {
    		 array2[i] = (int)(Math.random() * 30 + 1);//元素赋值，将随机数范围[0,1）扩展至[0,31)，随机数为浮点型，需要强转为int型
    		 for (int j = 0; j < i; j++) {
    		 if(array2[i] == array2[j]) {//判断是否重复
    	     i--;//如果重复则重新开始本次循环
    	     break; //如果重复结束当前循环    
    		 }
    	   }
		}
    	for (int i = 0; i < array2.length; i++) {
    		System.out.print(array2[i] + " ");//输出所有数组元素
		}
    	System.out.println("\n");
    	//方式二，使用布尔型变量判断
    	int[] array3 = new int[10];
   	 for (int i = 0; i < array3.length; i++) {
   		 array3[i] = (int)(Math.random() * 30 + 1);
   		boolean mark = false;//赋值mark为假
   		for(;;) {
   			for (int j = 0; j < i; j++) {
				if(array3[i] == array3[j]) {
					mark = true;
					break;//如果有重复元素则mark赋值为真，且停止内层循环
				}
			}  		
   	        if(mark){//如果mark为真则重新赋值
   	        	array3[i] = (int)(Math.random() * 30 + 1);
   	        	mark = false;//重置mark标记，为下一次比较准备
   	        	continue;//结束当前次循环，进入下一轮判断       	
   	        }	
   	        break;//当mark为false时，为无限循环加上中断语句
   	     }
   	 }
		
   	for (int i = 0; i < array3.length; i++) {
   		System.out.print(array3[i] + " ");
		}//输出所有数组元素
   	    System.out.println("\n");
   	    
   	    //打印回形数组
   	    //方法一
   	    System.out.println("请输入回形数组阵的大小");
   	    int length = scan.nextInt();
   	    int[][] array4 = new int[length][length];
   	    int s = length *length;//s为二维数组元素的总数
   	    int i,j;
   	    i = j = 0;
   	    int k =1;//K=1向右，K=2向下，K=3向左，K=4向上,设定4种情况
   	    for(int m = 1;m <= s;m++) {//遍历数组元素，依次按照设定角标顺序赋值
   	    	if(k == 1) {
   	    		if(j < length && array4[i][j] == 0) {
   	    			array4[i][j++] = m;//第一行1234----length向右赋值
   	    		}else {
   	    			k = 2;//赋值完后转到最后一列向下赋值
   	    			i++;
   	    			j--;
   	    			m--;
   	    		}
   	    	}else if(k == 2) {
   	    		if(i < length && array4[i][j] == 0) {
   	    			array4[i++][j] = m;//最后一列向下赋值
   	    		}else {
   	    			k = 3;//赋值完后转到最后一行向左赋值
   	    			i--;
   	    			j--;
   	    			m--;
   	    		}
   	    		
   	    	}else if(k == 3) {
   	    		if(j >= 0 && array4[i][j] == 0) {
   	    			array4[i][j--] = m;//最后一行向左赋值
   	    		}else {
   	    			k = 4;//赋值完后转到第一列向上赋值
   	    			i--;
   	    			j++;
   	    			m--;
   	    		}
   	    	}else if(k == 4) {
   	    		if(i >= 0 && array4[i][j] == 0) {
   	    			array4[i--][j] = m;//第一列向上赋值
   	    		}else {
   	    			k = 1;//赋值完后转到第二行向右赋值，开始新的循环，直到所有数组元素都不等于初始值0 ，数组赋值完成
	    			i++;
	    			j++;
	    			m--;
   	    	    }
   	    	    }
   	    }
   	    for (int n = 0; n < array4.length; n++) {
   	    	for (int l = 0; l < array4[n].length; l++) {
   	    		System.out.print(array4[n][l] + " ");
			}   
   	        System.out.println();
		}
   	       
   	    //方法二
   	    System.out.println("请输入回形数组阵的大小");
	    int length2 = scan.nextInt();
	    int[][] array5 = new int[length2][length2];
	    int count = 0;//要输入的数据
	    int maxX = length2 - 1;//二维数组x轴的最大下标
	    int maxY = length2 - 1;//二维数组y轴的最大下标
	    int minX = 0;////二维数组x轴的最小下标
	    int minY = 0;//二维数组y轴的最小下标
	    while(minX <= maxX) {
	         for (int x = minX; x <= maxX; x++) {
				array5[minY][x] = ++count;
			 }
	    	 minY++;
	    	 for (int y = minY; y <= maxY; y++) {
					array5[y][maxX] = ++count;
				 }
		     maxX--;
		     for (int x = maxX; x >= minX; x--) {
					array5[maxY][x] = ++count;
				 }
		     maxY--;
		     for (int y = maxY; y >= minY; y--) {
					array5[y][minX] = ++count;
				 }
			 minX++;	
	    }
	       
	    for (int n1 = 0; n1 < array5.length; n1++) {
   	    	for (int l1 = 0; l1 < array5[n1].length; l1++) {
   	    		System.out.print(array5[n1][l1] + " ");
			}   
   	        System.out.println();
		}
 	 
	    //定义一个int型一维数组，包含n个元素，分别赋值随机整数
	    //求出所有元素的最大值，最小值，总和，平均值，并输出
	    System.out.println("请输入随机数组的长度");
	    int length3 = scan.nextInt();
	    int[] array6 = new int[length3];
	    for (int l = 0; l < array6.length; l++) {
			array6[l] = (int)(Math.random() * 99 + 1);//元素范围1-99
		}
	    int maxValue = array6[0];
	    int minValue = array6[0];	    
	    int sumValue = array6[0];
	    for (int l = 0; l < array6.length; l++) {
			if(maxValue <= array6[l]) {
				maxValue = array6[l];
			}
			if(minValue >= array6[l]) {
			   minValue = array6[l];
			}
			sumValue += array6[l];
		}
	    System.out.println("随机数组为");
	    for (int l = 0; l < array6.length; l++) {
	    	System.out.print(array6[l] + " ");
		}
	    System.out.println();
	    System.out.println("最大值为" + maxValue);
	    System.out.println("最小值为" + minValue);
	    System.out.println("总和为" + sumValue);
	    double averageValue = sumValue / length3;
	    System.out.println("平均值为" + averageValue);
	    
	    //数组的复制
	    int[] array7,array8;
	    array7 = new int[] {2,3,5,7,11,13,17,19,23,29};
	    //查看array7中元素
	    for (int l = 0; l < array7.length; l++) {
	    	System.out.print(array7[l] + " ");
		}
	    System.out.println();
	    
	    array8 = array7;//把array7首地址值赋值给array8，此时堆空间中实际只有一个数组。
	    //数组复制不能用上面的方式。
	    //
	    int[] array9 = new int[array7.length];
	    for (int l = 0;l < array9.length;l++) {
			array9[l] = array7[l];
		}
	    //查看array8中元素
	    for (int l = 0; l < array8.length; l++) {
	    	System.out.print(array8[l] + " ");
		}
	    System.out.println();
	    //修改并输出array8中元素
	    for (int l = 0; l < array8.length; l++) {
	    	if(l % 2 == 0 ){
	    		array8[l] = l;
	    	}
	    	System.out.print(array8[l] + " ");
		}
	    System.out.println();
	    //查看array7中元素
	    for (int l = 0; l < array7.length; l++) {
	    	System.out.print(array7[l] + " ");
		}
	    System.out.println();//修改array8后，array7元素也会被改变
	    //查看array9元素	   
	    for (int l = 0;l < array9.length;l++) {
	    	System.out.print(array9[l] + " ");	    	
		}//与原array7数据相同
	    System.out.println();
	    
	    //数组的反转,通过临时变量遍历交换赋值
	    //
	    String[] array10 = new String[] {"AA","BB","CC","DD","EE","FF","GG"};
	    for (int l = 0;l < array10.length;l++) {
	    	System.out.print(array10[l] + " ");	    	
		}
	    System.out.println();
	    //方法一
	    String temp ="";//创建临时变量temp，可以放在for循环内
	    for (int l = 0; l < array10.length/2; l++) {
			temp = array10[l];
			array10[l] = array10[array10.length - l - 1];
			array10[array10.length - l - 1] = temp;
		}
	    for (int l = 0;l < array10.length;l++) {
	    	System.out.print(array10[l] + " ");	    	
		}
	    System.out.println();
	    
	    //方法二
	    for (int l = 0, p = array10.length - 1; l < p; l++,p--) {
			String temp1 = array10[l];
			array10[l] = array10[p];
			array10[p] = temp1;
		}
	    
	    for (int l = 0;l < array10.length;l++) {
	    	System.out.print(array10[l] + " ");	    	
		}
	    System.out.println();
	    
	    
	    //数组元素的 查找(基本方式线性查找，较常用的二分法查找)
	    System.out.println("请输入要查找的元素");
	    boolean mark1 = true;
	    String ask = scan.next();
	    for (int l = 0;l < array10.length;l++) {	
	            if(ask.equals(array10[l])){
				System.out.println(ask +"在数组角标为" + l + "的位置");
				mark1 = false;
				break;
			}
		}
	    if(mark1) {
	    	System.out.println("数组中不存在元素" + ask);
	    }
	    
	    //二分法查找，较线性查找快
	    //每次从数组中间开始查找一半，左半边没有查找右半边，右半边再从中间开始找
	    //二分法使用的前提是所要查找的数组有序
	    System.out.println("请输入随机数组的长度");
	    int length4 = scan.nextInt();
	    int[] array11 = new int[length4];
	    for (int l = 0; l < array11.length; l++) {
	    	array11[l] = (int)(Math.random() * 201 - 100);//随机数组范围【-100,100】		    
	    }	    
	    //先排序，将数组变为有序数组
	    for (int l = 0; l < array11.length - 1; l++) {
			for (int l2 = 0; l2 < array11.length - 1 -l; l2++) {
				if(array11[l2] > array11[l2 + 1]) {
					int temp1 = array11[l2];
					array11[l2] = array11[l2 + 1];
					array11[l2 + 1] = temp1;
				}
			}
		}
	    for (int l = 0;l < array11.length;l++) {
	    	System.out.print(array11[l] + " ");	    	
		}
	    System.out.println();
	    System.out.println("请输入要查找的数字，范围-100到100");
	    boolean mark2 = true;
	    int ask1 = scan.nextInt();
	    int start = 0;
	    int end = array11.length - 1;
	    for(;start <= end;) {//或者使用while(start <= end)
	    	int middle = (start + end) / 2;
	    	if(array11[middle] == ask1) {
	     	System.out.println(ask1 + "在随机数组中的角标是" + middle);
	    	mark2 = false;
	    	break;	
	    	}else if(ask1 < array11[middle]) {
	    	end = middle - 1;//通过改变头尾赋值来不断缩小范围，最终收敛到start=end结束循环
	    	}else if(ask1 > array11[middle]) {
	    	start = middle + 1;	
	    	}	    	
	    }	    
	    if(mark2) {
	    	System.out.println("数组中不存在元素" + ask1);
	    }
		System.out.println("OVER");
	}
}