लाल-काला ट्री

कंप्यूटर विज्ञान में, लाल-काला पेड़ एक विशेष बाइनरी खोज पेड़ डेटा संरचना है जो तेजी से भंडारण और ऑर्डर की गई जानकारी की पुनर्प्राप्ति के लिए जाना जाता है, और यह गारंटी देता है कि संचालन एक ज्ञात समय के भीतर पूरा हो जाएगा। अन्य स्व-संतुलन बाइनरी खोज पेड़ों की तुलना में, लाल-काले पेड़ में नोड्स लाल और काले रंग का प्रतिनिधित्व करने वाले रंग नामक एक अतिरिक्त बिट रखते हैं जिसका उपयोग पेड़ को पुन: व्यवस्थित करते समय यह सुनिश्चित करने के लिए किया जाता है कि यह हमेशा लगभग संतुलित रहता है। जब पेड़ को संशोधित किया जाता है, तो नए पेड़ को पुन: व्यवस्थित किया जाता है और रंग गुणों को बहाल करने के लिए उसे फिर से रंगा जाता है, जिससे यह पता चलता है कि सबसे खराब स्थिति में पेड़ कितना असंतुलित हो सकता है। गुणों को इस प्रकार डिज़ाइन किया गया है कि यह पुनर्व्यवस्थित करना और पुनः रंगना कुशलतापूर्वक किया जा सकता है।

(पुनः)संतुलन सही नहीं है, लेकिन बिग ओ अंकन  समय में खोज की गारंटी देता है $$O(\log n)$$, कहाँ $$n$$ पेड़ में प्रविष्टियों (या कुंजियों) की संख्या है। पेड़ को पुनर्व्यवस्थित करने और फिर से रंगने के साथ-साथ सम्मिलित करने और हटाने की कार्रवाई भी की जाती है $$O(\log n)$$ समय। प्रत्येक नोड के रंग को ट्रैक करने के लिए प्रति नोड केवल एक बिट जानकारी की आवश्यकता होती है क्योंकि केवल दो रंग होते हैं। पेड़ में लाल-काला पेड़ होने के कारण विशिष्ट कोई अन्य डेटा शामिल नहीं है, इसलिए इसकी मेमोरी फ़ुटप्रिंट क्लासिक (बिना रंग वाले) बाइनरी खोज पेड़ के लगभग समान है। कुछ मामलों में, अतिरिक्त जानकारी को बिना किसी अतिरिक्त मेमोरी लागत के संग्रहीत किया जा सकता है।

इतिहास
1972 में, रूडोल्फ बायर एक डेटा संरचना का आविष्कार किया जो बी-वृक्ष  का एक विशेष ऑर्डर-4 केस था। इन पेड़ों ने समान संख्या में नोड्स के साथ जड़ से पत्ती तक सभी पथ (ग्राफ सिद्धांत) को बनाए रखा, जिससे पूरी तरह से संतुलित पेड़ बने। हालाँकि, वे बाइनरी सर्च ट्री नहीं थे। बायर ने अपने पेपर में उन्हें सममित बाइनरी बी-ट्री कहा और बाद में वे 2-3-4 पेड़ या सिर्फ 2-4 पेड़ के रूप में लोकप्रिय हो गए। 1978 के एक पेपर में, संतुलित पेड़ों के लिए एक द्विवर्णी रूपरेखा, लियोनिदास जे. गुइबास और रॉबर्ट सेडगेविक (कंप्यूटर वैज्ञानिक) ने सममित बाइनरी बी-ट्री से लाल-काले पेड़ की उत्पत्ति की। लाल रंग इसलिए चुना गया क्योंकि यह ज़ेरॉक्स PARC में काम करने के दौरान लेखकों के लिए उपलब्ध रंगीन लेजर प्रिंटर द्वारा निर्मित सबसे अच्छा दिखने वाला रंग था। गुइबास की एक अन्य प्रतिक्रिया में कहा गया है कि यह पेड़ों को चित्रित करने के लिए उनके पास उपलब्ध लाल और काले पेन के कारण था। 1993 में, अर्ने एंडर्सन ने सम्मिलित करने और हटाने के संचालन को सरल बनाने के लिए दाएं झुकाव वाले पेड़ का विचार पेश किया। 1999 में, क्रिस ओकासाकी ने दिखाया कि इन्सर्ट ऑपरेशन को पूरी तरह कार्यात्मक कैसे बनाया जाए। इसके संतुलन कार्य को केवल 4 असंतुलित मामलों और एक डिफ़ॉल्ट संतुलित मामले की देखभाल करने की आवश्यकता है। मूल एल्गोरिदम में 8 असंतुलित मामलों का उपयोग किया गया था, लेकिन उसे घटाकर 6 असंतुलित मामले कर दिया। सेडगेविक ने दिखाया कि इन्सर्ट ऑपरेशन को जावा (प्रोग्रामिंग भाषा) कोड की केवल 46 लाइनों में लागू किया जा सकता है। 2008 में, सेडगेविक ने एंडर्सन के विचार का लाभ उठाते हुए बाएं झुकाव वाले लाल-काले पेड़ का प्रस्ताव रखा, जिसने सम्मिलित करने और हटाने के संचालन को सरल बना दिया। सेडगेविक ने मूल रूप से ऐसे नोड्स की अनुमति दी थी जिनके दो बच्चे लाल हैं, जिससे उनके पेड़ 2-3-4 पेड़ों की तरह हो गए, लेकिन बाद में यह प्रतिबंध जोड़ा गया, जिससे नए पेड़ 2-3 पेड़ों की तरह बन गए। सेडगेविक ने इन्सर्ट एल्गोरिदम को केवल 33 लाइनों में लागू किया, जिससे कोड की उनकी मूल 46 लाइनें काफी छोटी हो गईं।

शब्दावली
लाल-काला पेड़ एक विशेष प्रकार का बाइनरी खोज पेड़ है, जिसका उपयोग कंप्यूटर विज्ञान में तुलनीय डेटा के टुकड़ों को व्यवस्थित करने के लिए किया जाता है, जैसे कि पाठ के टुकड़े या संख्याएं (उदाहरण के लिए आंकड़े 1 और 2 में संख्याएं)। कुंजी और/या डेटा ले जाने वाले नोड्स को अक्सर ट्री (डेटा संरचना) कहा जाता है आंतरिक नोड्स, लेकिन इसे बहुत विशिष्ट बनाने के लिए उन्हें इस आलेख में गैर-शून्य नोड्स भी कहा जाता है।

लाल-काले पेड़ों की पत्ती नोड्स (  NIL   चित्र 1 में) में कुंजी या डेटा नहीं है। इन पत्तों को कंप्यूटर मेमोरी में स्पष्ट व्यक्ति होने की आवश्यकता नहीं है: एक NULL पॉइंटर - जैसा कि सभी बाइनरी ट्री डेटा संरचनाओं में होता है - इस तथ्य को एनकोड कर सकता है कि (पैरेंट) नोड में इस स्थिति में कोई चाइल्ड नोड नहीं है। फिर भी, पेड़ में अपनी स्थिति के अनुसार, ये वस्तुएं अन्य नोड्स के संबंध में हैं जो आरबी-संरचना के लिए प्रासंगिक हैं, इसमें माता-पिता, भाई-बहन (यानी, माता-पिता का दूसरा बच्चा), चाचा, यहां तक ​​​​कि हो सकते हैं भतीजा नोड; और बच्चा हो सकता है—लेकिन किसी अन्य नोड का अभिभावक कभी नहीं। इन अंत-पथ वाली वस्तुओं के लिए किसी रंग का श्रेय देना वास्तव में आवश्यक नहीं है, क्योंकि स्थिति यही है  या  शर्त से निहित है  (#C-eval भी देखें)।

चित्र 2 इन शून्य पत्तियों के बिना वैचारिक रूप से वही लाल-काला पेड़ दिखाता है। पथ (ग्राफ सिद्धांत) की समान धारणा पर पहुंचने के लिए, किसी को यह ध्यान देना चाहिए कि ई। जी., 3 पथ नोड 1 के माध्यम से चलते हैं, अर्थात् 1 के माध्यम से एक पथleft प्लस 1 के माध्यम से 2 जोड़े गए पथright, अर्थात् 6 से होकर गुजरने वाले रास्तेleft और 6right. इस तरह, पथों के ये सिरे नए नोड्स डालने के लिए डॉकिंग पॉइंट भी हैं, जो पूरी तरह से चित्र 1 के शून्य पत्तों के बराबर हैं।

इसके बजाय, निष्पादन समय की एक मामूली मात्रा को बचाने के लिए, इन (संभवतः कई) शून्य पत्तों को एक अद्वितीय (और काले) सेंटिनल नोड # बाइनरी ट्री में पॉइंटर्स के रूप में लागू किया जा सकता है (नल पॉइंटर के बजाय)।

निष्कर्ष के रूप में, तथ्य यह है कि एक बच्चा मौजूद नहीं है (एक सच्चा नोड नहीं है, इसमें डेटा नहीं है) सभी घटनाओं में एक ही NULL पॉइंटर द्वारा या एक सेंटिनल नोड के लिए एक ही पॉइंटर के रूप में निर्दिष्ट किया जा सकता है। इस पूरे लेख में, किसी भी विकल्प को NIL नोड कहा जाता है और इसमें कॉन्स्टेंट (कंप्यूटर प्रोग्रामिंग) है.

किसी नोड की काली गहराई को जड़ से उस नोड तक काले नोड्स की संख्या (यानी काले पूर्वजों की संख्या) के रूप में परिभाषित किया गया है। लाल-काले पेड़ की काली ऊंचाई जड़ से पत्तियों तक किसी भी पथ में काले नोड्स की संख्या है, जो #req4 द्वारा, स्थिर है (वैकल्पिक रूप से, इसे किसी भी पत्ती नोड की काली गहराई के रूप में परिभाषित किया जा सकता है)। किसी नोड की काली ऊँचाई उसके द्वारा जड़ित उपवृक्ष की काली ऊँचाई है। इस आलेख में, NIL नोड की काली ऊंचाई 0 पर सेट की जाएगी, क्योंकि इसका उपट्री खाली है जैसा कि चित्र 2 में सुझाया गया है, और इसकी पेड़ की ऊंचाई भी 0 है।

गुण
बाइनरी सर्च ट्री पर लगाई गई आवश्यकताओं के अलावा निम्नलिखित को भी संतुष्ट किया जाना चाहिए red–black tree:


 * 1) प्रत्येक नोड या तो लाल या काला है।
 * 2) सभी शून्य नोड्स (चित्र 1) को काला माना जाता है।
 * 3) लाल नोड में लाल बच्चा नहीं होता है।
 * 4) किसी दिए गए नोड से उसके किसी भी वंशज NIL नोड तक प्रत्येक पथ (ग्राफ सिद्धांत) समान संख्या में काले नोड्स से होकर गुजरता है।
 * 5) (निष्कर्ष) यदि नोड N में बिल्कुल एक बच्चा है, तो यह एक लाल बच्चा होना चाहिए, क्योंकि यदि यह काला होता, तो इसके NIL वंशज N के NIL बच्चे की तुलना में एक अलग काली गहराई पर बैठेंगे, जो #req4 का उल्लंघन करेगा।

