23函数递归算法 数组 冒泡排序法

23函数递归算法 数组 冒泡排序法

一、递归

特点

- 在函数里面调用自身
- 必须有一个明确的递归结束条件，这个称之为递归出口
- 不确定循环执行的次数

菲波拉契数

求斐波那契数的第n个数 1 1 2 3 5 8 …

function fn(n) {

	//设置出口

	if (n == 1 || n == 2) {
	return 1
	}
	return fn(n - 1) + fn(n - 2)
}
alert(fn(prompt("需要算出的第n项值")))

二、数组

数组

数组是一个可以存储一组或一系列相关数据的容器，一组数的集合，就是数组

数组的创建

1、使用new关键字和array ()来创建数组

var arr = new array();	//创建一个空数组
	//数组里面的值可以为任意类型的值，如果为字符型需要加""，纯数字可以不加，多个值用","隔开

2、使用[]方法创建一个数组

var arr = [];	//创建一个空数组

数组的索引 (index)

- 数组中有多个值，每个值都有一个”编号”，通过”编号”可以访问到数组中的每个值，数组中的”编号”又称”下标”或”索引号”
- 数组中的”下编号”是从0开始的正整数
- 第1个数组元素下标一定是0，最后一个数组元素的下标是：长度-1,即arr.length-1
- 使用数组的目的，就是使用循环遍历数组很方便

数组的属性

数组对象属性length：就是指数组中元素的总个数

数组元素的访问

//数组名称加上编号就可以访问数组
	arr[0]	//访问数组名为arr的数组的第一项
	arr[arr.length-1]	//访问数组，名为arr的数组的最后一项

三、数组的操作

var arr = [0, 1, 2, 3, 4, 5]

- 读取元素	读取已经存在下标的元素
	形如 arr[0]	//0

- 修改元素	修改已经存在下标的元素的值 (重新赋值)
	形如 arr[0] = 6	//arr = [6, 1, 2, 3, 4, 5]

- 增加元素	添加一个不存在的下标的元素
	形如 arr[6] = 6	//arr = [0, 1, 2, 3, 4, 5, 6]
		arr[7] = 7	//arr = [0, 1, 2, 3, 4, 5, empty, 7]

- 删除元素	使用关键字delete，只能删除元素值，而下标还在
	形如 delete(arr[0],arr[1])	//arr = [empty, empty, 2, 3, 4, 5]

数组的遍历

从数组把数据一个一个的读取或写入

//使用for循环遍历
var arr = [1, 2, 3 ,4 ,5 ,6]

//顺序遍历
for (var i = 0; i < arr.length; i++){
    alert(arr[i])
}

//逆序遍历
for (var i = arr.length-1; i >= 0;i--){
    alert(arr[i])
}

四、数组的方法

var arr = [0, 1, 2, 3, 4, 5]

shift()		删除数组中第一个元素，并将长度减1
	形如arr.shift()	//arr = [1, 2, 3, 4, 5]

pop()	删除数组中最后一个元素，并将长度减1
	形如arr.pop()		//arr = [0, 1, 2, 3, 4]

unshift()	往数组前面添加一个或多个数组元素，长度要改变
	形如arr.unshift(-2, -1)	//arr = [-2, -1, 0, 1, 2, 3, 4, 5]

push()	往数组结尾添加一个或多个数组元素，长度要改变
	形如arr.push(6, 7)	//arr = [0, 1, 2, 3, 4, 5, 6, 7]

var arr = [0, 1, 2, 3, 4, 5]
var arr1 = [0, 1]
var arr2 = [2, 3]
var arr3 = [4, 5]

concat()	方法用于链接两个或多个数组，不改变原数组，返回一个新的数组
	形如res = arr1.concat(arr2,arr3)	//res = [0, 1, 2, 3, 4, 5]

reverse()	逆向排序，元素组也被逆向排序了
	形如arr.reverse()	//arr = [5, 4, 3, 2, 1, 0]

toString()	将数组转成字符串
	形如res = arr.toString()	//res = 0,1,2,3,4,5

join()	将数组转成字符串，中间以拼接符链接
	形如res = arr.join("+")	//res = 0+1+2+3+4+5

var arr = [0, 1, 2, 3, 4, 5]

slice(start,end)	不修改原数组，将数组中的指定区域数据提取出来
	start开始
	end结束
    如果参数是负值表示从倒数开始，不含结束位置
    形如res = arr.slice(0,2)	//res = [0, 1]

splice()
删除	用于删除元素，两个参数，第一个参数(要删除第一项的位置)，第二个参数(要删除的项数)
	形如arr.splice(0, 2)	//arr = [2, 3, 4, 5]

插入	向数组指定位置插入任意项元素，三个参数，第一个参数(开始位置)，第二个参数(0)，第三个参数(插入的项)
	形如arr.splice(0, 0, -2, -1)	//arr = [-2, -1, 0, 1, 2, 3, 4, 5]

替换	向数组指定位置插入任意项元素，同时删除任意数量的项，三个参数，第一个参数(起始位置)，第二个参数(删除的项数)，第三个参数(插入任意数量的项)
	形如arr.splice(0, 3, 2, 0, 1)	//arr = [2, 0 ,1, 3, 4, 5]

五、数组的排序

sort()	对数组进行排序

a-b	如果它的值为正值，就交换它们的位置
	顺序
b-a  如果值为正数，交换它们的位置
	倒序

var arr = [1, 6, 88, 3, 55, 7]

res = sort(function(a,b){
    a-b
})		//res = [1, 3, 6, 7, 55, 88]

res = sort(function(a,b){
    b-a
})		//res = [88, 55, 7, 6, 3, 1]

冒泡排序法

为了方便调用可以写为函数的形式

function sorting(){

	//设置需要遍历的次数

    for(i = 0; i < arr.length - 1; i++){

		//遍历的次数，因为每一次都会确定最后一个为最大值，所以遍历的次数为arr.length-i-1

        for(j = 0; j < arr.length - i -1; j==){

			//当前面的数比后面的数大时，将两者的数进行交换

            if(arr[j] > arr[j + 1]){
                temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }

		//返回冒泡排序后的数组

        return arr
    }
}