学习内容
- 数组的形式，数组的内部存储结构
- 选择排序，冒泡排序，折半查找
课后作业
1.定义一个函数，函数功能是动态提取int[]中元素的最大值。
2.定义一个函数，从数组中查询指定的元素首次出现的位置。
3.定义函数，完成冒泡排序，大数下沉。
4.折半查找。
5.阐述
6.定义一个函数，实现矩阵的转置.arr[i][j] == arr[j][i];//前提条件是正方的。
7.遍历三维组数，横向输出三维数组的每一个层。
8.定义一个类:Dog 有名称 color age cry();
9.阐述出来堆区，栈区，何时出现溢出，如何解决。
10.oop
解答：
1题答案：动态提取int[]中元素的最大值
class Demo{
public static void main(String[] args){
outResult(getMax(new int []{1,6,4,2}));
}
// 求出数组中最大值
public static int getMax(int array[]){
int temp = Integer.MIN_VALUE;
if(array == null || array.length == 0){
System.out.println("输入数组不合法");
return 0;
}
for(int i = 0; i < array.length; i++){
if(temp < array[i]){
temp = array[i];
}
}
return temp;
}
public static void outResult(int i){
System.out.println(i);;
}
}
2题答案：从数组中查询指定的元素首次出现的位置
class Demo{
public static void main(String[] args){
numLocation( 10, new int[]{1,6,4,5,8,3});
}
public static void numLocation( int num , int arr[] ){
for(int i = 0; i < arr.length; i++){
if(num == arr[i]){
System.out.println("该元素首次出现在第" + (i + 1) + "个位置");
break;
}else if( num != arr[i] && i == (arr.length - 1) ){
System.out.println("该数组中不存在该元素");
}
}
}
}
3题答案：冒泡排序，大数下沉
class Demo{
public static void main(String[] args){
outArr( bubbleSort(new int[]{ 3,6,10,9,2 }) );
}
public static int[] bubbleSort(int arr[]){
for(int i = 0; i < arr.length ; i++){
for(int j = 0; j < (arr.length - 1 - i); j++){
int temp = 0;
if(arr[j] > arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
public static void outArr( int arr[] ){
for(int i= 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
}
}
4题答案：折半查找
class Demo{
public static void main(String[] args){
System.out.println(halfBind(new int[]{1,2,3,4,7,9,10},4));
}
//折半查找
public static int halfBind(int arr[],int num){
int a = 0, b = arr.length - 1, m = 0;
int midIndex = 0; //中间数的下标
while( a <= b ){
midIndex = (a + b)/ 2;
m = arr[midIndex];
if( num == m ){
return midIndex;
}else if( num < m ){ //落在中间数的左边
b = midIndex - 1;
}else{ //落在中间数的右边
a = midIndex + 1;
}
}
return -1;
}
6.题答案: 转置矩阵
class Demo{
public static void main(String[] args){
int num = 1;
int[][] arr = new int[4][4];
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
arr[i][j] = num;
num ++;
}
}
outArr(tranArr(arr));
}
//转置矩阵
public static int[][] tranArr(int arr[][]){
int temp = 0;
for(int i = 0; i < arr.length; i++){
for(int j = i; j < arr[i].length; j++){
temp = arr[i][j];
arr[i][j] = arr[j][i];
arr[j][i] = temp;
}
}
return arr;
}
//输出矩阵
public static void outArr( int arr[][] ){
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
7.题答案：横向输出三维数组的每一层
class Demo{
public static void main(String[] args){
outArr(getArr3_3_3());
}
//构造三维数组
public static int[][][] getArr3_3_3(){
int num = 1;
int[][][] arr = new int[3][3][3];
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
for(int k = 0; k < arr[i][j].length; k++){
arr[i][j][k] = num;
num ++;
}
}
}
return arr;
}
//输出矩阵 按列输出
public static void outArr( int arr[][][]){
// 依次找到各个层次
for(int i = 0; i < arr.length; i++){
// 找到第各个层次的第一行的各个列依次输出
for(int k = 0; k < arr[i][0].length; k++){
System.out.print(arr[i][0][k] + " ");
}
System.out.print("|" + " ");
}
System.out.println();
for(int i = 0; i < arr.length; i++){
// 找到第各个层次的第二行的各个列依次输出
for(int k = 0; k < arr[i][1].length; k++){
System.out.print(arr[i][1][k] + " ");
}
System.out.print("|" + " ");
}
System.out.println();
for(int i = 0; i < arr.length; i++){
// 找到第各个层次的第三行的各个列依次输出
for(int k = 0; k < arr[i][2].length; k++){
System.out.print(arr[i][2][k] + " ");
}
System.out.print("|" + " ");
}
System.out.println();
}
}
按行输出则直接遍历，更简单
8.创建Dog类
class Demo{
public static void main(String[] args){
Dog dog = new Dog();
dog.setAge(3);
dog.setColor("black");
dog.cry();
}
}
class Dog{
private String color;
private int age;
public void setColor( String color ){
this.color = color;
}
public String getColor(){
return color;
}
public void setAge( int age ){
this.age = age;
}
public int getAge(){
return age;
}
public void cry(){
System.out.println("汪汪汪");
}
}
9.阐述出来堆区，栈区，何时出现溢出，如何解决。
栈溢出情形：
当不断方法以递归的形式不断运行，压桟时往往就会发生栈溢出。
解决方式：当jvm内存足够时，可用java -Xss 来重新设置栈内存来解决
堆溢出情形：
当创建数组或对象等其他方式写入堆内存过大时，便会出现堆溢出。
解决方式：当jvm内存足够时，可用java -Xmx 来重新设置堆内存来解决
遇到的问题
1.定义一个函数，函数功能是动态提取int[]中元素的最大值
- 提示编码gbk的不可映射字符 需要通过javac -encoding utf-8 Xxx.java 才能编译
其实我们只要把notepad++语言设置成GBK中文形式就完美解决啦
- 数组new的形式不对
数组的三种构造形式：
int [ ]arr = new int[ 3 ]; int [ ]arr = new int[ ]{ 1,3,4,5 }; int[ ]arr = {1,4,2,5};
- Integer.MIN_VALUE 写成Integer.min_value是不对的
2.选择排序一开始理解不是很透彻，多想想就很清楚了
3.在编译从数组中查询指定的元素首次出现的位置这个程序时，报错：
原来是缺失了int，应该是new int[ ]{1,3,5,2,9 };
class Demo{
public static void main(String[] args){
outResult(getSelectSort(new int []{1,6,4,2}));
}
// 选择排序
public static int[] getSelectSort(int arr[]){
for(int i = 0; i < arr.length; i++){
// 获得数组当前值后面所有值中的最小值
int min = Integer.MAX_VALUE;
int num = 0;
for(int j = i + 1; j < arr.length; j++){
if(min > arr[j]){
min = arr[j];
num = j;
}
}
//判断 交换当前值与其后最小值的值与序号
if(arr[i] > min){
arr[num] = arr[i];
arr[i] = min;
}
}
return arr;
}
public static void outResult(int arr[]){
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " " );
}
}
}
附老师代码：
class ArraySelectSort
{
public static void main(String[] x){
outArr(sort(new int[]{5,7,8,1,3,4,9}));
}
public static int[] sort(int[] arr){
//迭代数组的每个元素
for(int i = 0 ; i < arr.length ; i ++){
//定义最小值
int min = Integer.MAX_VALUE;
int index = 0 ;
//查找最小值以及最小值对应的下标
for(int j = i + 1 ; j < arr.length ; j ++){
if(min > arr[j]){
min = arr[j] ;
index = j ;
System.out.println(min);
}
}
//完成当前元素和后续数组中最小的元素的对调.
int xx = 0 ;
if(arr[i] > min){
//xx = arr[i] ;
arr[index] = arr[i] ;
arr[i] = min;
}
}
return arr ;
}
public static void outArr(int[] arr){
for(int i = 0 ; i < arr.length ; i ++){
System.out.print(arr[i] + " ");
}
}
}
4.在写for循环时经常直接写i = 0; 应该写成 int i = 0；
5.转置矩阵时总是转置的不全面
原因在于交换arr[i] [j]和和arr[j][i]的代码写的不对，另外注意第二层循环的起始位置
6.其实很简单，只是让每一行的行数和列数相等
7.在输出三维数组时报错，后发现getArr3*3*3( )这个标识符是不合法的
8.在创建Dog类时一直报错：
后来才发现多了一个（），而且class Dog是不能放在另一个class中的
十八掌第三天课程总结