कुछ लेखक, ई. जी। कॉर्मेन और अन्य., पांचवीं आवश्यकता के रूप में दावा करें कि जड़ काली है; लेकिन मेहलहॉर्न और सैंडर्स नहीं या सेडगेविक और वेन। चूँकि जड़ को हमेशा लाल से काले में बदला जा सकता है, इस नियम का विश्लेषण पर बहुत कम प्रभाव पड़ता है। यह आलेख इसे भी छोड़ देता है, क्योंकि यह पुनरावर्ती एल्गोरिदम और प्रमाणों को थोड़ा परेशान करता है।

उदाहरण के तौर पर, प्रत्येक बाइनरी ट्री # बाइनरी ट्री के प्रकार जिसमें केवल काले नोड्स होते हैं, एक लाल-काला पेड़ होता है।

रीड-ओनली ऑपरेशन, जैसे खोज या ट्री ट्रैवर्सल, किसी भी आवश्यकता को प्रभावित नहीं करते हैं। इसके विपरीत, संशोधित संचालन #सम्मिलन और #निकालना: सरल मामले आसानी से आवश्यकताओं 1 और 2 को बनाए रखते हैं, लेकिन अन्य आवश्यकताओं के संबंध में आवश्यकता 3 के उल्लंघन से बचने के लिए कुछ अतिरिक्त प्रयास किए जाने चाहिए, जिन्हें a कहा जाता है लाल-उल्लंघन, या आवश्यकता 4, जिसे ए कहा जाता है काला-उल्लंघन.

आवश्यकताएँ लाल-काले पेड़ों की एक महत्वपूर्ण संपत्ति को लागू करती हैं: जड़ से सबसे दूर की पत्ती तक का रास्ता जड़ से निकटतम पत्ती तक के रास्ते से दोगुने से अधिक लंबा नहीं होता है। परिणाम यह है कि पेड़ ऊंचाई-संतुलित बाइनरी खोज पेड़ है|ऊंचाई-संतुलित। चूंकि मान डालने, हटाने और खोजने जैसे कार्यों के लिए ऊंचाई के अनुपात में सबसे खराब स्थिति वाले समय की आवश्यकता होती है $$h$$ पेड़ की, ऊंचाई पर यह ऊपरी सीमा लाल-काले पेड़ों को सबसे खराब स्थिति में कुशल होने की अनुमति देती है, अर्थात् संख्या में लॉगरिदमिक वृद्धि $$n$$ प्रविष्टियों की, i. इ। $h \in O(\log n)$, जो सामान्य बाइनरी खोज पेड़ों के मामले में नहीं है। गणितीय प्रमाण के लिए अनुभाग #सीमा का प्रमाण देखें।

लाल-काले पेड़, सभी बाइनरी खोज पेड़ों की तरह, अपने तत्वों की काफी कुशल अनुक्रमिक पहुंच (उदाहरण के लिए इन-ऑर्डर ट्रैवर्सल, यानी बाएं-रूट-दाएं क्रम में) की अनुमति देते हैं। लेकिन वे जड़ से पत्ती तक ट्रैवर्सल के माध्यम से स्पर्शोन्मुख रूप से इष्टतम रैंडम एक्सेस का भी समर्थन करते हैं, जिसके परिणामस्वरूप $$O(\log n)$$ खोज समय.

क्रम 4 के बी-पेड़ों की सादृश्यता
एक लाल-काला पेड़ संरचना में क्रम के बी-पेड़ के समान होता है 4, जहां प्रत्येक नोड में 1 और 3 मान और (तदनुसार) 2 और 4 चाइल्ड पॉइंटर्स के बीच हो सकते हैं। ऐसे बी-ट्री में, प्रत्येक नोड में लाल-काले पेड़ के काले नोड में मान से मेल खाने वाला केवल एक मान होगा, एक ही नोड में इसके पहले और/या बाद में एक वैकल्पिक मान होगा, दोनों एक समान लाल नोड से मेल खाएंगे लाल-काला पेड़.

इस तुल्यता को देखने का एक तरीका लाल-काले पेड़ के ग्राफिकल प्रतिनिधित्व में लाल नोड्स को ऊपर ले जाना है, ताकि वे एक क्षैतिज क्लस्टर बनाकर, अपने मूल काले नोड के साथ क्षैतिज रूप से संरेखित हों। बी-ट्री में, या लाल-काले पेड़ के संशोधित ग्राफिकल प्रतिनिधित्व में, सभी पत्ती नोड्स एक ही गहराई पर हैं।

लाल-काला पेड़ तब संरचनात्मक रूप से क्रम 4 के बी-पेड़ के बराबर होता है, जिसमें 3 मानों की अधिकतम क्षमता के साथ प्रति क्लस्टर 33% मूल्यों का न्यूनतम भरण कारक होता है।

हालाँकि, यह बी-ट्री प्रकार अभी भी लाल-काले पेड़ की तुलना में अधिक सामान्य है, क्योंकि यह लाल-काले पेड़ के रूपांतरण में अस्पष्टता की अनुमति देता है - क्रम 4 के समकक्ष बी-पेड़ से कई लाल-काले पेड़ों का उत्पादन किया जा सकता है (चित्र 3 देखें) ). यदि बी-ट्री क्लस्टर में केवल 1 मान है, तो यह न्यूनतम, काला है, और इसमें दो चाइल्ड पॉइंटर्स हैं। यदि किसी क्लस्टर में 3 मान हैं, तो केंद्रीय मान काला होगा और उसके किनारों पर संग्रहीत प्रत्येक मान लाल होगा। हालाँकि, यदि क्लस्टर में दो मान हैं, तो उनमें से कोई भी लाल-काले पेड़ में काला नोड बन सकता है (और दूसरा लाल होगा)।

तो ऑर्डर-4 बी-ट्री यह नहीं बनाए रखता है कि प्रत्येक क्लस्टर में कौन सा मान पूरे क्लस्टर के लिए मूल काला पेड़ है और उसी क्लस्टर में अन्य मानों का जनक है। इसके बावजूद, लाल-काले पेड़ों पर परिचालन समय के मामले में अधिक किफायती है क्योंकि आपको मूल्यों के वेक्टर को बनाए रखने की आवश्यकता नहीं है। यदि मानों को संदर्भ द्वारा संग्रहीत करने के बजाय सीधे प्रत्येक नोड में संग्रहीत किया जाता है तो यह महंगा हो सकता है। हालाँकि, बी-ट्री नोड्स अंतरिक्ष में अधिक किफायती हैं क्योंकि आपको प्रत्येक नोड के लिए रंग विशेषता को संग्रहीत करने की आवश्यकता नहीं है। इसके बजाय, आपको यह जानना होगा कि क्लस्टर वेक्टर में किस स्लॉट का उपयोग किया जाता है। यदि मान संदर्भ द्वारा संग्रहीत किए जाते हैं, उदा. जी। ऑब्जेक्ट, शून्य संदर्भों का उपयोग किया जा सकता है और इसलिए क्लस्टर को एक वेक्टर द्वारा दर्शाया जा सकता है जिसमें वैल्यू पॉइंटर्स के लिए 3 स्लॉट और पेड़ में चाइल्ड रेफरेंस के लिए 4 स्लॉट होते हैं। उस स्थिति में, बी-ट्री मेमोरी में अधिक कॉम्पैक्ट हो सकता है, जिससे डेटा स्थानीयता में सुधार हो सकता है।

वही सादृश्य बड़े ऑर्डर वाले बी-पेड़ों के साथ बनाया जा सकता है जो संरचनात्मक रूप से रंगीन बाइनरी पेड़ के बराबर हो सकते हैं: आपको बस अधिक रंगों की आवश्यकता है। मान लीजिए कि आप नीला जोड़ते हैं, तो नीला-लाल-काला पेड़ लाल-काले पेड़ की तरह परिभाषित होता है लेकिन अतिरिक्त बाधा के साथ कि पदानुक्रम में कोई भी दो क्रमिक नोड नीले नहीं होंगे और सभी नीले नोड लाल नोड के बच्चे होंगे, तो यह एक बी-ट्री के बराबर हो जाता है जिसके क्लस्टर में निम्नलिखित रंगों में अधिकतम 7 मान होंगे: नीला, लाल, नीला, काला, नीला, लाल, नीला (प्रत्येक क्लस्टर के लिए, अधिकतम 1 ब्लैक नोड, 2 लाल नोड होंगे), और 4 नीले नोड्स)।

मूल्यों की मध्यम मात्रा के लिए, रंगीन बाइनरी ट्री में सम्मिलन और विलोपन बी-ट्री की तुलना में तेज़ होते हैं क्योंकि रंगीन पेड़ नोड्स के प्रत्येक क्षैतिज क्लस्टर के भरण कारक को अधिकतम करने का प्रयास नहीं करते हैं (रंगीन बाइनरी में केवल न्यूनतम भरण कारक की गारंटी होती है) पेड़, समूहों के विभाजन या जंक्शनों की संख्या को सीमित करते हुए)। बी-ट्री, पेड़ का घूमना  करने के लिए तेज़ होंगे (क्योंकि रंगीन बाइनरी ट्री में कई अलग-अलग नोड्स के बजाय रोटेशन अक्सर एक ही क्लस्टर के भीतर होंगे)। हालाँकि, बड़ी मात्रा में भंडारण के लिए, बी-ट्री बहुत तेज़ होंगे क्योंकि वे एक ही क्लस्टर में कई बच्चों को समूहित करके अधिक कॉम्पैक्ट होंगे जहाँ उन्हें स्थानीय रूप से पहुँचा जा सकता है।

