数据结构与算法

最新推荐文章于 2024-08-27 16:50:49 发布

chenxuezhou

最新推荐文章于 2024-08-27 16:50:49 发布

阅读量158

点赞数

分类专栏：算法文章标签：算法数据结构

本文链接：https://blog.csdn.net/u012557298/article/details/80898794

版权

算法专栏收录该内容

10 篇文章 1 订阅

订阅专栏

挺好的样例题，值得刷

https://leetcode-cn.com/explore/

带算法特性

给一个01矩阵，求不同的岛屿的个数。

0代表海，1代表岛，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。

样例

在矩阵：

[
  [1, 1, 0, 0, 0],
  [0, 1, 0, 0, 1],
  [0, 0, 0, 1, 1],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 1]
]

中有 3 个岛.

function dfs(grid, x , y){

if(x<0||x>grid.length-1){

return;

}

if(y<0||y>grid[0].length-1){

return;

}

if(!grid[x][y]){

return;

}

grid[x][y]=false;

dfs(grid,x+1,y);

dfs(grid,x-1,y);

dfs(grid,x,y+1);

dfs(grid,x,y-1);

}

function numIslands( grid) {

// Write your code here

if(grid.length ==0 || grid[0].length==0 || grid == null ) return 0;

var n=grid.length;

var m=grid[0].length;

var count=0;

for(var i=0;i<n;i++){

for(var j=0;j<m;j++){

if(grid[i][j]){

dfs(grid,i,j);

count++;

}

return count;

}

var a= [

[1, 1, 0, 0, 0],

[0, 1, 0, 0, 1],

[0, 0, 0, 1, 1],

[0, 0, 0, 0, 0],

[0, 0, 0, 0, 1]

]

console.log(numIslands(a))

DFS、BFS遍历html节点

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <title>Demo</title>
  
</head>

<body>
  <div class="root">
    <div class="container">
      <section class="sidebar">
        <ul class="menu"></ul>
      </section>
      <section class="main">
        <article class="post"></article>
        <p class="copyright"></p>
      </section>
    </div>
  </div>

  <script>
    const DFSTraverse = (rootNodes, rootLayer) => {
      const roots = Array.from(rootNodes)
      while (roots.length) {
        const root = roots.shift()
        printInfo(root, rootLayer)
        // 如果有子节点，直接遍历子节点，同时将层级加1
        if (root.children.length) {
          DFSTraverse(root.children, rootLayer + 1)
        }
      }
    }
    const BFSTraverse = (rootNodes, rootLayer) => {
      const roots = Array.from(rootNodes)
      const rootsLayer = [] // 单用一个数组存放每个节点的的层级
      // 初始化
      for (let i = 0; i < roots.length; i++) {
        rootsLayer.push(rootLayer)
      }
      var rootIdx = 0 // 记录当前处理roots中的第几个节点，方便查找rootsLayer中对应的层级
      while (roots.length) {
        const root = roots.shift() // 出队
        printInfo(root, rootsLayer[rootIdx])
        // 如果有子节点，将子节点放到roots队列中
        if (root.children.length) {
          Array.prototype.push.apply(roots, Array.from(root.children))
          // 将当前层级加1得到子节点的层级
          rootLayer = rootsLayer[rootIdx] + 1
          for (let i = 0; i < root.children.length; i++) {
            rootsLayer.push(rootLayer)
          }
        }
        // 处理下一个root节点
        rootIdx++
      }
    }

    // 输入节点信息
    const printInfo = (node, layer) => {
      var str = ''
      for (let i = 1; i < layer; i++) {
        str += ' '
      }
      console.log(`${layer}:${str}${node.tagName} .${node.className}`);
    }

    console.log('DFS *******************************');
    DFSTraverse(document.querySelectorAll('.root'), 1);
    console.log('BFS *******************************');
    BFSTraverse(document.querySelectorAll('.root'), 1);
  </script>
</body>

</html>

https://blog.csdn.net/zwseaman/article/details/7592855

深度优先算法属于盲目搜索，无法保证搜索到的路径为最短路径。

JS队列的定义方式，DFS有些用递归，有些用栈和队列

平衡二叉树：

DataStruct:

public class AVLNode {
    public int data;
    public int depth;
    public int balance;
    public AVLNode parent;
    public AVLNode left;
    public AVLNode right;

    public AVLNode(int data){
        this.data = data;
        depth = 1;
        balance = 0;
        left = null;
        right = null;
    }
}

左旋的操作方式


private static void l_rotate(AVLNode a) {
        AVLNode b=a.right,p=a;//错误的方式
        b.left=p;
        p.right=a.left;
        a=b;
}


正确方式

 private static void r_rotate(AVLNode a) {
        AVLNode b=a.left;
        a.left=b.right;
        b.right=a;
        a=b;
    }

由于值传递问题，无法通过一个方法修改节点内部结构

  private  void r_rotate(AVLNode a) {
        AVLNode b=left;
        left=b.right;
        b.right=this;
        this=b;//this不可修改
    }



整个过程root引用到的对象一直在变化，操作类似红黑树，C语言改成java方式会引发很多问题

参考文章：

https://www.cnblogs.com/You0/p/4459719.html