二叉平衡树avlTree和红黑树rbTree的java实现

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量1.1k 收藏
点赞数
文章标签： java delete insert null string tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxjcaesar/article/details/2792294
版权

 最近复习了一下数据结构，用java实现了avl树和rb树，以下是代码，不对之处，请您斧正

 

//下面的是用于输入数据的实现类

//author: yxjcaesar

import java.io.*;
public class IO{
 public static PrintStream p=System.out;
 public static InputStream in=System.in;
 public static int[] readInts(){
  try{
   BufferedReader br=new BufferedReader(new InputStreamReader(in));
   String s=br.readLine();
   String[] ss=s.split(" ");
   int[] re=new int[ss.length];
   for(int i=0;i<ss.length;i++){
    re[i]=Integer.parseInt(ss[i]);
   }
   return re;
  }catch(Exception e){
   e.printStackTrace();
   return null;
  }
 }
}

 

 

 

 

 

 

 

 

 

 

 

//下面的是RB树的实现代码

//author: yxjcaesar

import java.util.*;
public class RBTree{
 Node tree=new Node(-1,Node.B);
 int c=0;
 int tc=0;
 int c1=0;
 int c2=0;
 Node c3=null;

 /**insert(int) 插入数据
 *@author yxjcaesar
 */
 public boolean insert(int s){
  boolean bool=insert(this.tree,s);
  tree.color=Node.B;
  return bool;
 }
 private boolean insert(Node t,int s){
  if(t.data==-1){
   t.data=s;
   t.color=Node.R;
   t.lChild=new Node(-1,Node.B);
   t.rChild=new Node(-1,Node.B);
   c=2;
   return true;
  }else if(t.data>s){
   boolean b=insert(t.lChild,s);
   if(b&&c!=0){
    switch(c){
     case 2: tc=0;if(t.color==Node.B)c=0;else c--;break;
     case 1: rbBalance(t,0);break;
    }
   }
   return b;
  }else if(t.data<s){
   boolean b=insert(t.rChild,s);
   if(b&&c!=0){
    switch(c){
     case 2:tc=1;if(t.color==Node.B)c=0;else c--;break;
     case 1:rbBalance(t,1);break;
    }
   }
   return b;
  }
  return false;
 }
 private void rbBalance(Node t,int d){
  c=0;
  if(t.lChild.color==Node.R&&t.rChild.color==Node.R){
   t.color=Node.R;
   t.lChild.color=t.rChild.color=Node.B;
   c=2;
  }else{
   if(d==0){
     switch(tc){
    case 0: rRotate(t);break;
    case 1: lRotate(t.lChild);rRotate(t);break;
     }
      }
      else{
     switch(tc){
    case 0: rRotate(t.rChild);lRotate(t);break;
    case 1: lRotate(t);break;
     }
      }
      t.lChild.color=t.rChild.color=Node.R;
  }
 }
 private void lRotate(Node t){
  Node p=t.rChild;
  int temp=p.data;
  p.data=t.data;
  t.data=temp;
  t.rChild=p.rChild;
  p.rChild=p.lChild;
  p.lChild=t.lChild;
  t.lChild=p;
 }
 private void rRotate(Node t){
  Node p=t.lChild;
  int temp=t.data;
  t.data=p.data;
  p.data=temp;
  t.lChild=p.lChild;
  p.lChild=p.rChild;
  p.rChild=t.rChild;
  t.rChild=p;
 }


 /**show()用来按顺序显示数据
 */
 public void show(){
  IO.p.println("The natural order is: ");
     Node[] stack=new Node[100];
  int top=0;
  if(this.tree.data!=-1)
  stack[top++]=this.tree;
  while(top>0){
      Node n1;
   while((n1=stack[top-1]).data!=-1) stack[top++]=n1.lChild;
   top--;
   if(top>0){
    Node n2=stack[--top];
    IO.p.print("<"+n2.data+","+n2.color()+">   ");
    stack[top++]=n2.rChild;
   }
  }
  IO.p.println();
 }


 /**gShow()用凹凸法显示树
 */
    public void gShow(){
  IO.p.println("This tree's view is:");
  Node[] n=new Node[100];
  int[] is=new int[100];
  int top=0;
  n[top++]=this.tree;
  while(top>0){
   switch(is[top-1]){
    case 0: IO.p.println(bank(top)+n[top-1].data);is[top-1]++;
            if(n[top-1].lChild!=null){n[top]=n[top-1].lChild;top++;}break;
    case 1: is[top-1]++;if(n[top-1].rChild!=null){n[top]=n[top-1].rChild;top++;}break;
    case 2: is[--top]=0;
   }
  }
 }
 private String bank(int i){
  String s="";
  while(i>1){s+=".";i--;}
  return s;
 }

