红黑树

下面网址中是红黑树很好的教材，很详细。

http://blog.csdn.net/eric491179912/article/details/6179908

另外经典教材就是算法导论中关于红黑树的章节了，以算法导论为主，实在不明白的地方再去网上查找资料。

红黑树是一种特殊的二叉查找树，大家都知道二叉查找树的复杂度最坏情况为O(h)，为了减低最坏情况的复杂度，大神们设计了许多种二叉查找树的改进版本，红黑树便是其中之一，它可以保证在最坏情况下复杂度为O(lgn)，也就是说h < lgn。

红黑树的五个性质

1）每个节点或者是红色，或者是黑色

2）根节点是黑色

3）每个叶子节点是黑色的(此处的叶子节点指的是外部节点)

4）红色节点的两个孩子都是黑色的

5）对于每个节点，从该节点到其子孙叶子节点的所有路径上包含相同数目的黑色节点

红黑树节点的定义

typedef struct node
{
    int color;
    int key;
    struct node *p;//指向父节点
    struct node *left, *right;
 
}RBtreeNode;

与二叉搜索树相比较，多出了2部分，本节点的颜色属性和指向父节点是指针，之所以需要指向父节点是为了后序操作的便利。

红黑树的左旋和右旋

在节点x上左旋，是以x和x的右孩子y之间的轴为支点，旋转结束后x成为y的左孩子；在节点y上右旋，是以y和y的左孩子x之间的轴为支点，旋转结束后y是x的右孩子；如图所示

，理论上与二叉搜索树的旋转没有任何区别

红黑树的插入

假设新插入节点z，我们将其置为红色，可能破坏性质2）和性质4），违反性质2）是因为新插入的点成为了根节点，违反性质4）是因为z->p也是红色；插入z后，从底向上逐层调整树的结构和颜色，使其仍然满足红黑树的性质。既然从底层开始调整，我们可以只考虑违反性质4），当然在调整过程中绝不允许出现违反其他性质的现象。

前提z的父亲是红色

case1--z的叔叔是红色

z的叔叔uncle_z是红色，那z的爷爷肯定是黑色，可以把z的父亲和叔叔置为黑色，z的爷爷置为红色，z <- z的爷爷，然后继续向上操作。

case2--uncle_z是黑色，且z和uncle_z不是同一方向的孩子，即z是左孩子，uncle_z是右孩子；或者z是右孩子，uncle_z是左孩子

　　case2.1--z是左孩子，uncle_z是右孩子，如下面左图所示。我们以z的爷爷为输入，做一次右旋操作，同时把parent_z置为黑色，gparent_z置为红色，整棵树调整结束。

左右分割

　　case2.2--z是右孩子，uncle_z是左孩子，如上面右图所示。我们，以z的爷爷为输入，做一次左旋操作，同时把parent_z置为黑色，gparent_z置为红色，整棵树调整结束。

可以看到，case2.1和case2.2是对称的两种情况。

case3--uncle_z是黑色，且z和uncle_z是同一方向的孩子，即z是左孩子，uncle_z也是左孩子；或者z是右孩子，uncle_z也是右孩子

　　case3.1--z和uncle_z同时是左孩子，如下面左图所示。我们以z的父亲为输入，做一次右旋操作，同时把z置为旋转前z的父亲，变成了case2.2，有木有！！

左右分割

　　case3.2--z和uncle_z同时是右孩子，如上面右图所示。我们以z的父亲为输入，做一次左旋操作，同时把z置为旋转前z的父亲，变成了case2.1。

插入的最后，在把root的颜色置为黑色，完事。

红黑树的删除

假设被删除节点是z，可以找到真正要被删除的节点y，即如果z至多有一个孩子，y等于z；否则y是z的中序后继，此时y至多有一个右孩子；总的说来y至多只有一个右孩子x。如果y是红色，删除y后仍然能够保证红黑树的5个性质；如果y是黑色，可能违反性质2），4），5）。删除y时就是把x代替了y的位置，我们可以给x额外增加一个黑色，使其成为了双黑色和红黑色，这样满足了性质5），但违反性质1）。

如果x是红黑色，我们将其置为黑色，调整结束；

