day005--20150805

回顾:
1.循环:反复执行一段相同或相似的代码
2.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量: 在循环过程中所改变的那个量
3.循环结构:
1)while:先判断后执行
2)do...while:先执行后判断
第1要素与第3要素相同时
3)for:应用率最高的
4.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环

int num=1;
while(num<5){
num++;
}
System.out.println(num); //5

int num;
for(num=1;num<5;num++){
}
System.out.println(num); //5

 

态度
不要为了完成作业而完成作业
学习
课本上的编码题，我都会自己敲一遍

 

 

 

 

 

笔记:
1.各种循环结构的更佳适用情况
1)while: "当..."循环
2)do...while: "直到..."循环
第1要素与第3要素相同时首选
3)for: 固定次数循环----应用率最高的
2.嵌套循环:
1)循环中套循环
2)多行多列时使用，外层循环控制行，内层循环控制列
3)执行过程: 外层循环走一次，内存循环走所有次
4)能用一层就不用两层，能用两层就不用三层，层数越少越好
如果超过三层循环，说明设计有问题
5)break只能跳出一层循环
3.程序=算法+数据结构
算法:解决问题的流程/步骤(顺序、分支、循环)
数据结构:将数据按照某种特定的结构来保存--数怎么存
设计合理的数据结构会导致好的算法
4.数组:
1)相同数据类型元素的集合
2)数组是一种数据类型(引用类型)
3)数组的定义:
int[] arr = new int[4];
4)数组的初始化: 给数组中的元素赋值
int[] arr = new int[4]; //0,0,0,0
int[] arr = {1,4,5,7}; //1,4,5,7
int[] arr = new int[]{1,4,5,7}; //1,4,5,7
int[] arr;
arr = {1,4,5,7}; //编译错误，此方式只能声明同时初始化
arr = new int[]{1,4,5,7}; //正确
5)数组的访问: 通过下标/索引来访问数组中的元素
下标从0开始，最大到.length-1
int[] arr = new int[4];
System.out.println(arr.length); //4
arr[0] = 100; //给arr中的第1个元素赋值为100
arr[1] = 200;
arr[2] = 300; //给arr中的第3个元素赋值为300
arr[3] = 400;
arr[4] = 500; //数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素
6)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = 100; //给arr中每个元素都赋值为100
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
7)数组的复制:
System.arraycopy(a,1,a1,0,4);
int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
8)数组的排序:
Arrays.sort(arr); //升序排

 

 

任务:
1.冒泡排序算法对4个数排序--int[] arr = {45,23,87,1};
写执行过程----往程序中带数
2.经典案例很熟练的写出来
3.课后作业
4.每日一练

 

 

 

 

在达内期间-------提高逻辑思维能力(想，练)

 

听我讲能懂
自己写不出来-------正常的

1)逻辑思维能力还不太够
2)写得太少了----多写几次，往程序中带数

 

 

 

 

冒泡原理:
1)4个数冒3轮
2)每一轮都是从第1个元素开始比
3)每一次都是和它的下一个元素比
4)冒出来的数就不带它玩了
arr.length-1-i
i=0 比3次
i=1 比2次
i=2 比1次

int[] arr = {45,23,87,1};
for(int i=0;i<arr.length-1;i++){ //控制轮数
for(int j=0;j<arr.length-1-i;j++){ //控制每轮比较的次数
if(arr[j]>arr[j+1]){
int t = arr[j];
arr[j] = arr[j+1];
arr[j+1] = t;
}
}
}

第一轮:
45和23比，换，23,45,87,1
45和87比，不换，23,45,87,1
87和1比，换，23,45,1,87-----------87冒出来了
第二轮:
23和45比，不换，23,45,1,87
45和1比，换，23,1,45,87------------45冒出来了
第三轮:
23和1比，换，1,23,45,87------------23冒出来了

 

 

 

 

 

 

 

1)元素数少的话，使用何种方式排序没有影响
2)元素数多的话，排序算法就有优劣之分了
交换次数越少效率越高
3)不同的数据使用不同的排序算法，最终效率也不同

 

long a = System.currentTimeMillins(); 1010
冒泡算法
long b = System.currentTimeMillins(); 1012

System.out.println(b-a); //Arrays.sort(arr)所花费的毫秒数

 

 

 

 

 

10万-----冒泡最快
10万-----快速最快
10万-----插入最快

Arrays.sort(arr); //升序排列(从小到大)

 

 

 

 

int[] arr = {1,5,76,45};
找最大数的算法:
1.假设第1个元素为最大值
int max = arr[0];
2.遍历剩余元素，将每个元素与max对比，
若大于max，则改变max的值为较大的数
for(int i=1;i<arr.length;i++){
if(arr[i]>max){
max = arr[i];
}
}

 

int[] a = {10,20,30,40,50};
int[] a1 = new int[7]; //0,0,0,0,0,0,0
for(int i=0;i<a.length;i++){
a1[i] = a[i];
}

 

 

 

 

 

max=1
i=1 max=5
i=2 max=76
i=3

 

 

 

 

 

 

 

 

int[] arr = new int[10];
System.out.println(arr[9]);
System.out.println(arr[8]);
System.out.println(arr[7]);
System.out.println(arr[6]);
System.out.println(arr[5]);
System.out.println(arr[4]);
System.out.println(arr[3]);
System.out.println(arr[2]);
System.out.println(arr[1]);
System.out.println(arr[0]);

 

 

 

 

 

 

 

int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i] = 100;
}

 

 

 

 

 

i=0 arr[0]=100
i=1 arr[1]=100
i=2 arr[2]=100
...
i=9 arr[9]=100

arr[0] = 100;
arr[1] = 100;
arr[2] = 100;
arr[3] = 100;
arr[4] = 100;
arr[5] = 100;
arr[6] = 100;
arr[7] = 100;
arr[8] = 100;
arr[9] = 100;

 

 

 

 

int[] arr = new int[4];
System.out.println(arr[0]); //0
arr[2] = 88; //给第3个元素赋值为88

 

 

 

 

 

编译错误，检查语法

int[] arr = new int[4];

int a;
int b;
int c;
int d;

b = 88;

 

 

 

int a = 5;

//声明int型数组arr，包含4个元素
//每个元素都是int型，默认值为0
int[] arr = new int[4]; //0,0,0,0
//声明double型数组dou，包含8个元素
//每个元素都是double型，默认值为0.0
double[] dou = new double[8];
//声明boolean型数组bos，包含20个元素
//每个元素都是boolean型，默认值为false
boolean[] bos = new boolean[20];

 

 

 

 

 

 

 

 

 

 

将书籍按照图书的类别放置----找书的算法简单

将书籍按照出版社不同放置----算法不会变得简单

 

 

 

 

 

 

实际应用中，在某种情况下需跳出所有层次循环---需求几乎没有
for(int i=1;i<=10000;i++){
for(int j=1;j<=10000;j++){
for(int k=1;k<=10000;k++){
System.out.println("aaa");
break;
}
}
}

软件是要模拟现实生活的

 

 

 

 

i=1
j=1/2/3/.../19/20
i=2
j=1/2/3/.../19/20
i=3
j=1/2/3/.../19/20

 

转载于:https://www.cnblogs.com/xiaziteng/p/4705899.html