标签：index arr 下标 递归函数 存储 冒泡排序 循环 排序 单元

递归函数

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

     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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。