 /**blackH()用来计算黑色高度
 */
 public void blackH(){
  IO.p.println("This tree black height is:"+blackH(this.tree));
 }
 private int blackH(Node t){
  if(t.data!=-1){
   int h=0;
   if(t.color==Node.R) h=0; else h=1;
   int l=blackH(t.lChild);
   int r=blackH(t.rChild);
   if(l==-1||r==-1||l!=r) return -1;
      else return h+l;
  }
  return 0;
 }


 /**delete(int)用来删除数据
 */
 public boolean delete(int s){
  Node p=new Node(-1);
  p.rChild=this.tree;
  boolean b=delete(this.tree,p,1,s);
  this.tree=p.rChild;
  this.tree.color=Node.B;
  return b;
 }
 private boolean delete(Node t,Node p,int d,int s){
  if(t.data==-1) return false;
  if(t.data>s){
   boolean b=delete(t.lChild,t,0,s);
   if(b&&c2==0){
    if(c3.color==Node.R){c3.color=Node.B;c2=1;}
    else{
     leftQuit(t);
    }
   }
   return b;
  }else if(t.data<s){
   boolean b=delete(t.rChild,t,1,s);
            if(b&&c2==0){
    if(c3.color==Node.R){c3.color=Node.B;c2=1;}
    else{
     rightQuit(t);
    }
   }
   return b;
  }else{
   if(t.lChild.data!=-1&&t.rChild.data!=-1){
    Node t1=t.lChild;
    while(t1.rChild.data!=-1) t1=t1.rChild;
    t.data=t1.data;
    t1.data=s;
    delete(t.lChild,t,0,s);
    if(c2==0){
     if(c3.color==Node.R){c3.color=Node.B;c2=1;}
     else leftQuit(t);
       }
   }else{
    c2=0;
    c3=t.lChild;
       if(t.lChild.data==-1) {c3=t.rChild;}
    if(d==0) {p.lChild=c3;} else {p.rChild=c3;}
    if(t.color==Node.R) {c2=1;}
   }
   return true;
  }
 }
 private void leftQuit(Node t){
  Node t1=t.rChild;
  Node t11=t1.lChild,t12=t1.rChild;
  if(t1.color==t11.color&&t11.color==t12.color&&t12.color==Node.B){
   t1.color=Node.R;c3=t;c2=0;
   return;
  }
  if(t1.color==Node.R){
   lRotate(t);
   Node t2=t.lChild.rChild;
   Node t21=t2.lChild,t22=t2.rChild;
   if(t21.color==t22.color&&t22.color==Node.B){
    t2.color=Node.R;
    c3=t.lChild;c3.color=Node.B;
   }
   else{
    if(t22.color==Node.R){
     t22.color=Node.B;
     lRotate(t.lChild);
    }else{
     t21.color=Node.B;
     rRotate(t.lChild.rChild);
     lRotate(t.lChild);
    }
   }
   c2=1;return;
  }
  if(t12.color==Node.R){
   t12.color=Node.B;
   lRotate(t);
  }else{
   t11.color=Node.B;
   rRotate(t1);
   lRotate(t);
  }
  c2=1;
 }
 private void rightQuit(Node t){
  Node t1=t.lChild;
  Node t11=t1.lChild,t12=t1.rChild;
  if(t1.color==t11.color&&t11.color==t12.color&&t12.color==Node.B){
   t1.color=Node.R;c3=t;c2=0;
   return;
  }
  if(t1.color==Node.R){
   rRotate(t);
   Node t2=t.rChild.lChild;
   Node t21=t2.lChild,t22=t2.rChild;
   if(t21.color==t22.color&&t22.color==Node.B){
      t2.color=Node.R;
      c3=t.rChild;c3.color=Node.B;
   }
   else{
    if(t21.color==Node.R){
     t21.color=Node.B;
     rRotate(t.rChild);
    }else{
     t22.color=Node.B;
     lRotate(t.rChild.lChild);
     rRotate(t.rChild);
    }
   }
   c2=1;return;
  }
  if(t11.color==Node.R){
   t11.color=Node.B;
      rRotate(t);
  }else{
   t12.color=Node.B;
   lRotate(t1);
   rRotate(t);
  }
  c2=1;
 }
 public static void main(String[] args){
  RBTree rbt=new RBTree();

  IO.p.print("Input the datas one by one and split by space:");
  int[] is=IO.readInts();//用来输入多个数据，用空格分开
  for(int i:is){
   rbt.insert(i);
  }
  rbt.show();
  rbt.gShow();
  rbt.blackH();
  IO.p.print("The delete node: ");
  is=IO.readInts();//输入要删除的数据，单个
  while(is[0]!=0){
   rbt.delete(is[0]);
   rbt.show();
   rbt.gShow();
   rbt.blackH();

   IO.p.print("The delete node: ");
   is=IO.readInts();
  }
 }
}
class Node{
 static final int R=0,B=1;
 int data;
 Node lChild;
 Node rChild;
 int color;
 Node(int data){
  this.data=data;
 }
 Node(int data,int color){
  this(data);
  this.color=color;
 }
 public String color(){
    return color==0?"Red":"Black";
 }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

//下面是avl树的java实现

import java.util.*;
public class AVLTree{
 int count;
 int[] datas;
 Node tree;
 int tall;
 int low;
 private void lRotate(Node t){
  Node p=t.rChild;
  int temp=p.data;
  p.data=t.data;
  t.data=temp;
  t.rChild=p.rChild;
  p.rChild=p.lChild;
  p.lChild=t.lChild;
  t.lChild=p;
 }
 private void rRotate(Node t){
  Node p=t.lChild;
  int temp=t.data;
  t.data=p.data;
  p.data=temp;
  t.lChild=p.lChild;
  p.lChild=p.rChild;
  p.rChild=t.rChild;
  t.rChild=p;
 }

