前端数据结构与算法总复习

最新推荐文章于 2024-07-26 15:05:55 发布

旺sir

最新推荐文章于 2024-07-26 15:05:55 发布

阅读量202

点赞数

文章标签：前端

本文链接：https://blog.csdn.net/weixin_44858541/article/details/126393289

版权

1.常见的数据结构

栈，队列，链表

集合，字典

树，堆，图

2.常见的算法

链表：遍历链表，删除链表节点

树，图：深度/广度优先遍历

数组：冒泡，选择，归并，插入,快速排序，顺序/二分搜索

3.数据结构之栈

特点：先进后出

有效括号

var isValid=function（s）{
   let length=s.length;
   if(length%1===1) return false;
   let stack=[];
   let myMap=new Map();
   myMap.set("(",")");
   myMap.set('{','}');
   myMap.set('[',']');
   for(let i=0;i<n;i++){
    let n=s[i];
    if(myMap.has(n)){
      stack.push(n);}
    else{
      let t=stack[stack.length-1];
      if(myMap.get(t)===n){stack.pop();}
      else{
       return false}
}
}
  return stack.length===0
}

4.数据结构之队列

特点：先进后出

5.数据结构之链表

1.数组VS链表

数组在增删非首尾元素时，常常需要移动元素

而链表在增删非首尾元素时，不需要移动元素，仅仅只需要更改next指向即可

在js当中并没有链表这种数据结构，可以使用对象来模拟链表

2.反转链表

var reverseList=function（head）{
  let curr=head;
  let pre=null;
  while(curr){
  let next=curr.next;
  curr.next=pre;
  pre=curr;
  curr=next;
}
  return pre
}

6.数据结构之集合

集合

1.集合是一种无序且唯一的数据结构

2.在ES6当中提供了集合这种数据结构，用Set来表示

3.集合的常用操作：去重，判断某元素是否在集合中，求交集

7.数据结构之字典

1.与集合类似，字典也是一种存储唯一值的数据结构，但是它是以键值对的形式来存储的。

2.Es6中有字典，名为Map

3.字典的常用操作时键值对的增删改查

const m=New Map();
//增
m.set("a","aa");
m.set("b","bb");
//删
m.delete('a');
//改
m.set('a','aaaaa');
//查
m.get('a');

两数之和

var twoSum=function(nums,target){
   let length=nums.length;
   let myMap=new Map();
   for(let i=1;i<length;i++){
      let n1=nums[i];
      let n2=target-n1;
      if(myMap.has(n2)){
         return [myMap.get(n2),i]
     }
       else{
               myMap.set(n1,i);
     }  
   }
}

8.数据结构之树

1.树是一种分层数据的抽象模型

2.js当中没有树这种数据结构，可以用对象来进行模拟

树的常用操作包括:深度，广度优先遍历，先中后序遍历

//深度优先遍历
const dfs=function(root){
   console.log(root.val);
   root.childern.forEach((child)=>{ dfs(child);});
}
//广度优先遍历
const bfs=function(root){
   let  q=[root];
   while(q.length>0){
   let n=q.shift();
   console.log(n.val);
   n.children.forEach((child)=>{
       q.push(child);});
}
  
}
//二叉树的前中后序遍历

//前序遍历
1.递归写法
const preOrder=function(tree){
   if(!tree){ return }
   console.log(tree.val);
   preOrder(tree.left);
   preOrder(tree.right);
}
2.非递归写法
const preOrder=function(tree){
   if(!tree){return }
   let stack=[tree];
   while(stack.length){
    let n=stack.pop();
    if(n.right){stack.push(n.right);
    if(n.left){stack.push(n.left)}}

}
//中序遍历（递归）
 const inOrder=function(tree){
    if(!tree){return }
    inOrder(tree.left);
    console.log(tree.val);
    inOrder(tree.right);
}
//后序遍历
const  postOrder=function(tree){
    if(!tree){ return }
    postOrder(tree.left);
    postOrder(tree.right);
    console.log(tree.val);
}
//二叉树层序遍历
const  levelOrder=function(tree){
    if(!tree){ return }
    let q=[tree,0];
    let res=[];
    while(q.length){
      let [n,l]=q.shift();
      if(!res[l]){res.push([n.val]);}
      else{res[l].push(n.val);}
    if(n.left){q.push([n.left,l+1]);}
    if(n.right){q.push([n.right,l+1]);} 
}
     return res
}