如果x是根节点，我们将其置为黑色，结束；

如果x是双黑色，做必要的旋转和涂色。

假设parent_x为删除节点y后x的父节点，实际上就是y的父节点，那么parent_x一定是有两个孩子的，因为此时y非空，且y是黑色，在不违反性质5）的前提下，y一定有兄弟。令parent_x的另一个孩子为w，即x的兄弟为w

case1--w为黑色，且w的两个孩子都是黑色

因为w是黑色，x是双重黑色，可以同时去掉x和w的黑色，x的父节点增加一重黑色，不会违反性质5），然后把x赋值给x的父节点，继续循环。如下面两幅图所示

左右分割

case2--w是黑色，且w同一方向的孩子是红色，即若w是左孩子，w的左孩子是红色；若w是右孩子，w的右孩子是红色。我们可以通过旋转使x的高度减一，并且在x和x的父亲之间增加一个黑色节点，最后把x置为根节点，循环结束

　　case2.1--w是黑色，w是左孩子，w的左孩子是红色，以w的父节点为输入，做一次左旋，并且做一些颜色涂改

左右分割

　　case2.2--w是黑色，w是右孩子，w的右孩子是红色，以w的父节点为输入，做一次右旋，并且做一些颜色涂改

case3--w是黑色，w同一方向的孩子是黑色，我们可以通过旋转使其转化为case2

　　case3.1--w是黑色，w是左孩子，w的左孩子是黑色，那么右孩子一定是红色，否则就成了case1;以w为输入，做一次右旋，变成了case2.1

左右分割

　　case3.2--w是黑色，w是右孩子，w的右孩子是黑色，那么左孩子一定是红色，否则就成了case1;以w为输入，做一次左旋，变成了case2.2

case4--w是红色的，则w肯定有黑孩子，parent_x是黑色的，以parent_x为输入，做一次左旋，可转变成case1,case2,或者case3

附源代码，另附测试数据的大神博客网址：http://blog.csdn.net/v_JULY_v/article/details/6284050

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

//红黑树基本操作
#include <stdio.h>
#include <list>
 
#define BLACK 0
#define RED 1
typedef struct node
{
    int color;
    int key;
    struct node *p;
    struct node *left, *right;
 
}treeNode;
 
//在节点x上左旋操作，以x和x右孩子之间的轴为支点，旋转结束后x成为y的左孩子
//      x                  y
//     / \   left_rotate  / \ 
//    lx  y     --->     x  ry
//       / \            / \
//      ly ry          lx ly
treeNode* left_rotate(treeNode* root, treeNode* x)
{
    treeNode *y = x->right;
    x->right = y->left;
    if(y->left != NULL)
        (y->left)->p = x;
    y->p = x->p;
    if(x->p == NULL)//x是根节点
        root = y;
    else if(x == (x->p)->left)
        (x->p)->left = y;
    else (x->p)->right = y;
    y->left = x;
    x->p = y;
 
    return root;
}
 
//在节点y上的右旋操作，以y和y的左孩子x之间的轴为支点，旋转结束后y是x的右孩子
//      y                  x
//     / \  right_rotate  / \ 
//    x  ry     --->     lx  y
//   / \                    / \          
//  lx rx                  rx ry
treeNode* right_rotate(treeNode* root, treeNode* y)
{
    treeNode *x = y->left;
    y->left = x->right;
    if(x->right != NULL)
        (x->right)->p = y;
    x->p = y->p;
    if(y->p == NULL)//y是根节点
        root = x;
    else if(y == (y->p)->left)
        (y->p)->left = x;
    else (y->p)->right = x;
    x->right = y;
    y->p = x;
    return root;
}
 