 //insert(int)用于插入的方法
 public boolean insert(int s){
  Node p=new Node();
  p.rChild=this.tree;
  boolean bool=insert(this.tree,p,1,s);
  this.tree=p.rChild;
  return bool;
 }
 private boolean insert(Node t,Node p,int d,int s){
  if(t==null){
   switch(d){
    case 0:p.lChild=new Node(s);break;
    case 1:p.rChild=new Node(s);break;
   }
   tall=1;return true;
  }else{
   if(t.data==s) {tall=0;return false;}
   if(t.data>s&&insert(t.lChild,t,0,s)){
    if(tall==1){
     switch(t.bf){
      case 0: tall=1;t.bf=1;break;
      case 1: tall=0;leftBalance(t);
      case -1:tall=0;t.bf=0;break;
     }
    }
    return true;
   }
   if(t.data<s&&insert(t.rChild,t,1,s)){
    if(tall==1){
     switch(t.bf){
      case 0: tall=1;t.bf=-1;break;
      case 1: tall=0;t.bf=0;
      case -1:tall=0;rightBalance(t);
     }
    }
    return true;
   }
   return false;
  }
 }
 private void leftBalance(Node t){
  Node p1=t.lChild;
  switch(p1.bf){
   case 1:rRotate(t);t.bf=0;t.rChild.bf=0;break;
   case -1: int tt=p1.rChild.bf;
            lRotate(p1);rRotate(t);t.bf=0;
            switch(tt){
       case 0:t.lChild.bf=t.rChild.bf=0;break;
       case 1:t.lChild.bf=0;t.rChild.bf=-1;break;
       case -1:t.lChild.bf=1;t.rChild.bf=0;break;
      }
  }
 }
 private void rightBalance(Node t){
  Node p1=t.rChild;
  switch(p1.bf){
   case -1:lRotate(t);t.bf=0;t.lChild.bf=0;break;
   case 1:  int tt=p1.lChild.bf;
            rRotate(p1);lRotate(t);t.bf=0;
            switch(tt){
       case 0:t.lChild.bf=t.rChild.bf=0;break;
       case 1:t.lChild.bf=0;t.rChild.bf=-1;break;
       case -1:t.lChild.bf=1;t.rChild.bf=0;break;
      }
  }
 }

 /**gShow()用凹凸法显示树
 */
 public void gShow(){
  IO.p.println("This tree's view is:");
  Node[] n=new Node[100];
  int[] is=new int[100];
  int top=0;
  if(this.tree!=null)
  n[top++]=this.tree;
  while(top>0){
   switch(is[top-1]){
    case 0: IO.p.println(bank(top)+n[top-1].data);is[top-1]++;
            if(n[top-1].lChild!=null){n[top]=n[top-1].lChild;top++;}break;
    case 1: is[top-1]++;if(n[top-1].rChild!=null){n[top]=n[top-1].rChild;top++;}break;
    case 2: is[--top]=0;
   }
  }
 }
 private String bank(int i){
  String s="";
  while(i>1){s+=".";i--;}
  return s;
 }


