关于后端:数据结构和算法随笔2

36次阅读

共计 3535 个字符,预计需要花费 9 分钟才能阅读完成。

参考极客工夫




顺序存储

二叉树的遍历

前序遍历的递推公式:preOrder(r) = print r->preOrder(r->left)->preOrder(r->right)
 
中序遍历的递推公式:inOrder(r) = inOrder(r->left)->print r->inOrder(r->right)
 
后序遍历的递推公式:postOrder(r) = postOrder(r->left)->postOrder(r->right)->print r
void preOrder(Node* root) {if (root == null) return;
  print root // 此处为伪代码,示意打印 root 节点
  preOrder(root->left);
  preOrder(root->right);
}
 
void inOrder(Node* root) {if (root == null) return;
  inOrder(root->left);
  print root // 此处为伪代码,示意打印 root 节点
  inOrder(root->right);
}
 
void postOrder(Node* root) {if (root == null) return;
  postOrder(root->left);
  postOrder(root->right);
  print root // 此处为伪代码,示意打印 root 节点
}

二叉查找树查找

public class BinarySearchTree {
  private Node tree;
 
  public Node find(int data) {
    Node p = tree;
    while (p != null) {if (data < p.data) p = p.left;
      else if (data > p.data) p = p.right;
      else return p;
    }
    return null;
  }
 
  public static class Node {
    private int data;
    private Node left;
    private Node right;
 
    public Node(int data) {this.data = data;}
  }
}

二叉查找树插入

public void insert(int data) {if (tree == null) {tree = new Node(data);
    return;
  }
 
  Node p = tree;
  while (p != null) {if (data > p.data) {if (p.right == null) {p.right = new Node(data);
        return;
      }
      p = p.right;
    } else { // data < p.data
      if (p.left == null) {p.left = new Node(data);
        return;
      }
      p = p.left;
    }
  }
}

二叉查找树的删除操作

第一种状况是,如果要删除的节点没有子节点,咱们只须要间接将父节点中,指向要删除节点的指针置为 null。比方图中的删除节点 55。

第二种状况是,如果要删除的节点只有一个子节点(只有左子节点或者右子节点),咱们只须要更新父节点中,指向要删除节点的指针,让它指向要删除节点的子节点就能够了。比方图中的删除节点 13。

第三种状况是,如果要删除的节点有两个子节点,这就比较复杂了。咱们须要找到这个节点的右子树中的最小节点,把它替换到要删除的节点上。而后再删除掉这个最小节点,因为最小节点必定没有左子节点(如果有左子结点,那就不是最小节点了),所以,咱们能够利用下面两条规定来删除这个最小节点。

public void delete(int data) {
  Node p = tree; // p 指向要删除的节点,初始化指向根节点
  Node pp = null; // pp 记录的是 p 的父节点
  while (p != null && p.data != data) {
    pp = p;
    if (data > p.data) p = p.right;
    else p = p.left;
  }
  if (p == null) return; // 没有找到
 
  // 要删除的节点有两个子节点
  if (p.left != null && p.right != null) { // 查找右子树中最小节点
    Node minP = p.right;
    Node minPP = p; // minPP 示意 minP 的父节点
    while (minP.left != null) {
      minPP = minP;
      minP = minP.left;
    }
    p.data = minP.data; // 将 minP 的数据替换到 p 中
    p = minP; // 上面就变成了删除 minP 了
    pp = minPP;
  }
 
  // 删除节点是叶子节点或者仅有一个子节点
  Node child; // p 的子节点
  if (p.left != null) child = p.left;
  else if (p.right != null) child = p.right;
  else child = null;
 
  if (pp == null) tree = child; // 删除的是根节点
  else if (pp.left == p) pp.left = child;
  else pp.right = child;
}

为什么说堆排序没有疾速排序快
1、堆排序数据拜访的形式没有疾速排序敌对
2、对于同样的数据,在排序过程中,堆排序算法的数据交换次数要多于疾速排序

图存储形式:
邻接表存储办法

广度优先搜寻(BFS)

public void bfs(int s, int t) {if (s == t) return;
  boolean[] visited = new boolean[v];
  visited[s]=true;
  Queue<Integer> queue = new LinkedList<>();
  queue.add(s);
  int[] prev = new int[v];
  for (int i = 0; i < v; ++i) {prev[i] = -1;
  }
  while (queue.size() != 0) {int w = queue.poll();
   for (int i = 0; i < adj[w].size(); ++i) {int q = adj[w].get(i);
      if (!visited[q]) {prev[q] = w;
        if (q == t) {print(prev, s, t);
          return;
        }
        visited[q] = true;
        queue.add(q);
      }
    }
  }
}
 
private void print(int[] prev, int s, int t) { // 递归打印 s->t 的门路
  if (prev[t] != -1 && t != s) {print(prev, s, prev[t]);
  }
  System.out.print(t + " ");
}


深度优先搜寻(DFS)

boolean found = false; // 全局变量或者类成员变量
 
public void dfs(int s, int t) {
  found = false;
  boolean[] visited = new boolean[v];
  int[] prev = new int[v];
  for (int i = 0; i < v; ++i) {prev[i] = -1;
  }
  recurDfs(s, t, visited, prev);
  print(prev, s, t);
}
 
private void recurDfs(int w, int t, boolean[] visited, int[] prev) {if (found == true) return;
  visited[w] = true;
  if (w == t) {
    found = true;
    return;
  }
  for (int i = 0; i < adj[w].size(); ++i) {int q = adj[w].get(i);
    if (!visited[q]) {prev[q] = w;
      recurDfs(q, t, visited, prev);
    }
  }
}

b+ 树

每个节点中子节点的个数不能超过 m,也不能小于 m/2;根节点的子节点个数能够不超过 m/2,这是一个例外;m 叉树只存储索引,并不真正存储数据,这个有点儿相似跳表;通过链表将叶子节点串联在一起,这样能够不便按区间查找;个别状况,根节点会被存储在内存中,其余节点存储在磁盘中。树的高度也只是 3,最多只有 3 次磁盘 IO 就能获取到数据。磁盘 IO 变少了,查找数据的效率也就进步了。

B 树跟 B+ 树的不同点次要集中在这几个中央

B+ 树中的节点不存储数据,只是索引,而 B 树中的节点存储数据;B 树中的叶子节点并不需要链表来串联。B 树只是一个每个节点的子节点个数不能小于 m/2 的 m 叉树。B 树的长处在于数据存储在每个结点中,能够更快拜访到,而不必须走到叶子结点,B 树更多的用在文件系统中。B+ 树的每个非叶子结点都只充当索引,所以查问必须到叶子结点完结,但它非常适宜“扫库”和区间查找,而且因为大多结点只用于索引,所以并不会存储真正的数据,在内存上会更紧凑,雷同的内存就能够寄存更多的索引数据了。比方字典的拼音和汉字是拆散的,只须要几十页就能失去残缺的拼音表,然而如果拼音和汉字掺杂在一起,要失去残缺的索引(拼音)表就须要整个字典。

B 树结构

正文完
 0