break:用于终止整个循环。
continue:用于中止本次循环，进入下一次循环。
递归
方法自身调用自身的过程叫做方法的递归(recursion)
递归问题的特点
一个问题可被分解为若干层简单的子问题
子问题和其上层问题的解决方案一致
外层问题的解决依赖于子问题的解决
需求:求5的阶乘(5!)
分析:
5! = 5*4!
4! = 4*3!
3! = 3*2!
2! = 2*1!
1! = 1;
public class Test03{
public static int rec(int n){
if(1 == n){
return 1;
}
return n * rec(n-1);
}
public static void main(String[] args){
int a = 5;
int r = rec(a);
System.out.println("r = " + r);
}
}
递归执行过程
递归效率稍低。
递归结构包括两个部分：
递归结束条件。解答：什么时候不调用自身方法。如果没有条件，将陷入死循环。
递归体。解答：什么时候需要调用自身方法。
总结
递归的优点
简单的程序
递归的缺点
但是递归调用会占用大量的系统堆栈，内存耗用多，
在递归调用层次多时速度要比循环慢的多
递归的使用场合
任何可用递归解决的问题也能使用迭代解决。
当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归；
在要求高性能的情况下尽量避免使用递归，递归既花时间又耗内存。
查找算法
import java.util.Scanner;
public class Test08{
public static void main(String[] args){
// 数组的查找
int[] arr = {8,4,2,1,23,344,12};
Scanner sc = new Scanner(System.in);
//
System.out.println("请键盘输入一个数:");
int t = sc.nextInt();
int loc = -1;
for(int i=0;i<arr.length;i++){
if(t == arr[i]){
loc = i;
break;
}
}
if(loc < 0){
System.out.println("没找到元素");
}else{
System.out.println("找到元素："+loc);
}
}
}
数组的插入算法
需求:有一个有序的数组，向数组中添加一个元素后，依然保持数组有序。
public class Test09{
public static void main(String[] args){
// 数组的查找
// {1,3,5,9,12};
int[] arr = new int[6];
arr[0] = 1;
arr[1] = 3;
arr[2] = 5;
arr[3] = 9;
arr[4] = 12;
int t = 0;
// 【1】找位置
int loc = -1;
for(int i=0;i<arr.length-1;i++){
if(arr[i] > t){
loc = i;
break;
}
}
// System.out.println("loc="+loc);
// 【2】移动元素
if(loc < 0){
// 数组中的元素比要添加的数都小
arr[arr.length-1] = t;
}else{
// 在数组中找到位置
for(int i = arr.length-1;i>loc;i--){
arr[i] = arr[i-1];
}
arr[loc] = t;
}
// 【3】遍历元素
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
数组的删除算法
需求:有一个有序的数组，删除数组一个元素，依然保持数组有序。
public class Test10{
public static void main(String[] args){
// 数组元素的删除
int[] arr = {1,3,5,9,12};
int t = 3;
// 【1】找位置
int loc = -1;
for(int i=0;i<arr.length;i++){
if(t == arr[i]){
loc = i;
break;
}
}
if(loc < 0){
System.out.println("数组中没有找到目标元素");
}else{
for(int i=loc;i<arr.length-1;i++){
arr[i] = arr[i+1];
}
// 覆盖残留值
arr[arr.length-1] = 0;
}
// 【3】遍历
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
冒泡排序
public class Test01{
public static void main(String[] args){
int[] arr = {5,3,1,4,2};
int tmp = 0;
// for循环用于控制趟数
for(int i=0;i<arr.length-1;i++){
// 内层for用于控制两两比较次数
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
tmp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
}
}
// 遍历
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
数组的常用方法
import java.util.Arrays;
public class Test03{
public static void main(String[] args){
// 【2】排序方法(升序)
// int[] arr2 = {5,1,2,4,3};
String[] arr2 = {"cello","bworld","ava"};
Arrays.sort(arr2);
// 方法的调用可以嵌套
System.out.println(Arrays.toString(arr2));
// 【3】二分法查找算法
int[] arr3 = {5,1,2,4,3};
// {1,2,3,4,5}
Arrays.sort(arr3);
// 对有序的且无重复元素的数组进行查找。
int index = Arrays.binarySearch(arr3,6);
System.out.println("index:"+index);
}
}
二分法(折半查找)查找算法
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
如果找到返回key在数组中的位置；如果找不到，返回-(插入点+1)。插入点就是key应该插入到数组的具体位置。
import java.util.Arrays;
public class Test04{
public static void main(String[] args){
// 【5】数组的复制
int[] arr3 = {1,2,3};
// 注意:arr3和arr3Cpy是两个不同的内存空间，相互独立
int[] arr3Cpy = Arrays.copyOf(arr3,5);
System.out.println(Arrays.toString(arr3Cpy));
// 【6】数组的复制
// System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
// System.arraycopy(源数组,源起始索引,目标数组,目标起始索引,长度)
int[] arr4 = {1,2,3};
int[] arr4Cpy = new int[arr4.length];
System.arraycopy(arr4,1,arr4Cpy,0,3);
System.out.println(Arrays.toString(arr4Cpy));
}
}
注意:arraycopy会出现越界的问题。
网友评论