//插入新的节点后必须得调整
treeNode* rb_insert_fixup(treeNode *root, treeNode *z)
{
    treeNode *uncle_z;
    while(z->p && z->p->color == RED && z->p->p)
    {
        if (z->p->p->left == z->p)//z的父亲是左孩子
        {
            uncle_z = z->p->p->right;//z的叔父是右孩子
            //case1--叔父是右孩子，红色
            if(uncle_z && uncle_z->color == RED)
            {
                uncle_z->color = BLACK;
                z->p->color = BLACK;
                z->p->p->color = RED;
                z = z->p->p;
            }
            //case1 end
            else
            {   
                //case2--叔父是右孩子，黑色 z是右孩子
                if (z == z->p->right)//如果z是右孩子
                {
                    z = z->p;
                    root = left_rotate(root, z);
                }
                //case2 end 
                //case3--叔父是右孩子，黑色 z是左孩子
                z->p->color = BLACK;
                z->p->p->color = RED;
                root = right_rotate(root, z->p->p);
                //case3 end
            }
        }
        else//z的父亲是右孩子
        {
            uncle_z = z->p->p->left;//z的叔父是左孩子
            //case4--叔父是左孩子，红色
            if (uncle_z && uncle_z->color == RED)
            {
                uncle_z->color = BLACK;
                z->p->color = BLACK;
                z->p->p->color = RED;
                z = z->p->p;
            }
            //case4 end
            else
            {   
                //case5--叔父是左孩子，黑色，z是左孩子
                if (z == z->p->left)
                {
                    z = z->p;
                    root = right_rotate(root, z);
                }
                //case5 end
                //case6--叔父是左孩子，黑色 z是右孩子
                z->p->color = BLACK;
                z->p->p->color = RED;
                root = left_rotate(root, z->p->p);
                //case6 end
            }
        }
    }
    root->color = BLACK;
    return root;
}
 
//插入新的节点
treeNode* rb_insert(treeNode *root, int value)
{
    treeNode *z = new treeNode;
    z->key = value;
    treeNode *x = root;
    treeNode *y = NULL;
 
    while(x != NULL)
    {
        y = x;
        if(value == x->key)
            return root;
        if(value < x->key)
            x = x->left;
        else x = x->right;
    }
    z->p = y;
    if (y == NULL)
    {
        root = z;
    }
    else
    {
        if(value < y->key)
            y->left = z;
        else
            y->right = z;
    }
    z->left = NULL;
    z->right = NULL;
    z->color = RED;
    root = rb_insert_fixup(root, z);
    return root;
}
//删除节点x的父节点后调整, x相当于多重黑色或者红黑色
treeNode* rb_delete_fixup(treeNode *root, treeNode *x, treeNode *parent_x)
{
    treeNode *w;//x_brother
    while(x!=root && (x == NULL ||x->color == BLACK))
    {
        //x的父亲parent_x一定有两个孩子
        if(x == parent_x->left)
        {
            w = parent_x->right;//x的右兄弟w
            //case1--x的兄弟w为红色，则w肯定有黑孩子,左旋,转换成case2,case3....
            if(w->color == RED)
            {
                w->color = BLACK;
                parent_x->color = RED;
                root = left_rotate(root, parent_x);
                w = parent_x->right; //w重新置为parent_x的右孩子
            }
            //case1 end
            //case2--w为黑色，w的两个孩子(如果有)也是黑色
            if((w->left == NULL || w->left->color == BLACK) && (w->right == NULL || w->right->color == BLACK))
            {
                w->color = RED;
                x = parent_x;
                parent_x = parent_x->p;
            }
            //case2 end 
            else
            {   //case3--w的右孩子是黑色，左孩子是红色
                if(w->right == NULL || w->right->color == BLACK)
                {
                    if(w->left != NULL)//如果w有左孩子,一定是红色
                        w->left->color = BLACK;
                    w->color = RED;
                    root = right_rotate(root, w);
                    w = parent_x->right;
                }
                //case3 end
                //case4 w的右孩子是红色
                if (w->right != NULL)//如果w有右孩子，一定是红色
                    w->right->color = BLACK;
                w->color = parent_x->color;
                parent_x->color = BLACK; 
                root = left_rotate(root, parent_x);
                x = root;
            }
        }
        else//与上面对称
        {
            w = parent_x->left;//x的左兄弟w
            //case5--x的兄弟w为红色，则w肯定有黑孩子,右旋,转换成case2,case3....
            if(w->color == RED)
            {
                w->color = BLACK;
                parent_x->color = RED;
                root = right_rotate(root, parent_x);
                w = parent_x->left;
            }
            //case5 end
            //case6--w为黑色，w的两个孩子(如果有)也是黑色
            if((w->left == NULL || w->left->color == BLACK) && (w->right == NULL || w->right->color == BLACK))
            {
                w->color = RED;
                x = parent_x;
                parent_x = parent_x->p;
            }
            //case6 end
            else
            {
            //case7--w的左孩子是黑色，右孩子是红色
                if(w->left == NULL || w->left->color == BLACK)
                {
                    if(w->right != NULL)
                        w->right->color = BLACK;
                    w->color = RED;
                    root = left_rotate(root, w);
                    w = parent_x->left;
                }
                //case7 end
                //case8 w的左孩子是红色
                if (w->left->color == RED)
                    w->left->color = BLACK;
                w->color = parent_x->color;
                parent_x->color = BLACK; 
                root = right_rotate(root, parent_x);
                x = root;
                //case8 end
            }
        }
    }
 
    if(x != NULL)
        x->color = BLACK;
    return root;
}
 