समूहों के औसत भरण कारकों को बढ़ाने के लिए बी-ट्री में संभव सभी अनुकूलन समतुल्य बहुरंगी बाइनरी ट्री में संभव हैं। विशेष रूप से, संरचनात्मक रूप से समतुल्य बी-ट्री में औसत भरण कारक को अधिकतम करना गैर-काले नोड्स की संख्या में वृद्धि करके, बहुरंगी पेड़ की कुल ऊंचाई को कम करने के समान है। सबसे खराब स्थिति तब होती है जब रंगीन बाइनरी ट्री में सभी नोड्स काले होते हैं, सबसे अच्छी स्थिति तब होती है जब उनमें से केवल एक तिहाई काले होते हैं (और अन्य दो तिहाई लाल नोड्स होते हैं)।

अनुप्रयोग और संबंधित डेटा संरचनाएँ
लाल-काले पेड़ सम्मिलन समय, विलोपन समय और खोज समय के लिए सबसे खराब स्थिति की गारंटी देते हैं। यह न केवल उन्हें वास्तविक समय कंप्यूटिंग जैसे समय-संवेदनशील अनुप्रयोगों में मूल्यवान बनाता है|वास्तविक समय अनुप्रयोगों, बल्कि यह उन्हें अन्य डेटा संरचनाओं में मूल्यवान बिल्डिंग ब्लॉक बनाता है जो सबसे खराब स्थिति की गारंटी प्रदान करते हैं; उदाहरण के लिए, कम्प्यूटेशनल ज्यामिति में उपयोग की जाने वाली कई डेटा संरचनाएं लाल-काले पेड़ों पर आधारित हो सकती हैं, और वर्तमान लिनक्स कर्नेल और एपोल  सिस्टम कॉल कार्यान्वयन में उपयोग किए जाने वाले  पूर्णतया निष्पक्ष अनुसूचक  पर आधारित हो सकती हैं। लाल-काले पेड़ों का उपयोग करता है।

एवीएल वृक्ष एक अन्य संरचना का समर्थन करता है $$O(\log n)$$ खोजना, सम्मिलित करना और हटाना। एवीएल पेड़ों का रंग लाल-काला हो सकता है, इस प्रकार ये आरबी पेड़ों का एक उपसमूह हैं। सबसे खराब स्थिति वाली ऊंचाई आरबी पेड़ों की सबसे खराब स्थिति वाली ऊंचाई का 0.720 गुना है, इसलिए एवीएल पेड़ अधिक कठोरता से संतुलित होते हैं। 79 रनों में यथार्थवादी परीक्षण मामलों के साथ बेन पफैफ के प्रदर्शन माप में एवीएल से आरबी अनुपात 0.677 और 1.077 के बीच, माध्यिका 0.947 और ज्यामितीय माध्य 0.910 पाया गया। WAVL पेड़ों का प्रदर्शन उन दोनों के बीच में होता है।

लाल-काले पेड़ कार्यात्मक प्रोग्रामिंग में भी विशेष रूप से मूल्यवान हैं, जहां वे सबसे आम लगातार डेटा संरचनाओं में से एक हैं, जिनका उपयोग सहयोगी सरणी और सेट (कंप्यूटर विज्ञान) बनाने के लिए किया जाता है जो उत्परिवर्तन के बाद पिछले संस्करणों को बनाए रख सकते हैं। लाल-काले पेड़ों के लगातार संस्करण की आवश्यकता होती है $$O(\log n)$$ समय के अतिरिक्त, प्रत्येक सम्मिलन या विलोपन के लिए स्थान।

प्रत्येक 2-3-4 पेड़|2-4 पेड़ के लिए, समान क्रम में डेटा तत्वों के साथ संबंधित लाल-काले पेड़ होते हैं। 2-4 पेड़ों पर सम्मिलन और विलोपन ऑपरेशन भी लाल-काले पेड़ों में रंग-फ़्लिपिंग और घुमाव के बराबर हैं। यह 2-4 पेड़ों को लाल-काले पेड़ों के पीछे के तर्क को समझने के लिए एक महत्वपूर्ण उपकरण बनाता है, और यही कारण है कि कई परिचयात्मक एल्गोरिदम पाठ लाल-काले पेड़ों से ठीक पहले 2-4 पेड़ों का परिचय देते हैं, भले ही 2-4 पेड़ों का अक्सर उपयोग नहीं किया जाता है अभ्यास।

2008 में, रॉबर्ट सेडगेविक (कंप्यूटर वैज्ञानिक) ने लाल-काले पेड़ का एक सरल संस्करण पेश किया, जिसे बाईं ओर झुका हुआ लाल-काला पेड़ कहा जाता है। कार्यान्वयन में स्वतंत्रता की पहले से अनिर्दिष्ट डिग्री को समाप्त करके। एलएलआरबी एक अतिरिक्त अपरिवर्तनीयता बनाए रखता है कि सभी लाल लिंक को सम्मिलित करने और हटाने के अलावा बाईं ओर झुकना चाहिए। लाल-काले पेड़ों को 2-3 पेड़ों के सममितीय बनाया जा सकता है, या 2-4 पेड़, संचालन के किसी भी क्रम के लिए. 2-4 वृक्ष आइसोमेट्री का वर्णन 1978 में सेडगेविक द्वारा किया गया था। 2-4 पेड़ों के साथ, आइसोमेट्री को एक रंग फ्लिप द्वारा हल किया जाता है, जो एक विभाजन के अनुरूप होता है, जिसमें दो बच्चों के नोड्स का लाल रंग बच्चों को छोड़ देता है और मूल नोड में चला जाता है।

टैंगो पेड़ का मूल विवरण, तेज़ खोजों के लिए अनुकूलित एक प्रकार का पेड़, विशेष रूप से अपने डेटा संरचना के हिस्से के रूप में लाल-काले पेड़ों का उपयोग करता है। जावा (प्रोग्रामिंग भाषा) 8 के अनुसार, हैश तालिका  को ऐसे संशोधित किया गया है कि हैश फ़ंक्शन#यूनिफ़ॉर्मिटी  हैश कोड  के साथ विभिन्न तत्वों को संग्रहीत करने के लिए  लिंक्ड सूची  का उपयोग करने के बजाय, एक लाल-काले पेड़ का उपयोग किया जाता है। इसके परिणामस्वरूप ऐसे तत्व को खोजने की समय जटिलता में सुधार होता है $$O(m)$$ को $$O(\log m)$$ कहाँ $$m$$ टकराने वाले हैशकोड वाले तत्वों की संख्या है।

संचालन
लाल-काले पेड़ पर खोज या ट्री ट्रैवर्सल जैसे रीड-ओनली ऑपरेशन को बाइनरी सर्च ट्री के लिए उपयोग किए जाने वाले ऑपरेशन से किसी संशोधन की आवश्यकता नहीं होती है, क्योंकि प्रत्येक लाल-काला पेड़ एक साधारण बाइनरी सर्च ट्री का एक विशेष मामला है। हालाँकि, सम्मिलन या निष्कासन का तत्काल परिणाम लाल-काले पेड़ के गुणों का उल्लंघन कर सकता है, जिसकी बहाली को पुनर्संतुलन कहा जाता है ताकि लाल-काले पेड़ स्व-संतुलन बन जाएं। सबसे खराब स्थिति में इसके लिए एक छोटी संख्या की आवश्यकता होती है, $$O(\log n)$$ बिग ओ नोटेशन में, कहाँ $$n$$ पेड़ में औसतन या परिशोधित वस्तुओं की संख्या है $$O(1)$$, एक स्थिर संख्या,  रंग परिवर्तन (जो व्यवहार में बहुत जल्दी होते हैं); और तीन से अधिक वृक्ष चक्र नहीं (प्रविष्टि के लिए दो). यदि नीचे दिया गया उदाहरण कार्यान्वयन उपयुक्त नहीं है, तो स्पष्टीकरण के साथ अन्य कार्यान्वयन बेन पफ़्फ़ में पाया जा सकता है एनोटेटेड सी लाइब्रेरी GNU libavl (जून 2019 तक v2.0.3)।

सम्मिलित करने और हटाने के संचालन का विवरण उदाहरण C++ कोड के साथ प्रदर्शित किया जाएगा, जो प्रकार परिभाषाओं, नीचे दिए गए मैक्रोज़ और रोटेशन के लिए सहायक फ़ंक्शन का उपयोग करता है:



