递归函数 冒泡排序 和 选择排序

递归函数

在函数内部调用函数本身.

     function fun( ){
          fun( );
      }

递归函数的核心内容:
1, 调用函数本身等于在调用函数自己 , 也就是调用函数本身所有的程序代码.
2, 递归函数的进入是由外到内 , 递归函数的终止是由内到外.

<!-- 
        累加求和函数的程序
            递归思想的累加求和
                1-100累加求和

                可以看成1-99的累加和 + 100
                可以看成1-98的累加和 + 100 + 99

                1-n 的累加和 可以看成 (1+(n-1)+n)


     -->
function add( num ){
            if( num === 1 ){
                return 1;
            }else{
                return add(num-1)+num;
            }
        }
        console.log(add(100));

冒泡排序

数组数据的一种排序方式方法.

核心思路:
从数组的第一个单元开始循环 , 和当前单元的下一个单元进行数据比较 , 如果当前单元存储的数据大 , 下一个单元存储的数据小 , 需要交换两个单元存储的数据数值 , 循环一次会将一个最大值存储到数组的末位 , 多次循环完成数组的排序.

冒泡排序算法的优化:
1, 外层
n个单元循环循环n-1次 (两两进行比较排序 , 最后一个单元没有比较排序的单元)

2, 内层
每个单元和下一个单元进行数据比较 , 最后一个单元没有下一个单元进行数据比较 , 从第一个单元循环至倒数第二个单元.

const arr = [5,4,3,2,1];
         // 循环一次 , 将一个最大值 存储到数组的末位
         for(let j = 0 ; j<=arr.length-1-1;j++){

            // 一次循环将最大值存储到数组的末位
             for(let i = 0 ;i<=arr.length-1-1-j ;i++){
                 if(arr[i]>arr[i+1]){
                     let a = arr[i];
                     arr[i] = arr[i+1];
                     arr[i+1] = a ;
                 }

             }
         }
         console.log(arr);

选择排序

核心思路
从当前循环起始单元开始 和 之后的所有单元进行数据比较 , 如果之后单元存储的数据小于起始单元数据 , 在变量中存储之后单元的索引下标 , 循环结束后 , 变量中存储的是最小值所在单元的索引下标 , 如果这个索引下标不是当前循环起始单元的索引下标 , 交换两个单元 , 每次循环结束后将一个最小值排序到数组的起始位置 , 多次循环完成数组的排序.

选择排序的优化:
外层
n个单元循环n-1次

内层
从当前循环的起始单元 和 下一个单元开始循环比较 , 之前比较出的最小值不用参加下一次循环

const arr = [8432,592345,54,6,9,12,94,312];


         // 一次排序将一个最小值排序到数组的起始位置 
        
         

         for(let j = 0 ; j<=arr.length-1-1 ; j++){
              //循环第一次是从索引下标是0的第一个单元开始循环比较
              // 定义一个变量存储当前循环起始单元的索引下标
              let index = j;

              // 和起始单元之后所有的数组单元进行数据比较
              for(let i = index+1 ;i<=arr.length-1;i++){

                    // 变量存储的索引下标对应的单元的数据arr[index] 和当前循环单元对应的数据arr[i]比较, 如果arr[index] 大于arr[i] ,存储当前循环单元的索引下标
                  if(arr[index] > arr[i]){
                      index = i;
                  }
              }


              //循环结束 变量index中存储最小值所在单元的索引下标
              // 如果循环结束变量index存储的索引下标不是循环起始单元的索引下标 ,交换两个索引下标对应的单元存储的数据
              if(index != j){
                  let a = arr[index];
                  arr[index] = arr[j];
                  arr[j] = a ;
              }
         }
         console.log(arr);

标签：index,arr,下标,递归函数,存储,冒泡排序,循环,排序,单元
来源： https://blog.csdn.net/YANG_helloworld/article/details/122798959