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");
	}
}