नमूना कोड और सम्मिलन और निष्कासन के आरेख पर नोट्स
प्रस्ताव प्रविष्टि और निष्कासन (कुछ बहुत ही सरल मामलों का उल्लेख नहीं) दोनों को नोड्स, किनारों और रंगों के छह समूहों में विभाजित करता है, जिन्हें मामले कहा जाता है। प्रस्ताव में सम्मिलन और निष्कासन दोनों के लिए, बिल्कुल एक मामला शामिल है जो एक काले स्तर को जड़ और लूप के करीब ले जाता है, अन्य पांच मामले अपने स्वयं के पेड़ को पुनर्संतुलित करते हैं। अधिक जटिल मामलों को एक आरेख में चित्रित किया गया है।


 * RedNode.svg symbolises a red node and BlackNode.svg a (non-NIL) black node (of black height &ge; 1), RedOrBlackNode.svgगैर-शून्य नोड के लाल या काले रंग का प्रतीक है, लेकिन पूरे आरेख में एक ही रंग है। आरेखों में शून्य नोड्स का प्रतिनिधित्व नहीं किया गया है।
 * वेरिएबल N वर्तमान नोड को दर्शाता है, जिसे   N   या  N   आरेखों में।
 * एक आरेख में तीन कॉलम और दो से चार क्रियाएं होती हैं। बायां कॉलम पहले पुनरावृत्ति को दिखाता है, दायां कॉलम उच्च पुनरावृत्तियों को दिखाता है, मध्य कॉलम किसी मामले के विभाजन को उसके विभिन्न कार्यों में दिखाता है।
 * 1) कार्रवाई प्रविष्टि अपने रंगों के साथ नोड्स के समूह को दिखाती है जो एक मामले को परिभाषित करती है और ज्यादातर कुछ #गुणों का उल्लंघन करती है। एक नीली सीमा वर्तमान नोड एन को रिंग करती है और अन्य नोड्स को एन के साथ उनके संबंध के अनुसार लेबल किया जाता है।
 * 2) यदि पेड़ का घूमना उपयोगी माना जाता है, तो इसे अगली क्रिया में चित्रित किया जाता है, जिसे रोटेशन का लेबल दिया जाता है।
 * 3) यदि कुछ रंग बदलना उपयोगी माना जाता है, तो इसे अगली क्रिया में चित्रित किया जाता है, जिसे रंग लेबल किया जाता है।
 * 4) यदि अभी भी मरम्मत की कुछ आवश्यकता है, तो मामले अन्य मामलों के कोड का उपयोग करते हैं और यह वर्तमान नोड एन के पुन: असाइनमेंट के बाद होता है, जिसमें फिर से एक नीली रिंग होती है और जिसके सापेक्ष अन्य नोड्स को भी पुन: असाइन करना पड़ सकता है। इस क्रिया को पुन: असाइन लेबल किया गया है। दोनों के लिए, सम्मिलित करें और हटाएं, (बिल्कुल) एक मामला है जो रूट के करीब एक काले स्तर को दोहराता है; तब पुन: निर्दिष्ट तारामंडल संबंधित लूप अपरिवर्तनीय को संतुष्ट करता है।
 * A possibly numbered triangle with a black circle atop TriangleTop.svgएक लाल-काले उपवृक्ष का प्रतिनिधित्व करता है (#req3 के अनुसार अपने मूल से जुड़ा हुआ) जिसकी काली ऊंचाई पुनरावृत्ति स्तर शून्य से एक के बराबर है, यानी। ।इ। प्रथम पुनरावृत्ति में शून्य. इसकी जड़ लाल या काली हो सकती है। A possibly numbered triangle TriangleSubtree.svgएक लाल-काले उपवृक्ष का प्रतिनिधित्व करता है जिसकी काली ऊँचाई एक कम है, अर्थात। ।इ। इसके मूल की दूसरी पुनरावृत्ति में काली ऊँचाई शून्य है।


 * टिप्पणी
 * सरलता के लिए, नमूना कोड तार्किक विच्छेदन का उपयोग करता है:
 * और तार्किक संयोजन:
 * इस प्रकार, यह ध्यान में रखा जाना चाहिए कि दोनों कथनों का कुल मिलाकर मूल्यांकन नहीं किया जाता है . फिर दोनों ही मामलों में   छुआ नहीं गया है (शॉर्ट-सर्किट मूल्यांकन देखें)। (टिप्पणी   #consideredblack के अनुरूप है।)
 * संबंधित -यदि प्रस्ताव है तो कथन बहुत कम बार घटित होने चाहिए साकार हो गया है.
 * इस प्रकार, यह ध्यान में रखा जाना चाहिए कि दोनों कथनों का कुल मिलाकर मूल्यांकन नहीं किया जाता है . फिर दोनों ही मामलों में   छुआ नहीं गया है (शॉर्ट-सर्किट मूल्यांकन देखें)। (टिप्पणी   #consideredblack के अनुरूप है।)
 * संबंधित -यदि प्रस्ताव है तो कथन बहुत कम बार घटित होने चाहिए साकार हो गया है.

निवेशन
सम्मिलन नए (गैर-शून्य) नोड, मान लीजिए एन, को एनआईएल नोड के बाइनरी सर्च ट्री में स्थिति पर रखकर शुरू होता है, जिसका इन-ऑर्डर ट्रैवर्सल|इन-ऑर्डर पूर्ववर्ती कुंजी नए नोड की कुंजी से कम तुलना करती है, जो बदले में इसकी इन-ऑर्डर उत्तराधिकारी की कुंजी से कम तुलना की जाती है। (अक्सर, यह स्थिति इंसर्ट ऑपरेशन से ठीक पहले पेड़ के भीतर एक खोज का परिणाम होती है और इसमें एक नोड होता है  एक दिशा के साथ   साथ .) नया डाला गया नोड अस्थायी रूप से लाल रंग का है ताकि सभी पथों में पहले की तरह ही काले नोड्स की संख्या हो। लेकिन यदि इसका जनक, मान लीजिए P, भी लाल है तो यह क्रिया #ViolR|लाल-उल्लंघन का परिचय देती है।

 शून्य RBinsert1( आरबीट्री* टी, // -> लाल-काला पेड़  संरचना आरबीनोड* एन, // -> नोड डाला जाना है  संरचना आरबीनोड* पी, // -> एन का मूल नोड (शून्य हो सकता है)  बाइट डीआईआर) // पी के किनारे (बाएं या दाएं) जहां एन डालना है { संरचना आरबीनोड* जी; // -> पी का मूल नोड संरचना आरबीनोड* यू; // -> एन के चाचा

एन->रंग = लाल; एन->बाएं = शून्य; एन->दाएं = शून्य; एन->पैरेंट = पी; यदि (P == NULL) {// कोई अभिभावक नहीं है टी->रूट = एन; // N पेड़ T की नई जड़ है। वापस करना; // प्रविष्टि पूर्ण } पी->बच्चा[डीआईआर] = एन; // N को P के dir-child के रूप में डालें // (जब तक करें)-लूप की शुरुआत: करना { 

इन्सर्ट ऑपरेशन के रीबैलेंसिंग लूप में निम्नलिखित लूप अपरिवर्तनीय  है:
 * The current node N is [[File:RedNode.svg]](लाल) प्रत्येक पुनरावृत्ति की शुरुआत में।
 * #req3 संभावित अपवाद N←P के साथ सभी जोड़े नोड←पैरेंट के लिए संतुष्ट है जब P भी लाल है (एक #ViolR|N पर लाल-उल्लंघन)।
 * अन्य सभी गुण (#req4 सहित) पूरे पेड़ में संतुष्ट हैं।

सम्मिलित आरेखों पर नोट्स

 * आरेखों में, P का उपयोग N के माता-पिता के लिए, G का उपयोग दादा-दादी के लिए, और U N के चाचा को दर्शाएगा।
 * आरेख मूल नोड P को उसके मूल G के बाएं बच्चे के रूप में दिखाते हैं, भले ही P का दोनों ओर होना संभव है। नमूना कोड साइड वेरिएबल के माध्यम से दोनों संभावनाओं को कवर करता है.
 * एन इंसर्शन नोड है, लेकिन जैसे-जैसे ऑपरेशन आगे बढ़ता है अन्य नोड भी चालू हो सकते हैं (केस #इन्सर्ट केस I2 देखें)।
 * आरेख उन मामलों को दिखाते हैं जहां पी भी लाल है, लाल-उल्लंघन।
 * कॉलम x बच्चे की दिशा में परिवर्तन को इंगित करता है, अर्थात। ।इ। o (बाहरी के लिए) का अर्थ है कि P और N दोनों बाएं या दोनों दाएं बच्चे हैं, जबकि i (आंतरिक के लिए) का अर्थ है कि बच्चे की दिशा P से N की ओर बदलती है।
 * कॉलम समूह पहले उस मामले को परिभाषित करता है, जिसका नाम कॉलम केस में दिया गया है। जिससे खाली छोड़ी गई कोशिकाओं में संभावित मानों को नजरअंदाज कर दिया जाता है। इसलिए #Insert केस I2 के मामले में नमूना कोड N की चाइल्ड दिशाओं की दोनों संभावनाओं को कवर करता है, हालांकि संबंधित आरेख केवल एक दिखाता है।
 * सारांश में पंक्तियों को इस तरह क्रमबद्ध किया गया है कि सभी संभावित आरबी मामलों का कवरेज आसानी से समझ में आ सके।
 * कॉलम रोटेशन इंगित करता है कि क्या रोटेशन पुनर्संतुलन में योगदान देता है।
 * कॉलम असाइनमेंट अगले चरण में प्रवेश करने से पहले एन का असाइनमेंट दिखाता है। यह संभवतः अन्य नोड्स पी, जी, यू के पुन: असाइनमेंट को भी प्रेरित करता है।
 * यदि केस द्वारा कुछ बदला गया है, तो इसे बाद कॉलम समूह में दिखाया जाता है।
 * अगला कॉलम में एक तीर → दर्शाता है कि इस चरण के साथ पुनर्संतुलन पूरा हो गया है। यदि कॉलम बाद बिल्कुल एक मामले को निर्धारित करता है, तो इस मामले को अगले मामले के रूप में दिया जाता है, अन्यथा प्रश्न चिह्न होते हैं।
 * लूप अनुभाग #इन्सर्ट केस I1| में समाहित है केस I1 डालें और #केस I2 डालें| केस I2 डालें, जहां #इंसर्ट केस I2 में पुनर्संतुलन की समस्या बढ़ जाती है $$\Delta h=2$$ पेड़ का स्तर या पेड़ में 1 काला स्तर ऊंचा, इसमें दादा जी नया वर्तमान नोड एन बन जाता है। इसलिए यह अधिकतम होता है $$\tfrac{h}2$$ पेड़ की मरम्मत के लिए पुनरावृत्ति के चरण (जहाँ $$h$$ पेड़ की ऊंचाई है)। क्योंकि प्रत्येक चरण के साथ वृद्धि की संभावना तेजी से कम हो जाती है, कुल पुनर्संतुलन लागत औसतन स्थिर रहती है, वास्तव में #परिशोधन।
 * लूप की बॉडी से, केस #इंसर्ट केस I1 अपने आप बाहर निकल जाता है और #इन्सर्ट केस I4, #इंसर्ट केस I6, #इंसर्ट केस I5|I5 + I6, और #इन्सर्ट केस I3 की शाखाएं बाहर निकल जाती हैं।
 * रोटेशन I6 और I5 + I6 मामलों में होता है - लूप के बाहर। इसलिए, कुल मिलाकर अधिकतम दो घुमाव होते हैं।

केस I1 डालें
वर्तमान नोड का मूल P काला है, इसलिए #req3 कायम है। आवश्यकता 4 #loopInvariantI के अनुसार भी लागू होती है।

केस I2 डालें
यदि माता-पिता पी और चाचा यू दोनों लाल हैं, तो उन दोनों को फिर से काले रंग से रंगा जा सकता है और दादा-दादी जी #req4 को बनाए रखने के लिए लाल हो जाते हैं। चूँकि माता-पिता या चाचा से होकर कोई भी रास्ता दादा-दादी से होकर गुजरना चाहिए, इन रास्तों पर काले नोड्स की संख्या में कोई बदलाव नहीं आया है। हालाँकि, दादा-दादी जी अब आवश्यकता 3 का उल्लंघन कर सकते हैं, यदि उसके पास लाल माता-पिता हैं। G को N में पुनः लेबल करने के बाद #loopInvariantI पूरा हो जाता है ताकि पुनर्संतुलन को एक काले स्तर (= 2 वृक्ष स्तर) पर पुनरावृत्त किया जा सके।

केस I3 डालें
वर्तमान नोड एन पेड़ की (लाल) जड़ है, और सभी आरबी-गुण संतुष्ट हैं।
 * 1) इन्सर्ट केस I2 के लिए निष्पादित किया गया है $$\tfrac{h-1}2$$ समय और अब पेड़ की कुल ऊंचाई 1 गुना बढ़ गई है $$h~.$$

केस I4 डालें
मूल P लाल और मूल है। चूँकि N भी लाल है, आवश्यकता 3 का उल्लंघन होता है। लेकिन P का रंग बदलने के बाद पेड़ RB-आकार में है। पेड़ की काली ऊँचाई 1 से बढ़ जाती है।

केस I5 डालें
मूल P लाल है लेकिन चाचा U काला है। अंतिम लक्ष्य मूल नोड पी को दादा-दादी की स्थिति में घुमाना है, लेकिन यह काम नहीं करेगा यदि एन जी का आंतरिक पोता है (यानी, यदि एन जी के दाएं बच्चे का बायां बच्चा है या दाएं) G) के बाएं बच्चे का बच्चा. ए -rotation P पर वर्तमान नोड N और उसके पैरेंट P की भूमिकाओं को स्विच करता है। रोटेशन N के माध्यम से पथ जोड़ता है (वे जो 2 लेबल वाले सबट्री में हैं, आरेख देखें) और P के माध्यम से पथ हटा देता है (वे जो 4 लेबल वाले सबट्री में हैं)। लेकिन P और N दोनों लाल हैं, इसलिए #req4 संरक्षित है। स्थिति 6 में आवश्यकता 3 को बहाल किया गया है।

केस I6 डालें
वर्तमान नोड N अब निश्चित रूप से G का बाहरी पोता (बाएँ बच्चे का बायाँ या दाएँ बच्चे का दायाँ) होना निश्चित है। अब -rotate G पर, P को G के स्थान पर रखा गया है और P को N और G का माता-पिता बनाया गया है। G काला है और उसका पूर्व बच्चा P लाल है, क्योंकि #req3 का उल्लंघन किया गया है। P और G के रंगों को बदलने के बाद परिणामी पेड़ आवश्यकता 3 को पूरा करता है। #req4 भी संतुष्ट रहता है, क्योंकि काले G से होकर जाने वाले सभी रास्ते अब काले P से होकर गुजरते हैं। क्योंकि एल्गोरिदम सहायक डेटा संरचना का उपयोग किए बिना और सहायक चर के लिए अतिरिक्त भंडारण स्थान की केवल थोड़ी मात्रा का उपयोग किए बिना इनपुट को बदल देता है, यह इन-प्लेस एल्गोरिदम है।

साधारण मामले
लेबल एन वर्तमान नोड को दर्शाता है कि प्रवेश पर वह नोड है जिसे हटाया जाना है।

यदि N वह जड़ है जिसमें गैर-शून्य बच्चा नहीं है, तो इसे NIL नोड द्वारा प्रतिस्थापित किया जाता है, जिसके बाद पेड़ खाली होता है - और आरबी-आकार में।

यदि N के पास बिल्कुल एक गैर-शून्य बच्चा है, तो #con5 के अनुसार, यह एक लाल बच्चा होना चाहिए।

यदि N एक लाल नोड है, तो इसमें बिल्कुल एक गैर-शून्य बच्चा नहीं हो सकता है, क्योंकि इसे #req3 द्वारा काला होना होगा। इसके अलावा, #con5 के अनुसार इसका बिल्कुल एक काला बच्चा नहीं हो सकता। परिणामस्वरूप, लाल नोड एन बिना किसी बच्चे के है और इसे आसानी से हटाया जा सकता है।

यदि एन एक काला नोड है, तो इसमें दो लाल बच्चे, एक लाल बच्चा या कोई भी गैर-शून्य बच्चा नहीं हो सकता है। यदि N के पास एक भी लाल बच्चा है, तो बाद वाले को काले रंग से रंगने के बाद उसे इस बच्चे से बदल दिया जाता है।

यदि N के दो गैर-शून्य बच्चे हैं, तो उसके दाएँ उपवृक्ष में न्यूनतम तत्व के लिए एक अतिरिक्त नेविगेशन (जो कि N का इन-ऑर्डर उत्तराधिकारी है, मान लीजिए) $$\text{y}$$) एन और के बीच कोई अन्य नोड नहीं के साथ एक नोड ढूँढता है $$\text{y}$$ (जैसा कि बाइनरी सर्च ट्री#डिलीशन दिखाया गया है)। यह नोड $$\text{y}$$ उसका कोई बायाँ बच्चा नहीं है और इस प्रकार उसके पास अधिकतम एक गैर-शून्य बच्चा है। अगर $$\text{y}$$ एन के स्थान पर हटाया जाना है, एन और से संबंधित लाल-काला पेड़ डेटा $$\text{y}$$, मैं। ।इ। दो नोड्स के रंग और पॉइंटर्स का आदान-प्रदान करना होगा। (परिणामस्वरूप, संशोधित लाल-काला पेड़ पहले जैसा ही है, सिवाय इसके कि एन और के बीच का क्रम $$\text{y}$$ उलट दिया गया है।) इस विकल्प के परिणामस्वरूप उपरोक्त अधिक सरल मामलों में से एक हो सकता है, लेकिन यदि $$\text{y}$$ बिना बच्चे और काले के हम पहुंचते हैं...

एक काली बिना जड़ वाली पत्ती को हटाना
जटिल मामला तब होता है जब N जड़ नहीं है, उसका रंग काला है और उसकी कोई उचित संतान नहीं है (⇔ केवल NIL संतान)। पहले पुनरावृत्ति में, N को NIL से बदल दिया गया है।

डिलीट ऑपरेशन के पुनर्संतुलन लूप में निम्नलिखित लूप अपरिवर्तनीय है:
 * At the beginning of each iteration the black height of N equals the iteration number minus one, which means that in the first iteration it is zero and that N is a true black node [[File:BlackNode.svg]]उच्चतर पुनरावृत्तियों में.
 * N से होकर जाने वाले पथों पर ब्लैक नोड्स की संख्या विलोपन से पहले की तुलना में एक कम है, जबकि यह अन्य सभी पथों पर अपरिवर्तित है, इसलिए यदि अन्य पथ मौजूद हैं तो P पर #ViolB|ब्लैक-उल्लंघन होता है।
 * अन्य सभी गुण (#req3 सहित) पूरे पेड़ में संतुष्ट हैं।

डिलीट डायग्राम पर नोट्स

 * नीचे दिए गए चित्र में, P का उपयोग N के माता-पिता के लिए, S का उपयोग N के भाई-बहन के लिए, C (अर्थात करीबी भतीजा) का उपयोग S के बच्चे के लिए N के समान दिशा में किया गया है, और D (जिसका अर्थ है दूर का भतीजा) ) एस के दूसरे बच्चे के लिए (एस पहले पुनरावृत्ति में शून्य नोड नहीं हो सकता है, क्योंकि इसमें काली ऊंचाई होनी चाहिए, जो इसके हटाए जाने से पहले एन की काली ऊंचाई थी, लेकिन सी और डी शून्य नोड हो सकते हैं)।
 * आरेख वर्तमान नोड N को उसके मूल P के बाएं बच्चे के रूप में दिखाते हैं, भले ही N का दोनों तरफ होना संभव है। कोड नमूने साइड वेरिएबल के माध्यम से दोनों संभावनाओं को कवर करते हैं.
 * हटाने की शुरुआत में (पहले पुनरावृत्ति में), एन हटाए जाने वाले नोड की जगह लेने वाला शून्य नोड है। क्योंकि इसका स्थान मूल में है's node is the only thing of importance, it is symbolised by NilBlue.svg(अर्थ: वर्तमान नोड एन एक शून्य नोड और बायां बच्चा है) डिलीट डायग्राम के बाएं कॉलम में। जैसे-जैसे ऑपरेशन आगे बढ़ता है, उचित नोड्स (काली ऊंचाई ≥ 1) भी चालू हो सकते हैं (उदाहरण देखें केस #डिलीट केस डी2)।
 * By counting the black bullets ([[File:BlackNode.svg]] and [[File:TriangleTop.svg]]) डिलीट आरेख में यह देखा जा सकता है कि N से होकर जाने वाले पथों में अन्य पथों की तुलना में एक गोली कम है। इसका अर्थ है पी पर काला-उल्लंघन - यदि यह मौजूद है।
 * पहले कॉलम समूह में रंग समूह उस केस को परिभाषित करता है, जिसका नाम केस कॉलम में दिया गया है। जिससे खाली छोड़ी गई कोशिकाओं में संभावित मानों को नजरअंदाज कर दिया जाता है।
 * सारांश में पंक्तियों को इस तरह क्रमबद्ध किया गया है कि सभी संभावित आरबी मामलों का कवरेज आसानी से समझ में आ सके।
 * कॉलम रोटेशन इंगित करता है कि क्या रोटेशन पुनर्संतुलन में योगदान देता है।
 * कॉलम असाइनमेंट आगामी पुनरावृत्ति चरण में प्रवेश करने से पहले एन का असाइनमेंट दिखाता है। यह संभवतः अन्य नोड्स पी, सी, एस, डी के पुन: असाइनमेंट को भी प्रेरित करता है।
 * यदि केस द्वारा कुछ बदला गया है, तो इसे बाद कॉलम समूह में दिखाया जाता है।
 * अगला कॉलम में एक तीर → दर्शाता है कि इस चरण के साथ पुनर्संतुलन पूरा हो गया है। यदि कॉलम बाद बिल्कुल एक मामले को निर्धारित करता है, तो इस मामले को अगले मामले के रूप में दिया जाता है, अन्यथा प्रश्न चिह्न होते हैं।
 * लूप अनुभागों में समाहित है  #डिलीट केस D2| के माध्यम से केस D2 हटाएं, जहां पुनर्संतुलन की समस्या बढ़ गई है $$\Delta h=1$$ पेड़ में उच्च स्तर होता है जिसमें मूल पी नया वर्तमान नोड एन बन जाता है। इसलिए इसमें अधिकतम समय लगता है $$h$$ पेड़ की मरम्मत के लिए पुनरावृत्तियाँ (जहाँ $$h$$ पेड़ की ऊंचाई है)। क्योंकि प्रत्येक पुनरावृत्ति के साथ वृद्धि की संभावना तेजी से घट जाती है, कुल पुनर्संतुलन लागत औसतन स्थिर रहती है, वास्तव में #परिशोधन। (बस एक तरफ: मेहलहॉर्न और सैंडर्स बताते हैं: एवीएल पेड़ निरंतर परिशोधन अद्यतन लागत का समर्थन नहीं करते हैं।  यह विलोपन के बाद पुनर्संतुलन के लिए सत्य है, लेकिन AVL प्रविष्टि के लिए नहीं। )
 * लूप की बॉडी से #डिलीट केस D3, #डिलीट केस D6, #डिलीट केस D5|D5 + D6, #डिलीट केस D4, और #डिलीट केस D1; से बाहर निकलने वाली शाखाएँ हैं; अनुभाग #केस हटाएँ D3| केस D3 को हटाएँ, इसकी अपनी D6, D5 और D4 केस की तीन अलग-अलग निकास शाखाएँ हैं।
 * रोटेशन D6 और D5 + D6 और D3 + D5 + D6 के मामलों में होता है - सभी लूप के बाहर। इसलिए, कुल मिलाकर अधिकतम तीन घुमाव होते हैं।

केस डी1 हटाएं
वर्तमान नोड N नया रूट है। प्रत्येक पथ से एक काला नोड हटा दिया गया है, इसलिए आरबी-गुण संरक्षित हैं। पेड़ की काली ऊँचाई 1 से कम हो जाती है।

केस डी2 हटाएं
P, S और S के बच्चे काले हैं। S को लाल रंग से रंगने के बाद S से गुजरने वाले सभी रास्ते, जो कि बिल्कुल वही रास्ते हैं जो N से होकर नहीं गुजरते हैं, उनमें एक काला नोड कम हो जाता है। अब P द्वारा रूट किए गए सबट्री के सभी पथों में ब्लैक नोड्स की संख्या समान है, लेकिन उन पथों की तुलना में एक कम है जो P से नहीं गुजरते हैं, इसलिए #req4 का अभी भी उल्लंघन हो सकता है। P से N तक पुनः लेबल करने के बाद #loopInvariantD पूरा हो जाता है ताकि पुनर्संतुलन को एक काले स्तर (= 1 वृक्ष स्तर) से अधिक पर दोहराया जा सके।

केस डी3 हटाएं
भाई S का रंग लाल है, इसलिए P और भतीजे C और D का रंग काला होना चाहिए। ए -rotation P पर S को N के दादा-दादी में बदल देता है। फिर पी और एस के रंगों को उलटने के बाद, एन के माध्यम से पथ अभी भी एक काला नोड छोटा है। लेकिन N के पास अब एक लाल माता-पिता P है और पुनर्निर्धारण के बाद एक काला भाई-बहन S है, इसलिए D4, D5, या D6 मामलों में परिवर्तन आरबी-आकार को बहाल करने में सक्षम हैं।

केस डी4 हटाएं
भाई-बहन S और S के बच्चे काले हैं, लेकिन P लाल है। S और P के रंगों के आदान-प्रदान से S से गुजरने वाले रास्तों पर काले नोड्स की संख्या प्रभावित नहीं होती है, लेकिन यह N से गुजरने वाले रास्तों पर काले नोड्स की संख्या में एक जोड़ देता है, जिससे उन रास्तों पर हटाए गए काले नोड्स की भरपाई हो जाती है।

केस डी5 हटाएं
भाई S काला है, S का करीबी बच्चा C लाल है, और S का दूर का बच्चा D काला है। बाद एक -rotation S में भतीजा C, S का माता-पिता और N का नया भाई-बहन बन जाता है। S और C के रंगों का आदान-प्रदान होता है। All paths still have the same number of black nodes, but now N has a black sibling whose distant child is red, so the constellation is fit for case D6. Neither N nor its parent P are affected by this transformation, and P may be red or black (आरेख में)।

केस डी6 हटाएं
भाई S काला है, S का दूर का बच्चा D लाल है। बाद एक -rotation P पर भाई-बहन S, P और S का माता-पिता बन जाता है's distant child D. The colors of P and S are exchanged, and D is made black. The whole subtree still has the same color at its root S, namely either red or black (आरेख में), जो परिवर्तन से पहले और बाद में एक ही रंग को संदर्भित करता है। इस तरह #req3 संरक्षित है. उपवृक्ष में पथ जो N से नहीं गुजरते (i.o.w. आरेख में D और नोड 3 से होकर गुजरते हैं) पहले की तरह समान संख्या में काले नोड्स से गुजरते हैं, लेकिन N के पास अब एक अतिरिक्त काला पूर्वज है: या तो P काला हो गया है, या यह था ब्लैक और एस को ब्लैक दादा-दादी के रूप में जोड़ा गया था। इस प्रकार, N से गुजरने वाले पथ एक अतिरिक्त ब्लैक नोड से होकर गुजरते हैं, ताकि #req4 बहाल हो जाए और कुल पेड़ RB-आकार में हो। क्योंकि एल्गोरिदम सहायक डेटा संरचना का उपयोग किए बिना और सहायक चर के लिए अतिरिक्त भंडारण स्थान की केवल थोड़ी मात्रा का उपयोग किए बिना इनपुट को बदल देता है, यह इन-प्लेस एल्गोरिदम है।

सीमा का प्रमाण
के लिए $$h\in\N$$ ऊंचाई का एक लाल-काला पेड़ है $$h$$ साथ

नोड्स ($$\lfloor \, \rfloor$$ फर्श और छत के कार्य हैं) और कम नोड्स के साथ इस पेड़ की ऊंचाई का कोई लाल-काला पेड़ नहीं है - इसलिए यह न्यूनतम है। इसकी काली ऊंचाई है $$\lceil h/2\rceil$$ (काली जड़ के साथ) या विषम के लिए $$h$$ (फिर लाल जड़ के साथ) भी $$(h-1)/2~.$$ एक निश्चित ऊंचाई के लाल-काले पेड़ में नोड्स की न्यूनतम संख्या होने के लिए, इसमें लाल नोड्स की अधिकतम संख्या के साथ बिल्कुल एक सबसे लंबा पथ होना चाहिए, ताकि न्यूनतम काली ऊंचाई के साथ अधिकतम पेड़ की ऊंचाई प्राप्त की जा सके। इस पथ के अलावा अन्य सभी नोड्स को काला करना होगा। यदि इस पेड़ से एक नोड हटा दिया जाता है तो यह या तो ऊंचाई खो देता है या कुछ आरबी संपत्ति खो देता है।
 * $$m_h$$ ||colspan=2| $$= 2^{\lfloor(h+1)/2\rfloor} + 2^{\lfloor h/2 \rfloor} - 2$$
 * rowspan=2| ||rowspan=2;style="vertical-align:bot"| $$= \Biggl\{$$ ||style="vertical-align:top"| $$2 \cdot 2^{\tfrac{h}2}-2 = 2^{\tfrac{h}2+1}-2$$ ||      ||style="vertical-align:bot"| if $$h$$ even
 * style="vertical-align:top"| $$3 \cdot 2^{\tfrac{h-1}2}-2$$ || ||style="vertical-align:bot"| if $$h$$ odd
 * }
 * style="vertical-align:top"| $$3 \cdot 2^{\tfrac{h-1}2}-2$$ || ||style="vertical-align:bot"| if $$h$$ odd
 * }
 * }
 * सबूत

ऊंचाई का आरबी पेड़ $$h=1$$ लाल जड़ के साथ न्यूनतम है. इससे सहमति है
 * $$m_1 = 2^{\lfloor (1+1)/2\rfloor} \!+\!2^{\lfloor 1/2 \rfloor} \!\!-\!\!2 = 2^1\!+\!2^0\!\!-\!\!2 = 1~.$$

एक न्यूनतम आरबी वृक्ष (आरबीh चित्र 4 में) ऊँचाई का $$h>1$$ एक जड़ है जिसके दो बाल उपवृक्ष अलग-अलग ऊंचाई के हैं। उच्चतर चाइल्ड सबट्री भी एक न्यूनतम आरबी ट्री है, RBh–1, जिसमें एक लंबा पथ भी शामिल है जो इसकी ऊंचाई को परिभाषित करता है $h\!\!-\!\!1 $; यह है $$m_{h-1}$$ नोड्स और काली ऊंचाई $$\lfloor(h\!\!-\!\!1)/2\rfloor =: s .$$ दूसरा उपवृक्ष एक बाइनरी ट्री है#(काली) ऊंचाई के बाइनरी पेड़ों के प्रकार $$s$$ रखना $$2^s\!\!-\!\!1=2^{\lfloor(h-1)/2\rfloor}\!\!-\!\!1$$ काला नोड—और कोई लाल नोड नहीं। फिर नोड्स की संख्या गणितीय प्रेरण द्वारा होती है फ़ंक्शन के किसी फ़ंक्शन का ग्राफ़ $$m_h$$ ब्रेकप्वाइंट के साथ उत्तल फ़ंक्शन और टुकड़े-टुकड़े रैखिक फ़ंक्शन है $$(h=2k\;|\;m_{2k}=2 \cdot 2^k\!-\!2)$$ कहाँ $$k \in \N .$$ फ़ंक्शन को इस प्रकार सारणीबद्ध किया गया है $$m_h=$$ A027383(h–1) के लिए $$h\geq 1$$.

असमानता $$9>8=2^3$$ ओर जाता है $$3 > 2^{3/2}$$, जो विषम के लिए है $$h$$ ओर जाता है
 * के लिए फ़ंक्शन को हल करना $$h$$
 * $$m_h = 3 \cdot 2^{(h-1)/2}-2 = \bigl(3\cdot 2^{-3/2}\bigr) \cdot 2^{(h+2)/2}-2 > 2 \cdot 2^{h/2}-2$$.

तो दोनों, सम और विषम स्थिति में, $$h$$ अंतराल में है साथ $$n $$ नोड्स की संख्या होने के नाते. एक लाल-काला पेड़ $$n$$ नोड्स (कुंजियाँ) में पेड़ की ऊंचाई होती है $$h \in O(\log n) .$$
 * निष्कर्ष

संचालन और थोक संचालन सेट करें
सिंगल-एलिमेंट इंसर्ट, डिलीट और लुकअप ऑपरेशंस के अलावा, कई सेट ऑपरेशंस को परिभाषित किया गया है red–black trees: संघ (सेट सिद्धांत), प्रतिच्छेदन (सेट सिद्धांत) और सेट अंतर। फिर इन सेट फ़ंक्शंस के आधार पर सम्मिलन या विलोपन पर तेज़ बल्क ऑपरेशन लागू किया जा सकता है। ये सेट ऑपरेशन दो सहायक ऑपरेशन, स्प्लिट और जॉइन पर निर्भर करते हैं। नए परिचालनों के साथ, लाल-काले पेड़ों का कार्यान्वयन अधिक कुशल और अत्यधिक-समानांतर हो सकता है। अपनी समय की जटिलताओं को प्राप्त करने के लिए इस कार्यान्वयन के लिए आवश्यक है कि रूट को या तो लाल या काला होने की अनुमति दी जाए, और प्रत्येक नोड अपनी स्वयं की काली ऊँचाई संग्रहीत करे।


 * जॉइन: जॉइन फ़ंक्शन दो लाल-काले पेड़ों पर है $t_{1}$ और $t_{2}$ और एक कुंजी $k$, कहाँ $t_{1} < k < t_{2}$, मैं। ।इ। सभी चाबियाँ $t_{1}$ से कम हैं $k$, और सभी कुंजियाँ $t_{2}$से अधिक हैं $k$. यह सभी तत्वों से युक्त एक पेड़ लौटाता है $t_{1}$, $t_{2}$ के रूप में भी $k$.
 * यदि दो पेड़ों की काली ऊंचाई समान है, तो जॉइन बस बाएं उपट्री के साथ एक नया नोड बनाता है $t_{1}$, जड़ $k$ और दायां उपवृक्ष $t_{2}$. अगर दोनों $t_{1}$ और $t_{2}$काली जड़ है, सेट $k$ लाल होना. अन्यथा $k$काले रंग में सेट है.
 * यदि काली ऊँचाई असमान है, तो मान लीजिए $t_{1}$ की तुलना में अधिक काली ऊँचाई है $t_{2}$ (दूसरा मामला सममित है)। जॉइन की दाहिनी रीढ़ का अनुसरण करता है $t_{1}$ एक काले नोड तक $c$, जिसके साथ संतुलित है $t_{2}$. इस बिंदु पर बाएँ बच्चे के साथ एक नया नोड $c$, जड़ $k$ (लाल होने के लिए सेट) और सही बच्चा $t_{2}$ c को प्रतिस्थापित करने के लिए बनाया गया है। नया नोड लाल-काले अपरिवर्तनीय को अमान्य कर सकता है क्योंकि अधिकतम तीन लाल नोड एक पंक्ति में दिखाई दे सकते हैं। इसे डबल रोटेशन के साथ ठीक किया जा सकता है। यदि दोहरा लाल मुद्दा जड़ तक फैलता है, तो गुणों को बहाल करते हुए, जड़ को काला कर दिया जाता है। इस फ़ंक्शन की लागत दो इनपुट पेड़ों के बीच काली ऊंचाई का अंतर है।


 * विभाजन: एक लाल-काले पेड़ को दो छोटे पेड़ों में विभाजित करना, जो कि चाबी से छोटे हों $x$, और वे कुंजी से बड़े हैं $x$, पहले रूट से एक रास्ता डालकर डालें $x$ लाल-काले पेड़ में। इस प्रविष्टि के बाद, सभी मान इससे कम होंगे $x$ पथ के बायीं ओर मिलेगा, और सभी मान इससे बड़े होंगे $x$ दाहिनी ओर मिलेगा. जॉइन लागू करने से, बायीं ओर के सभी उपवृक्षों को नीचे से ऊपर तक मध्यवर्ती नोड्स के रूप में पथ पर कुंजियों का उपयोग करके बाएँ वृक्ष बनाने के लिए नीचे से ऊपर की ओर मर्ज किया जाता है, और दायाँ भाग सममित होता है।
 * कुछ अनुप्रयोगों के लिए, स्प्लिट यदि को दर्शाते हुए एक बूलियन मान भी लौटाता है $x$ पेड़ में दिखाई देता है. स्प्लिट की लागत है $$O(\log n) ,$$ पेड़ की ऊंचाई का क्रम. इस एल्गोरिदम का वास्तव में लाल-काले पेड़ के किसी विशेष गुण से कोई लेना-देना नहीं है, और इसका उपयोग किसी भी पेड़ पर जॉइन ऑपरेशन के साथ किया जा सकता है, जैसे कि एवीएल पेड़।

जॉइन एल्गोरिदम इस प्रकार है:

'फ़ंक्शन' जॉइनराइटआरबी(टीL, के, टीR): यदि (टीL.रंग=काला) और (टीL.ब्लैकहाइट=टीR.ब्लैकहाइट): वापसी नोड(टीL,⟨k,लाल⟩,TR) टी'=नोड(टीL.बाएँ,⟨TL.कुंजी,टीL.color⟩,joinRightRB(TL.सही,के,टीR)) यदि (टीL.रंग=काला) और (T'.right.color=T'.right.right.color=red): टी'.दाएं.दाएं.रंग=काला; वापसी रोटेटलेफ्ट(टी') वापसी टी' /* टी[रेक्टे टी'] */ फ़ंक्शन जॉइनलेफ़्टआरबी(टीL, के, टीR): /* JoinRightRB के लिए सममित */ फ़ंक्शन जॉइन (टीL, के, टीR): यदि टीL.ब्लैकहाइट>टीR.कालाऊंचाई: T'=joinRightRB(TL,के,टीR) यदि (T'.color=red) और (T'.right.color=red): टी'रंग=काला वापसी टी' यदि टीR.ब्लैकहाइट>टीL.कालाऊंचाई: /* सममित */ यदि (टीL.रंग=काला) और (टीR.रंग=काला): वापसी नोड(टीL,⟨k,लाल⟩,TR) वापसी नोड(टीL,⟨के,काला⟩,टीR)

विभाजन एल्गोरिथ्म इस प्रकार है:

फ़ंक्शन विभाजन(टी, के): यदि (T = शून्य) वापसी (शून्य, गलत, शून्य) यदि (k = T.कुंजी) वापसी (T.बाएँ, सत्य, T.दाएँ) यदि (k < T.key): (एल',बी,आर') = विभाजित(टी.बाएं, के) वापसी (L',b,join(R',T.key,T.right)) (एल',बी,आर') = विभाजित(टी.दाएं, के) वापसी (जुड़ें (टी.बाएं, टी.कुंजी, एल'),बी,टी.दाएं)

दो लाल-काले पेड़ों का मिलन $t_{1}$ और $t_{2}$ सेट का प्रतिनिधित्व करना $A$ और $B$, एक लाल-काला पेड़ है $t$ जो प्रतिनिधित्व करता है $A ∪ B$. निम्नलिखित पुनरावर्ती फ़ंक्शन इस संघ की गणना करता है:

फ़ंक्शन यूनियन(t1, टी2): यदि टी1 = शून्य वापसी टी2 यदि टी2 = शून्य वापसी टी1 (एल1,बी,आर1)=विभाजित(t1,टी2।चाबी) proc1=प्रारंभ: टीL=संघ(एल1,टी2।बाएं) proc2=प्रारंभ: टीR=संघ(आर1,टी2।सही) सभी proc1, proc2 प्रतीक्षा करें रिटर्न जॉइन(टीL, टी2.कुंजी, टीR)

यहां, विभाजन को दो पेड़ों को वापस करने के लिए माना जाता है: एक कुंजी को अपनी इनपुट कुंजी से कम रखता है, एक बड़ी कुंजी को रखता है। (एल्गोरिदम लगातार डेटा संरचना है | गैर-विनाशकारी, लेकिन एक इन-प्लेस विनाशकारी संस्करण भी मौजूद है।)

प्रतिच्छेदन या अंतर के लिए एल्गोरिथ्म समान है, लेकिन इसके लिए Join2 हेल्पर रूटीन की आवश्यकता होती है जो कि Join के समान है लेकिन मध्य कुंजी के बिना। यूनियन, इंटरसेक्शन या अंतर के नए कार्यों के आधार पर, या तो एक कुंजी या एकाधिक कुंजी को लाल-काले पेड़ से डाला या हटाया जा सकता है। चूंकि स्प्लिट जॉइन को कॉल करता है, लेकिन सीधे लाल-काले पेड़ों के संतुलन मानदंडों से निपटता नहीं है, ऐसे कार्यान्वयन को आमतौर पर जॉइन-आधारित ट्री एल्गोरिदम कहा जाता है। सम्मिलित-आधारित कार्यान्वयन।

मिलन, प्रतिच्छेद और भेद प्रत्येक की जटिलता है $$O\left(m \log \left({n\over m}+1\right)\right)$$ आकार के दो लाल-काले पेड़ों के लिए $$m$$ और $$n(\ge m)$$. तुलनाओं की संख्या की दृष्टि से यह जटिलता इष्टतम है। अधिक महत्वपूर्ण बात यह है कि चूंकि संघ, प्रतिच्छेदन या अंतर के लिए पुनरावर्ती कॉल एक-दूसरे से स्वतंत्र हैं, इसलिए उन्हें समानांतर एल्गोरिदम के विश्लेषण के साथ समानांतर प्रोग्रामिंग निष्पादित की जा सकती है। $$O(\log m \log n)$$. कब $$m=1$$यदि बड़े पेड़ की जड़ का उपयोग छोटे पेड़ को विभाजित करने के लिए किया जाता है, तो जॉइन-आधारित कार्यान्वयन में एकल-तत्व सम्मिलन और विलोपन के समान कम्प्यूटेशनल निर्देशित अचक्रीय ग्राफ (डीएजी) होता है।

समानांतर एल्गोरिदम
वस्तुओं की क्रमबद्ध सूचियों से लाल-काले पेड़ों के निर्माण के लिए समानांतर एल्गोरिदम निरंतर समय में चल सकते हैं या $$O(\log \log n)$$ समय, कंप्यूटर मॉडल पर निर्भर करता है, यदि उपलब्ध प्रोसेसर की संख्या संख्या के अनुपातिक रूप से आनुपातिक है $$n$$ वस्तुओं की जहां $$n\to\infty$$. तेज़ खोज, सम्मिलन और विलोपन समानांतर एल्गोरिदम भी ज्ञात हैं। जॉइन-आधारित ट्री एल्गोरिदम | लाल-काले पेड़ों के लिए जॉइन-आधारित एल्गोरिदम थोक संचालन के लिए समानांतर हैं, जिसमें यूनियन, इंटरसेक्शन, निर्माण, फ़िल्टर, मैप-रिड्यूस इत्यादि शामिल हैं।

समानांतर थोक संचालन
सम्मिलन, निष्कासन या अद्यतन जैसे बुनियादी संचालन को कई तत्वों के बड़े पैमाने पर प्रक्रिया करने वाले संचालन को परिभाषित करके समानांतर किया जा सकता है। कई बुनियादी परिचालनों के साथ बल्क को संसाधित करना भी संभव है, उदाहरण के लिए बल्क में डालने के लिए तत्व और पेड़ से हटाने के लिए तत्व भी हो सकते हैं।

बल्क ऑपरेशन के लिए एल्गोरिदम केवल लाल-काले पेड़ पर लागू नहीं होते हैं, बल्कि अन्य क्रमबद्ध अनुक्रम डेटा संरचनाओं के लिए भी अनुकूलित किए जा सकते हैं, जैसे 2-3 पेड़, 2-3-4 पेड़ और (ए, बी) - पेड़. निम्नलिखित में बल्क इंसर्ट के लिए अलग-अलग एल्गोरिदम की व्याख्या की जाएगी, लेकिन समान एल्गोरिदम को हटाने और अद्यतन करने के लिए भी लागू किया जा सकता है। बल्क इंसर्ट एक ऑपरेशन है जो अनुक्रम के प्रत्येक तत्व को सम्मिलित करता है $$I$$ एक पेड़ के ऊपर $$T$$.

सम्मिलित-आधारित
इस दृष्टिकोण को प्रत्येक क्रमबद्ध अनुक्रम डेटा संरचना पर लागू किया जा सकता है जो कुशल जुड़ाव और विभाजन-संचालन का समर्थन करता है। सामान्य विचार विभाजन करना है $$I$$ और $$T$$ कई भागों में और इन भागों पर समानांतर में सम्मिलन करें।


 * 1) सबसे पहले थोक $$I$$ सम्मिलित किए जाने वाले तत्वों को क्रमबद्ध किया जाना चाहिए।
 * 2) उसके बाद, एल्गोरिदम विभाजित हो जाता है $$I$$ में $$k \in \mathbb{N}^+$$ पार्ट्स $$\langle I_1, \cdots, I_k \rangle$$ लगभग समान आकार का।
 * 3) अगला पेड़ $$T$$ में विभाजित किया जाना चाहिए $$k$$ पार्ट्स $$\langle T_1, \cdots, T_k \rangle$$ एक तरह से, ताकि हर किसी के लिए $$j \in \mathbb{N}^+ | \, 1 \leq j < k$$ निम्नलिखित बाधाएँ कायम हैं:
 * 4) $$\text{last}(I_j) < \text{first}(T_{j + 1})$$
 * 5) $$\text{last}(T_j) < \text{first}(I_{j + 1})$$
 * 6) अब एल्गोरिदम प्रत्येक तत्व को सम्मिलित करता है $$I_j$$ में $$T_j$$ क्रमानुसार. यह चरण प्रत्येक के लिए किया जाना चाहिए $$j$$तक किया जा सकता है $$k$$ प्रोसेसर समानांतर में.
 * 7) अंत में, परिणामी पेड़ों को पूरे ऑपरेशन का अंतिम परिणाम बनाने के लिए जोड़ा जाएगा।

