golang 红黑 树

El paquete principal penalizaciones por 

"FMT" Importación 

// golang árbol rojo-negro 
// nodos añadir a lograr una solución justa y un nodo de función de impresión en capas 
// ref: https://www.jianshu.com/p/e136ec79235c 

const ( 
	rojo = 1 
	Negro 2 = 
) 

tipo struct {nodo 
	secundario en el nodo * 
	dejó nodo * 
	padre * nodo 
	clave int 
	int color 
} 

tipo struct {rbtree 
	la raíz nodo * 
	// Número de Miembros la 
	int len 
} 

// En la página Agregar Operación ocurrieron única hoja 
// justo el ignorar SO apos originales padres Hijo de nodo el 
// el color del nodo se añade siempre de color rojo 
FUNC (n- * nodo) addLeft (int clave) {nodo * 
	Add: = new nueva (nodo) 
	add.key = clave
	add.color = Rojo 
	add.parent = n 
	= n.left añaden 
	devoluciones Añadir 
} 

// operación de adición se produjo solamente en la hoja 
// así que simplemente ignorar nodo hijo original de la matriz 
// color del nodo añadido es siempre de color rojo 
func (n * nodo) addRight (int key) * el nodo { 
	add: = new (nodo) 
	add.key = clave 
	add.color = rojo 
	add.parent = n 
	= n.right añadir 
	retorno add 
} 

func (rb * RBTree) rotateLeft (n * nodo) { 
	padres: = n.parent 
	derecha: = n.right 
	n.right = right.left 
	Si right.left = nil { 
		right.left.parent = n 
	} 
	right.left = n 
	n.parent = derecha
	si el padre == nil {  
		right.parent = nil
		rb.root = derecha 
	} else { 
		if n == parent.left { 
			parent.left = derecha 
		} else { 
			parent.right = derecha 
		} 
		right.parent = parent 
	} 
} 

func (rb * RBTree) rotateRight (n * nodo) { 
	padres: = n.parent 
	la izquierda: = n.left 
	n.left = left.right 
	Si left.right = nil { 
		left.right.parent = n 
	} 
	left.right = n 
	n.parent = dejó 
	si el padre == nil { 
		left.parent = nil 
		rb.root = left 
	} else { 
		if n == parent.left { 
			parent.left = left 
		} else { 
			parent.right = left 
		} 
		left.parent = parent 
	} 
} 

Func (rb * RBTree) inserción (int clave) { 
	si rb.root == nil { 
		rb.root = new (nodo) 
		rb.root.key = clave 
		rb.root.color = Negro 
	} else { 
		p, OK : = rb.find (clave) 
		, si bien { 
			// TODO reemplazar nodo de valor 
			de retorno 
		} 
		// aquí p no debe ser nulo 
		si la clave p.key> { 
			add: = p.addLeft (clave) 
			rb.ajustAdd (complemento) 
		} else { 
			add: = p.addRight (clave) 
			rb.ajustAdd (complemento) 
		} 
	} 
	rb.len ++ 
} 

func (rb * RBTree) ajustAdd (agregar nodo *) { 
	t: = añadir 
	t: = add.parent 
	! para p = nil && p.color! = Negro {
		// PP no debe ser cero, puesto que p es de color rojo 
			uncle.color = Negro
		pp: = p.parent 
		// obtener tío 
		tío: = pp.left 
		si pp.left == {p 
			tío = pp.right 
		} 

		si tío == nil || uncle.color == Negro { 
			si p == {pp.left 
				si t == p.right { 
					rb.rotateLeft (p) 
				} 
				rb.rotateRight (pp) 
			} else { 
				si t == p.left { 
					rb.rotateRight (p) 
				} 
				rb.rotateLeft (pp) 
			} 

			pp.color = Red 
			pp.parent.color = Negro 
			descanso 
		} else { 
			// tío debe ser de color rojo 
			p.color = Negro 
			pp.color = Red 
			t = pp 
			p = t. padres 
		} 
	}

	si p == nil { 
		rb.root = t 
		rb.root.color = Negro 
		rb.root.parent = nil 
	} 
} 

// si la segunda vuelta verdadero parámetro, indica encontrado 
// else devolver el nodo padre que la voluntad clave agregarse 
func (rb * RBTree) encontrar (int clave) (* nodo, bool) { 
	si rb.root == nil { 
		retorno nulo, falso 
	} 
	c: = rb.root 
	t: = c 
	para c = nil {! 
		si c.key> tecla { 
			p = c 
			c = c.left 
		} else if c.key tecla <{ 
			p = c 
			c = c.right 
		} else {  
			retorno c , cierto
		} 
	} 
	retorno p, falso 
} 

// sólo para depuración 
func (rb * RBTree) print () { 
	ch: = make (Chan interfaz de {}, 1000) 
	var WG sync.WaitGroup 
	wg.Add (1) 
	ir func () { 
		Defer wg.Done ( ) 
		var dealed int 
		para { 
			selecciona { 
			caso v: = <-CH: 
				si n, OK:. = v (* nodo); {bien 
					si n == nil { 
						seguir 
					} 
					trató ++ 
					de color: = "red" 
					si n.color == Negro { 
						color = "negro" 
					} 
					pos: = "" 
					si n.parent == nil { 
						pos = "raíz" 
					} else if n == n.parent.left { 
						pos = "
					} Else if n == n.parent.right { 
	rb.insertar (3) 
						pos = "derecho"

					Si n.parent! = nil { 
						fmt.Printf ( "% d (p% d, c% s, p% s)", n.key, n.parent.key, color, POS) 
					} else { 
						fmt.Printf ( "% d (p% s, c% s, p% s)", n.key, "", color, pos) 
					} 

					ch <- n.left 
					ch <- n.right 

				} else { 
					fmt.Println ( ) 
					si se trataba == rb.len { 
						retorno 
					} 
					CH <- "siguiente" 
				} 
			} 
		} 
	} () 

	ch <- rb.root 
	ch <- "siguiente" 
	wg.Wait () 
} 

func main () { 
	rb: = new (RBTree) 
	rb.insert (1) 
	rb.insert (2) 
	rb.insert (5) 
	rb.insertar (6)
	rb.insert (4)
	rb.insert (7) 
	rb.insert (8) 
	rb.insert (9) 
	rb.insert (10) 
	rb.insert (11) 
	rb.insert (12) 
	rb.insert (13) 
	rb.print () 
}