day--11
冒泡排序 (必须熟练) p 58
- 冒泡排序是最为出名的排序算法之一,总共有八大排序! 两两对比然后调换位置 再两两对比再调换位置
- 冒泡的代码还是相当简单的,两层循环,外层冒泡轮数,里层一次比较,江湖中人尽皆知。
- 我们看到嵌套循环,应该立马就可以得出这个算法的世间复杂度为0(n2).
- 思考:如何优化?
public class ArryaOrder01 {
public static void main(String[] args) {
int[] a = {2,34,52,4,65,73,34,22,2,3,43};
int[] sort = sort(a); //调用下面自己写的方法后,返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
//冒泡排序的方法
public static int[] sort(int[] array){
//临时变量,借助临时变量交换赋值 java中不可以直接交换
int temp = 0;
//外层循环,判断我们这个要走多少次
for(int i = 0; i<array.length-1;i++){
boolean flag = false; //通过flag标识位减少没有意义的比较
//内层循环,比较两个数,如果第一个数比第二个数大,则交换位置
for(int j = 0;j<array.length-1-i;j++){
if(array[j+1]>array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if(flag==false){
break;
}
}
return array;
}
稀疏数组 (坐标的思维去看)
-
用坐标的方式去记录数组,就是压缩空间。
-
行 列 值
public class ArryaOrder01 { public static void main(String[] args) { int[] a = {2,34,52,4,65,73,34,22,2,3,43}; int[] sort = sort(a); //调用下面自己写的方法后,返回一个排序后的数组 System.out.println(Arrays.toString(sort)); } //冒泡排序的方法 public static int[] sort(int[] array){ //临时变量,借助临时变量交换赋值 java中不可以直接交换 int temp = 0; //外层循环,判断我们这个要走多少次 for(int i = 0; i<array.length-1;i++){ boolean flag = false; //通过flag标识 减少没有意义的比较 //内层循环,比较两个数,如果第一个数比第二个数大,则交换位置 for(int j = 0;j<array.length-1-i;j++){ if(array[j+1]>array[j]){ temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; flag = true; } } if(flag==false){ break; } } return array; } }
仔细看 必须懂 (也可以直接去IDE中去看)
public class SparseDemo {
public static void main(String[] args) {
//创建一个二维数组 11行和11列 0:没有棋子, 1:黑棋 2:白棋
int [][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始的数组
System.out.println("输出的原始数组:");
for(int[] ints : array1){
for(int anInt : ints){
System.out.print(anInt + "\t");
}
System.out.println();
}
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("有效值的个数是:"+sum);
//创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组,将非零的值,存放稀疏数组中
int count = 0;
for (int i = 0;i< array1.length;i++){
for(int j =0;j< array1.length;j++){
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("====================");
System.out.println("还原");
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for(int i = 1;i< array2.length;i++){
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3.打印
System.out.println("输出的还原的数组:");
for(int[] ints : array3){
for(int anInt : ints){
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
面向对象
-
$\textcolor{red}{ 对于描述复杂的事物,为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作,任然需要面向过程的思路去处理。}$
-
面向对象编程(Object-Oriented Programming,OOP)
-
面向对象编程的本质就是:$\textcolor{red}{以类的方式组织代码,以对象的组织(封装)数据。}$
-
抽象(这里的抽为动词:抽 像)
-
三大特性:
1. 封装
1. 继承
1. 多态 -
从认识的角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
-
从代码运行角度考虑是先有类后有对象。类是对象的模板。