ध्यान दें कि चरण 3 में विभाजन के लिए बाधाएँ हैं $$I$$ आश्वस्त करें कि चरण 5 में पेड़ों को फिर से जोड़ा जा सकता है और परिणामी क्रम को क्रमबद्ध किया जा सकता है।

छद्म कोड बल्क-इंसर्ट के लिए जॉइन-आधारित एल्गोरिदम का एक सरल विभाजन और जीत कार्यान्वयन दिखाता है। दोनों पुनरावर्ती कॉल समानांतर में निष्पादित की जा सकती हैं। यहां उपयोग किया गया जॉइन ऑपरेशन इस आलेख में बताए गए संस्करण से भिन्न है, इसके बजाय जॉइन-आधारित ट्री एल्गोरिदम#जॉइन2 का उपयोग किया जाता है, जो दूसरे पैरामीटर k को मिस करता है।

बल्कइन्सर्ट(टी, आई, के): मैं की तरह बल्कलइन्सर्टरेक(टी, आई, के) बल्कइन्सर्टरेक(टी, आई, के): यदि k = 1: I में सभी के लिए: T.insert(e) अन्य मी := ⌊आकार(I) / 2⌋ (टी1, _, टी2) := विभाजन(टी, आई[एम]) बल्कइन्सर्टरेक(टी1, मैं[0 .. मी], ⌈k / 2⌉) || बल्कइन्सर्टरेक(टी2, मैं[एम + 1 .. आकार(आई) - 1], ⌊k / 2⌋) टी ← जॉइन2(टी1, टी2)

