Java基础复习（六）
递归（大计算少用递归）
递归结构包括两个部分
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法
数组
- 数组是相同类型数据的有序集合
- 若干个数据按照先后次序排列组合而成
- 其中，每一个数据称作一个数组元素，通过数组元素下标访问
//声明数组变量
dataType[] arrayRefVar; //首选方法
dataType arrayRefVar[]; //效果相同
//new字符创建字符串
dataType[] arrayRefVar = new dataType[arraySize]；
- 数组的元素通过索引访问，数组索引从0开始
//静态初始化：创建 + 赋值
int[] a = {1，2，3，4，5};
//动态初始化：包换默认初始化
int[] b = new int [10];
CTRL+/：快速注释
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for(int i = 0,j=result.length-1;i<arrays.length;i++,j--){
result[j]=arrays[i];
}
return result;
}
//法二
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for(int i = arrays.length;i>0;i--){
}
return result;
}
package Jc;
import java.util.Arrays;
public class A {
public static void main(String[] args) {
int[] a={2,1,3};
System.out.println(a); //[I@7c30a502
//打印数组元素Arrays.toString
System.out.println(Arrays.toString(a)); //[1, 2, 3]
//自己写的方法
printArray(a); //(1,2,)
Arrays.sort(a);
System.out.println(Arrays.toString(a)); //[1, 2, 3]
}
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if(i==0){
System.out.print("(");
}
if(i==a.length-1){
System.out.println(")");
}else{
System.out.print(a[i]+",");
}
}
}
}
冒泡排序
1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
2.每一次比较，都会产生一个最大，或者最小的数字
3.下一轮则可以少一次排序！依次循环，直到结束！
package Jc;
import java.util.*;
public class ArrayCompare {
public static void main(String[] args){
int[] a = {1,3,5,2,4,6};
int[] sort = sort(a);
System.out.println(Arrays.toString(sort)); //调用toString方法升序打印
}
public static int[] sort(int[] array){
int temp = 0; //外层循环，判断循环走多少次
for (int i = 0; i < array.length - 1; i++) { //防止溢出，比到倒数第二个就不用比了
for (int j = 0; j < array.length - 1; j++) { //内层循环，比较两个数然后排序
if(array[j+1]<array[j]){
temp=array[j]; //冒泡排序
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
return array;
}
}
稀疏数组
就是将有效值变成表格的形式
package Jc;
import org.w3c.dom.ls.LSOutput;
public class SparseArray {
public static void main(String[] args) {
int[][] array1 = new int[11][11]; //创建二维数组11*11
array1[1][2] = 1;
array1[2][3] = 2; //输出原始的数组
System.out.println("输出原始的数组");
for (int[] ints : array1) { //这里用增强for循环遍历数组
for (int anInt : ints) { //我试了一下不能只写第一句，如果只写第一句的话输出的就是哈希码
System.out.print(anInt + "\t"); //这个ints的类型我也没搞太懂，看这个代码应该是int类型的，所以才能输出为数字
}
System.out.println(); //遍历完一组后换行
}
//转换为稀疏数组保存
//获取有效值个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("==========");
System.out.println("有效值的个数" + sum);
//创建一个稀疏数组
int[][] array2 = new int[sum + 1][3]; //sum+1表示的是共有几个有效值，3表示的是行，列，值的意思
array2[0][0] = 11; //表示11行
array2[0][1] = 11; //表示11列
array2[0][2] = sum; //表示值
//遍历二维数组，将非0数存在稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {//表示i行里面数组的长度
if(array1[i][j]!=0) {
count++;
array2[count][0] = i; //行
array2[count][1] = j; //列
array2[count][2] = array1[i][j]; //值
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
}
System.out.println("==========");
//读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]]; //表示11行11列
//将元素还原成值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//输出还原数组:
for(int[] ints : array1){
for(int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