 //delete(int)用于删除的方法
 public boolean delete(int s){
  Node p=new Node();p.rChild=this.tree;
  boolean bool=delete(this.tree,p,1,s);
  this.tree=p.rChild;
  return bool;
 }
 private boolean delete(Node t,Node p,int d,int s){
  if(t==null) {low=0;return false;}
  if(t.data==s){
   if(t.lChild!=null&&t.rChild!=null){
    Node t1=t.lChild;
    while(t1.rChild!=null){t1=t1.rChild;}
    int temp=t.data;
    t.data=t1.data;
    t1.data=temp;
    delete(t.lChild,t,0,s);
    if(low==1){
      switch(t.bf){
     case 0:t.bf=-1;low=0;break;
     case 1:t.bf=0;low=1;break;
     case -1:low=1;rightBalance(t);
      }
       }
   }else{
    Node t0=null;
       if(t.lChild==null)t0=t.rChild;
       if(t.rChild==null)t0=t.lChild;
       switch(d){
        case 0:p.lChild=t0;break;
        case 1:p.rChild=t0;break;
       }
       low=1;
   }
   return true;
  }
  if(t.data>s){
   if(!delete(t.lChild,t,0,s)) return false;
   if(low==1){
    switch(t.bf){
     case 0:t.bf=-1;low=0;break;
     case 1:t.bf=0;low=1;break;
     case -1:low=1;rightBalance(t);
    }
   }
  }
  if(t.data<s){
   if(!delete(t.rChild,t,1,s)) return false;
   if(low==1){
    switch(t.bf){
     case 0: t.bf=1;low=0;break;
     case -1:t.bf=0;low=1;break;
     case 1:low=1;leftBalance(t);
    }
   }
  }
  return false;
 }
 public void show(){
     IO.p.print("The tree's natural order is: ");
  Node[] stack=new Node[100];
  int top=0;
  stack[top++]=this.tree;
  while(top>0){
   Node n1;
   while((n1=stack[top-1])!=null) stack[top++]=n1.lChild;
   top--;
   if(top>0){
    Node n2=stack[--top];
    IO.p.print("<"+n2.data+","+n2.bf+">   ");
    stack[top++]=n2.rChild;
   }
  }
  IO.p.println();
 }
 public static void main(String[] args){
  AVLTree avl=new AVLTree();
  IO.p.print("Input the datas one by one and split by space:");
  int[] is=IO.readInts();
  for(int i:is) avl.insert(i);
  avl.show();
  avl.gShow();
  IO.p.print("The delete data:");
  is=IO.readInts();
  while(is[0]!=0){
   for(int i:is) avl.delete(i);
      avl.show();
      avl.gShow();
      IO.p.print("The delete data:");
      is=IO.readInts();
  }
 }
}
class Node{
 int data;
 Node lChild;
 Node rChild;
 int bf;
 Node(int data){
  this.data=data;
 }
 Node(){
 }
}

 

 

yxjcaesar
关注
【二叉树进阶】红黑树（Red Black Tree） - 平衡二叉搜索树
codewinter的博客
06-21 3340
红黑树，是一种平衡二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。AVL树和红黑树：红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于AVL树，使得红黑树整体性能略优于AVL树，不然map和set底层怎么会用红黑树呢，包括很多语言的库里面都用了红黑树。如果发明AVL树的人是天才的话，那么发明红
通俗易懂的图解二叉搜索树、AVL树和红黑树
暗色光的博客
07-06 549
搜索是一种很常见的需求，当数据较多时，如何找到目标对象时，即需要搜索查找。 那么如何快速找到目标呢，最朴素的思想就是暴力查找，一个一个对比。 显然，当数据量增大时，我们需要优化查找方法获取更快的查找速度，我们可以通过维护一个有序数组，从而实现二分查找，查找速度从O(n)降为O(longn)。 但是数组并不便于插入和删除，链表便成为了最好的选择。 既然是采用二分查找，那么不如直接按照查找的步骤维护一种数据结构，于是二叉搜索树出现了。 二叉搜索树的性质为： 若左子树不为空，则左子树上所有节点值都小于根结点值；
BTree概念及RBTree实现（JAVA）
qq_41587409的博客
04-25 671
了解一下B树 在实现红黑树之前先了解一下B树，因为红黑树的一些操作的实现和B树关系密切。 B树概念： m阶b树的性质（m>=2） ps:b树里面只有叶子节点和度>=2的节点 b树的搜索 b树的添加 m阶b树添加上溢 当一个节点的元素个数等于m时会造成添加上溢 m阶b树删除 a 删除的节点是叶子节点 b 删除的节点是非叶子节点 c 删除下溢 注意：将父节点元素b挪下来和左右子节点合并，可...
java二叉树红黑树_【转】数据结构-AVL树（平衡二叉树）与红黑树（RBTree）的对比...
weixin_42132325的博客
02-26 137
(一)简介1. AVL树：一棵AVL树或者是空树，或者是具有下列性质的二叉查找树——它的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。e.g. 2. 红黑树是一种二叉树，同时它还满足下列5个特性：每个结点是红色或者黑色的。根结点是黑色的。每个空结点(NULL/NIL)是黑色的。(这里将空结点作为一个特殊的结点对待，设定他们必须是黑色的。)如果一个结点是红色的，则它的左右子...
java——红黑树 RBTree
dengyunhui1210的博客
11-06 180
对于完全随机的数据，普通的二分搜索树就很好用，只是在极端情况下会退化成链表。 对于查询较多的情况，avl树很好用。 红黑树牺牲了平衡性，但是它的统计性能更优（综合增删改查所有的操作）。 红黑树java实现（不完整，没有进行删除节点的操作）： （默认左倾红黑树） package RedBlackTree; //从任意一个节点到叶子节点，经过的黑色节点是一样的——红黑树是...
RBTree（红黑树）
wangpengcsdn1的博客
06-05 990
红黑树 红黑树（Red Black Tree）和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡。 红黑树是一颗二叉搜索树，它的每一个节点增加了一个存储位用来表示颜色，可以是Red也可以是Black，通过对任意一条根到叶子节点的颜色来约束，红黑树保证最长路径是最短路径的两倍，因此近似平衡； 红黑树的性质： 1：每个节点不是红色就是黑色 2：根节点是黑色 3：
红黑树插入删除归类
beyond
04-03 2438
本文直接从该博客转载而来：http://blog.csdn.net/eric491179912/article/details/6179908 原创地址文中有，不加注。     介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonida
AVL树与红黑树（RBTree）的概念与区别
霜迟的博客
08-15 2967
要想了解AVL树与红黑树的区别，首先我们要先知道，这两棵树是属于自平衡二叉树，那么什么是平衡二叉树呢？ 一、平衡二叉树 二叉树的每一个节点的左右子树的深度差不超过1。 二、如何实现自平衡？ 通过旋转，旋转分为四种类型 1、LL型（右旋）：在左子树的左孩子上添加新的节点 2、RR型（左旋）：在右子树的右孩子上添加新的节点 3、LR型（先左旋（失衡子树）再右旋）：在左子树的右孩子上添加新节点 4、RL型（先右旋（失衡子树）再左旋）：在右子树的左孩子上添加新节点 三、AVL树 AVL树是带有平衡条件的二
红黑树、二叉平衡树、二叉排序树的java实现
11-29
本项目涵盖了三种重要的树形数据结构的Java实现：红黑树（RBTree）、二叉平衡树（AVLTree）以及二叉排序树（BSTree）。这些数据结构在处理大量数据时，能够提供高效的插入、删除和查找操作，广泛应用于数据库索引、...
红黑树(RBtree)实现代码
02-17
红黑树（Red-Black Tree，简称RB树）是一种自平衡的二叉查找树，它在数据结构领域中有着广泛的应用。红黑树的主要特性是每个节点都带有颜色属性，可以是红色或黑色，通过这些颜色规则来确保树的平衡性，从而在插入、...
平衡二叉排序树、AVL树、红黑树、B树、B+树
qq_37997523的博客
03-08 748
1、平衡二叉排序树 　 二叉查找树定义：又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 　　1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 　　2) 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； 　　3) 左、右子树也分别为二叉排序树； 　　4) 没有键值相等的节点。 ...
Java基础-红黑树(RBTree)学习与ArrayList,HashSet性能比较
Kuang_2014的专栏
04-10 1071
这两天都在看红黑树，第一次听说这种数据结构是在大学，当时听不大懂，第二次是在一篇博客上面了解到，当时是分析的jdk1.8的ConcurrentHashMap当某一个链表的节点数达到8个会采用红黑树的数据结构，当时没看懂，后面查看很多博客，也翻阅了数据结构的书，稍微理解了很多。概念和源码二叉树：二叉树是一个连通的无环图，并且每一个顶点的度不大于3。有根二叉树还要满足根结点的度不大于2。有了根结点之后...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 208
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 455
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 895
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 556
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 804
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 890
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
构建与平衡二叉搜索树AVL
"这篇资料是关于创建平衡二叉树的，特别是AVL树的实现。提供的代码包含了数据结构定义、基本操作函数以及旋转操作。" ...通过这些函数，可以进一步实现AVL树的插入和删除功能，同时保持树的平衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值