निष्पादन समय
छंटाई $$I$$ इस विश्लेषण में विचार नहीं किया गया है. बंटवारे और जुड़ने के लिए समानांतर एल्गोरिदम का उपयोग करके इसे बेहतर बनाया जा सकता है। इस मामले में निष्पादन का समय है गणित>\in O\left(\log |T| + \frac{|I|}{k} \log |T|\right).

पाइपलाइनिंग
बल्क ऑपरेशंस को समानांतर करने का एक अन्य तरीका पाइपलाइन (कंप्यूटिंग) दृष्टिकोण का उपयोग करना है। यह बुनियादी ऑपरेशन को संसाधित करने के कार्य को उप-कार्यों के अनुक्रम में तोड़कर किया जा सकता है। कई बुनियादी संचालन के लिए प्रत्येक उप-कार्य को एक अलग प्रोसेसर को सौंपकर उप-कार्यों को समानांतर में संसाधित किया जा सकता है।


 * 1) सबसे पहले थोक $$I$$ सम्मिलित किए जाने वाले तत्वों को क्रमबद्ध किया जाना चाहिए।
 * 2) प्रत्येक तत्व के लिए $$I$$ एल्गोरिथ्म तदनुसार सम्मिलन स्थिति का पता लगाता है $$T$$. यह प्रत्येक तत्व के लिए समानांतर में किया जा सकता है $$\in I$$ तब से $$T$$ इस प्रक्रिया में परिवर्तन नहीं किया जाएगा। अब $$I$$ अनुवर्ती भागों में विभाजित किया जाना चाहिए $$S$$ प्रत्येक तत्व की प्रविष्टि स्थिति के अनुसार। उदाहरण के लिए $$s_{n, \mathit{left}}$$ का परिणाम है $$I$$ इसमें वे तत्व शामिल हैं जिनकी प्रविष्टि स्थिति नोड के बाईं ओर होगी $$n$$.
 * 3) मध्य तत्व $$m_{n, \mathit{dir}}$$ हर बाद का $$s_{n, \mathit{dir}}$$ में डाला जाएगा $$T$$ एक नये नोड के रूप में $$n'$$. यह प्रत्येक के लिए समानांतर में किया जा सकता है $$m_{n, \mathit{dir}}$$ चूंकि परिभाषा के अनुसार प्रत्येक की प्रविष्टि स्थिति $$m_{n, \mathit{dir}}$$ निराला है। अगर $$s_{n, \mathit{dir}}$$ के बाएँ या दाएँ तत्व शामिल हैं $$m_{n, \mathit{dir}}$$, उन्हें बाद के नए सेट में समाहित किया जाएगा $$S$$ जैसा $$s_{n', \mathit{left}}$$ या $$s_{n', \mathit{right}}$$.
 * 4) अब $$T$$ संभवतः जड़ों से पत्तियों तक के रास्तों के अंत में लगातार दो लाल गांठें होती हैं, जिनकी मरम्मत की आवश्यकता होती है। ध्यान दें कि, मरम्मत करते समय, तत्वों की प्रविष्टि स्थिति $$\in S$$ यदि संबंधित नोड्स घूर्णन से प्रभावित होते हैं, तो अद्यतन करना होगा। यदि दो नोड्स में अलग-अलग निकटतम काले पूर्वज हैं, तो उन्हें समानांतर में मरम्मत की जा सकती है। चूंकि अधिकतम चार नोड्स में एक ही निकटतम काला पूर्वज हो सकता है, सबसे निचले स्तर पर नोड्स को समानांतर चरणों की निरंतर संख्या में मरम्मत की जा सकती है। यह चरण क्रमिक रूप से उपरोक्त काले स्तरों पर लागू किया जाएगा जब तक $$T$$ पूरी तरह से मरम्मत की गई है.
 * 5) चरण 3 से 5 तक नए अनुवर्ती चरणों में दोहराया जाएगा $$S$$ खाली है। इस बिंदु पर प्रत्येक तत्व $$\in I$$ डाला गया है. इन चरणों के प्रत्येक अनुप्रयोग को एक चरण कहा जाता है। चूंकि अनुवर्ती की लंबाई में $$S$$ है $$\in O(|I|)$$ और प्रत्येक चरण में अनुवर्ती को आधा-आधा काटा जा रहा है, चरणों की संख्या है $$\in O(\log |I|)$$. चूंकि सभी चरण पेड़ के काले स्तरों से ऊपर बढ़ते हैं, इसलिए उन्हें एक पाइपलाइन में समानांतर किया जा सकता है। एक बार जब एक चरण एक काले स्तर पर प्रसंस्करण समाप्त कर लेता है, तो अगला चरण आगे बढ़ने और उस स्तर पर जारी रखने में सक्षम होता है।

