查漏补缺：递归，栈与堆的浅层次理解，排序，稀疏数组

java查缺补漏(打卡2)

1. 递归注意点（由于一般用的少故此不熟练）

   • 递归头：需要一步是他不调用自身，故结束循环
   • 递归体：什么时候调用自身方法，（解决问题的方法）
   • 基数过大不建议用递归

2. 堆与栈的浅层次理解

   • 引用传递，如果此时将数组中的array[0]改为100，那么指向没变但数值改变

   • 值引用传递，如果定义的是一个int a，那么首先赋值即就是将指针指向那个位置，在方法中调用是将指向例外一个位置，而方法没有返回值的话此时方法生命周期就结束了，而外面的指针生命周期没有结束。

     public class arr {
         public static void main(String[] args) {
             int[] num=new int[]{1,2,3,4,5,6,7,8,9,10};
             arr.num(num);
             System.out.println(num[0]);
         }
         public static void num(int[] num)
         {
             num[0]=100;
         }
     }
     
     

3. 排序

   • 冒泡排序（虽然很简单而且之前也做过但叫冒泡排序我就不知道是什么，原来只是比较大小排序）

     public class Sort {
         public void bubbleSort(int[] arr) {
             int n = arr.length;
             for (int i = 0; i < n - 1; i++) {
                 for (int j = 0; j < n - i - 1; j++) {
                     if (arr[j] > arr[j + 1]) {
                         int temp = arr[j];
                         arr[j] = arr[j + 1];
                         arr[j + 1] = temp;
                     }
                 }
             }
         }
     
     

   • 稀疏数组（将重复的数据省去，来达到压缩的空间的目的，通过还原重复的数据达到解压的目的）

     public class Sparse {
         public static void SparesArray(int[][] Spares){
             for (int[] spare : Spares) {
                 for (int i : spare) {
                     System.out.print(i + " ");
                 }
                 System.out.println();
             }
             int sum=0;
             for(int i=0;i<Spares.length;i++){
                 for(int j=0;j<Spares[i].length;j++){
                     if(Spares[i][j]!=0){
                         sum++;
                     }
     
     
                 }
             }
             int[][]spares2=new int[sum+1][3];
             spares2[0][0]=11;
             spares2[0][1]=11;
             spares2[0][2]=sum;
             int count=0;
             for (int i=0;i<Spares.length;i++){
                 for (int j=0;j<Spares[i].length;j++){
                     if (Spares[i][j]!=0){
                         count++;
                         spares2[count][0]=i;
                         spares2[count][1]=j;
                         spares2[count][2]=Spares[i][j];
                     }
                 }
             }
             for (int i=0;i<spares2.length;i++){
                 System.out.println(spares2[i][0]+"\t "+spares2[i][1]
                 +"\t "+spares2[i][2]);
             }
     

​