算法杀我之前端算法小结

链表

链表是数据结构之一，其数据呈线性排列；在内存空间中，数据是分散存储于内存中的，每个数据都由两部分组成，一部分是数据本身，另一部分是一个指针，它指向下一块存储空间。

当对数据进行访问时，只能顺着指针指向一一往下访问，直到找到或者访问到末尾，如果链表中的数量是n，那么查到一个数据时，最快需要一次，最多需要查找n次。当需要在链表中添加或者删除一个数据时，只需要改变其中一个或两个的数据指针即可。与链表的数据量无关，是常量级的。

链表数据是线性的，存储空间是不连续的，访问的时间复杂度为o(n)，增删的时间复杂度为o(1).

循环链表:链表尾部的数据是没有指针的，当为尾部数据添加一个指向链表头部数据的指针时，链表指针之间就形成了环形结构，称为循环链表或环形链表。
双向链表：当链表内部指针既可以从前一个数据指向后一个数据同时也可以从后一个元素指向前一个数据时，就形成了双向链表。

注意：
数组也是线性排列的数据结构之一，它与链表不同的地方在于，数组在内存空间的存储是连续的。

当访问数组时，只需要根据数组索引找到对应位置即可，查找复杂度是常量级的，表示为O（1）；

而当对数组进行增加时，如果在数组头部增加，则需要先将数组扩容。然后将每一个元素都依次向后移动，这个过程复杂度是O（n）

而如果在数组尾部增加一个元素，复杂度变成了O（1），同理，删除一个元素，尾部删除时为O（1），头部删除时为O（n）。

可以看出，相比于链表，数组虽然查询方便了，但是操作复杂度却高了。

栈

栈是一种线性数据结构，当为栈添加一个元素时，这个元素被添加到了栈的最顶端，当取出元素时，只能单向的从最前面的位置读取，然后才能读取后面的元素，也就是说，最后被添加的，反而是最先读取的。
因此，栈被称为是后进先出（LIFO）模式，添加和删除数据的方式也被称为是入栈和出栈。由于栈具有LIFO的特点，常常被用来保存最新的数据。

队列

队列也是线性结构的数据结构，它与栈很像，都是单向的有序操作，但是队列属于先进先出（FIFO）
要访问后面的元素，只能把前面的元素都访问完了，才能访问到目标元素。添加和删除队列的操作也被称为入队和出队。

哈希表

哈希表:存储的是以键值对组合的数据，一般，把键当做数据的标识，而把值当做数据的内容，

哈希表通常与哈希函数组合使用，在建立哈希表的过程中，需要使用哈希函数计算数据的哈希值，将其存在数组中，这样在访问时就可以快速使用数组的特性访问。

如果在建立数据的时候存在多个位于同一个数组位置的值，则再次使用链表存储相同的值。

哈希表的使用，加快了数组查询的速度，在灵活性和高效性上有很大的优势。在编程中，关联数组时常常会用到哈希表。

堆

堆是图的一种，是二维的数据结构，其示意可以用二位的树状图表示，子节点的数据值总比父节点大。

在堆中，顶端的数据始终是最小的，所以无论多少数据量，取出最小值的复杂度始终都是o(1)

另外，由于取出数据后需要将最后的数据移动到最顶端，然后一边比较它与子节点数据的大小，一边往下移动，所以取出数据需要的运行时间和树的高度成正比。

如果需要频繁的从数据中取出最小值，那么，堆是一种很好的选择。

二叉查找树

二叉查找树也叫做二叉搜索树，或二叉排序树。是二维的图结构的一种。

它的特点是：
每个节点最多有两个节点，分别称为左子树和右子树，每一个节点上的值均大于其左子树上的值，每个节点上的值均小于其右子树上的值。

根据这两个特点可知：
二叉查找树查找最小值要往左下末端找，查找最大值要往右下末端找。

经典排序算法

冒泡排序

 const arr = [911, 520, 888, 666, 555, 2323];
 function bubbleSort(arr){
 	let temp;//创建空值
 	//外层循环控制比较的轮数
 	for(let i = 0;i < arr.length;i++){
 	//内层循环控制每一轮的比较次数
 		for(let j = 0 ;j < arr.length-1-i;j++){
 		//如果当前项大于后一项
 			if(arr[j] > arr[j+1]){
 			//交换位置
 				temp = arr[j];
 				arr[j] = arr[j+1];
 				arr[j+1] = temp;
 			}
 		}
 	}
 	return arr;
 }
 console.log(bubbleSort(arr))