निष्पादन समय
छंटाई $$I$$ इस विश्लेषण में विचार नहीं किया गया है. भी, $$|I|$$ से छोटा माना जाता है $$|T|$$, अन्यथा परिणामस्वरूप पेड़ को खरोंच से बनाना अधिक कुशल होगा।

लोकप्रिय संस्कृति
मिसिंग (कनाडाई टीवी श्रृंखला) के एक एपिसोड में एक लाल-काले पेड़ का सही संदर्भ दिया गया था जैसा कि रॉबर्ट सेडगेविक (कंप्यूटर वैज्ञानिक) ने अपने एक व्याख्यान में कहा था:

यह भी देखें

 * डेटा संरचनाओं की सूची
 * वृक्ष डेटा संरचना
 * पेड़ का घूमना
 * एए वृक्ष, लाल-काले वृक्ष का एक रूप
 * वाम ओर झुका हुआ लाल-काला पेड़
 * एवीएल वृक्ष
 * बी-वृक्ष (2-3 वृक्ष, 2-3-4 वृक्ष, बी+ वृक्ष, बी*-वृक्ष, यूबी-वृक्ष)
 * बलि का बकरा पेड़
 * स्पले पेड़
 * टी-वृक्ष
 * WAVL पेड़

अग्रिम पठन

 * Mathworld: Red–Black Tree
 * San Diego State University: CS 660: Red–Black tree notes, by Roger Whitney

बाहरी संबंध

 * Ben Pfaff: An Introduction to Binary Search Trees and Balanced Trees. Free Software Foundation, Boston 2004, ftp.gnu.org (PDF gzip; 1662 kB)
 * A complete and working implementation in C
 * OCW MIT Lecture on Red-black Trees by Erik Demaine
 * – Visualization of random and pre-sorted data insertions, in elementary binary search trees, and left-leaning red–black trees
 * An intrusive red–black tree written in C++
 * Red–black BSTs in 3.3 Balanced Search Trees
 * Red–black BST Demo