treeNode* rb_delete(treeNode *root, int value)
{
    treeNode *z, *y, *x;
    z = root;
    while(z != NULL)
    {
        if(z->key == value)
            break;
        if(z->key < value)
            z = z->right;
        else
            z = z->left;
    }
    if(z == NULL) //木有找到要删除的节点
        return root;
    y = z;
    if(y->left!=NULL && y->right!=NULL)//两个孩子的情况，y是z的中序后继
    {
        y = y->right;
        while (y->left != NULL)
        {
            y = y->left;
        }
        z->key = y->key;
    }
    //x是y唯一的孩子或者NULL
    if(y->left != NULL)
        x = y->left;
    else x = y->right;
     
    if(x)
        x->p = y->p;
    if(y->p == NULL)//y是根节点
        root = x;
    else if(y == y->p->left)
        y->p->left = x;
    else y->p->right = x;
     
    if(y->color==BLACK)
        root = rb_delete_fixup(root, x, y->p);
    delete y;
    return root;
}
 
treeNode* rb_find(treeNode *root, int value)
{
    treeNode *x = root;
    int h = 0;
    while (x != NULL)
    {
        if (x->key == value)
        {
            if(x->color == RED)
                printf("RED ");
            else
                printf("BLACK ");
            printf("从0层计数，%d在第%d层\n", value, h);
            return x;
        }
        if (x->key < value)
            x = x->right;
        else x = x->left;
        h++;
    }
    return NULL;
}
 
void midOrder(treeNode *root)
{
    if(root == NULL)
        return;
    midOrder(root->left);
    printf("%d-", root->key);
    if(root->color == RED)
        printf("RED ");
    else
        printf("BLACK ");
    midOrder(root->right);
}
 
void preOrder(treeNode *root)
{
    if(root == NULL)
        return;
    printf("%d-", root->key);
    if(root->color == RED)
        printf("RED ");
    else
        printf("BLACK ");
    preOrder(root->left);
    preOrder(root->right);
}
 
 
int main()
{
    int select, a;
    treeNode *root = NULL;
    do
    {
        printf("请输入选择 1--插入，2--查询， 3--删除, 4--输出中序和前序，其他跳出\n");
        scanf("%d", &select);
        if (select == 1)
        {
            printf("输入将要插入的值, -1表示结束\n");
            while(scanf("%d", &a), a != -1)
            {
                root = rb_insert(root, a);
            }
        }
        else if (select == 2)
        {
            printf("输入将要查询的值, -1表示退出查询\n");
            while(scanf("%d", &a), a != -1)
            {
                if(rb_find(root, a) != NULL)
                {
                    //printf("找到了\n");
                }
                else
                    printf("木有找到\n");
            }
        }
        else if(select == 3)
        {
            printf("输入将要删除的值, -1表示退出删除\n");
            while(scanf("%d", &a), a != -1)
            {
                root = rb_delete(root, a);
            }
        }
        else if(select == 4)
        {
            printf("中序是:\n");
            midOrder(root);
            printf("\n前序是:\n");
            preOrder(root);
            printf("\n");
        }
        else break;
 
    } while (true);
     
 
    getchar();
    return 0;
}