插入排序

const arr = [17, 8, 11, 5, 56, 13];
      function insert(arr) {
        let handle = [];
        handle.push(arr[0]);
        for (let i = 1; i < arr.length; i++) {
          let A = arr[i];
          for (let j = handle.length - 1; j >= 0; j--) {
            let B = handle[j];
            if (A > B) {
              handle.splice(j + 1, 0, A);
              break;
            }
            if (j === 0) {
              handle.unshift(A);
            }
          }
        }
        return handle;
      }
      console.log(insert(arr));

快速排序

//快速排序
      let arr = [5, 2, 9, 15, 12, 10];
      var quickSort = function (arr) {
        if (arr.length <= 1) {
          return arr;
        }
        var pivotIndex = Math.floor(arr.length / 2);
        var pivot = arr.splice(pivotIndex, 1)[0];
        var left = [];
        var rigth = [];
        for (var i = 0; i < arr.length; i++) {
          if (arr[i] < pivot) {
            left.push(arr[i]);
          } else {
            rigth.push(arr[i]);
          }
        }
        return quickSort(left).concat([pivot], quickSort(rigth));
      };

      console.log(quickSort(arr));

选择排序

function setletSort(arr){
	var length = arr.length;
	//如果不是数组或者数组长度小于等于1，直接返回，不需要排序
	if(!Array.isArray(array) || length < = 1)return;
	for(let i = 0;i < length - 1;i++){
		let index = i;//设置当前循环最小元素索引
		for (let j = i +1;j < length;j++){
			//如果当前元素比最小元素索引大，则更新最小元素索引
			if (array[index]) > array[j]){
				index = j;
			}
		}
		if(index!=i){
			var temp = arr[i];
			arr[i] = arr[index];
			arr[index] = temp;
		}
	}
	return arr;
}

旋转数组

给定一个数组，将数组中的元素向右移动k个位置，其中k是非负数
示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

一、直接使用js里面的pop和unshift方法

var rotate = function (nums,k){
	for (let i = 0;i < k;i++){
		nums.unshift(nums.pop());
	}
};

二、还可以splice（）整个切下尾部的k个元素，使用…展开后再unshift

var rotate = function(nums ,k){
let len = nums.length
return nums.unshift(...nums.splice(len-k,k))
}

js实现找出字符串中出现最多的字符和次数

@思路
  //1.首先遍历字符串每一数据
  //2.把找到的数据放进对象中
  //3.if判断是否有重复数据,如果有就+1,没有就等于1
  //4.str.charAt(i) 返回当前下标对应的字符 列如let str=abc;str.charAt(1)获取的是b
  //5.把保存对象遍历,进行比对,取最大的值出来打印
function getStrSum(str){
	let obj = {};
	for(let i = 0;i < str.length;i++){
		if(obj[str.charAt(i)]){
			obj[str.charAt(i)]++;
		}else{
			obj[str.charAt(i)] = 1;
		}
	}
	let sum = 0;
	len number;
	for(let key in obj){
		if(obj[key]>sum){
			sum = obj[key]
			number = key
		}
	}
	console.log(number + '出现了' + sum + '次');
}
getStrSum(str);

计算两个数组的交集、差集、补集、并集

var a = [1,2,3,4,5]
var b = [2,4,6,7,8]

//交集：
var c = a.filter(function(v){return b.indexOf(v) > -1})
//差集：
var d = a.filter(function(v){ return b.indexOf(v) == -1})
//补集：
var e = a.filter(function(v){ return !(b.indexOf(v) > -1)}).concat(b.filter(funtion (v){ return !(a.indexOf(v) > -1)}))
//并集：
var f = a.concat(b.filter(function(v) { return !(a.indexOf(v) > -1)}))

console.log("数组a：", a);

console.log("数组b：", b);

console.log("a与b的交集：", c);

console.log("a与b的差集：", d);

console.log("a与b的补集：", e);

console.log("a与b的并集：", f);