二叉树操作详解-优快云博客

#include <iostream> 

002#include <stack> 

003#include <queue> 

004  

005using 
namespace std; 

006  

007typedef 
struct Node{ 

008    int    
data; 

009    Node    *left;

010    Node    *right;

011    int    
tag; 

012    Node(int
val):data(val),left(NULL),right(NULL),tag(0){} 

013}Node; 

014  

015//插入二叉树节点--递归实现 

016Node *InsertTree(Node *root,int
val) 

017{ 

018    Node *e = NULL;

019    if(root == NULL){

020        e =
new Node(val);

021        if(e == NULL)
return NULL;

022        return
e; 

023    }else{

024        if(val < root->data){

025            root->left = InsertTree(root->left,val);//创建左子树

026        }

027        else
if(val > root->data){

028            root->right = InsertTree(root->right,val);//创建右子树

029        }

030    } 

031    return
root; //递归函数返回时返回的根节点 

032} 

033  

034  

035//在二叉树中插入节点--非递归实现 

036void 
InsertTree_(Node **root,int 
val) 

037{ 

038    if(root == NULL)
return; 

039    Node *e =
new Node(val);

040    if(e == NULL)
return; 

041    if(*root == NULL){

042        *root = e;

043    }else{

044        Node *p = *root,*pre = NULL;

045        while(p != NULL){

046            pre = p;

047            if(e->data < p->data){

048                p = p->left;

049            }

050            else
if(e->data > p->data){

051                p = p->right;

052            }else{//有相同的元素就退出

053                delete
e; 

054                return;

055            }

056        }

057  

058        if(e->data < pre->data){

059            pre->left = e;

060        }else{

061            pre->right = e;

062        }

063    } 

064} 

065  

066//销毁二叉树 

067void 
DeleteTree(Node *root) 

068{ 

069    if(root != NULL){

070        if(root->left != NULL){

071            DeleteTree(root->left);

072        }

073        if(root->right != NULL){

074            DeleteTree(root->right);

075        }

076        cout<<"delete :"<<root->data<<endl;

077        delete
root; 

078    } 

079} 

080  

081//递归先序遍历二叉树 

082void 
PreOrder(Node *root) 

083{ 

084    if(root != NULL){

085        cout<< root->data <<" ";

086        PreOrder(root->left);

087        PreOrder(root->right);

088    } 

089} 

090  

091//递归中序遍历二叉树 

092void 
MidOrder(Node *root) 

093{ 

094    if(root != NULL){

095        MidOrder(root->left);

096        cout<<root->data<<" ";

097        MidOrder(root->right);

098    } 

099} 

100  

101//递归后续遍历二叉树 

102void 
LastOrder(Node *root) 

103{ 

104    if(root != NULL){

105        LastOrder(root->left);

106        LastOrder(root->right);

107        cout<<root->data<<" ";

108    } 

109} 

110  

111//非递归先序遍历 

112void 
PreOrder_(Node *root) 

113{ 

114    if(root == NULL)
return; 

115    Node *p = root;

116    stack<Node *> s;

117    while(!s.empty() || p != NULL)

118    { 

119        while( p != NULL){

120            cout<<p->data <<" ";

121            s.push(p);

122            p = p->left;

123        }

124  

125        if(!s.empty()){

126            p = s.top();

127            s.pop();

128            p = p->right;

129        }

130    } 

131    cout<<endl;

132} 

133  

134//非递归中序遍历 

135void 
MidOrder_(Node *root) 

136{ 

137    if(root == NULL)
return; 

138    stack<Node *> s;

139    Node *p = root;

140    while(!s.empty()|| p != NULL)

141    { 

142        //将左子树压入栈中

143        while(p != NULL){

144  

145            s.push(p);

146            p = p->left;

147        }

148        //当栈不为空时弹出左子树，输出左子树的值再遍历右子树

149        if(!s.empty())

150        {

151            p = s.top();

152            cout<<p->data<<" ";

153            s.pop();

154            p = p->right;
//将右子树压入栈中 

155        }

156    } 

157    cout<<endl;

158} 

159  

160//非递归后续遍历 

161//需要判断根结点的左右子树是否都遍历过了 

162void 
LastOrder_(Node *root) 

163{ 

164    if(root == NULL)
return; 

165    stack<Node *> s;

166    Node *p = root;

167    while(!s.empty() || p != NULL)

168    { 

169        while(p != NULL){

170            s.push(p);

171            p = p->left;

172        }

173  

174        if(!s.empty())

175        {

176            p = s.top();//弹出左子树

177            //如果左子树已经遍历

178            if(p->tag == 1)

179            {

180                cout<<p->data<<" ";

181                s.pop();

182                p = NULL;
//为了弹出p的父结点 

183            }else{

184                p->tag = 1;

185                p = p->right;

186            }

187        }

188    } 

189    cout<<endl;

190} 

191  

192//广度优先遍历二叉树 

193void 
LevelOrder(Node *root) 

194{ 

195    if(root == NULL)return;

196    queue<Node *> queue;

197    Node *p = NULL;

198    //根结点入队

199    queue.push(root);

200    while(!queue.empty())

201    { 

202        p = queue.front();
//取出队首元素 

203        cout<<p->data<<" ";

204        queue.pop();

205        if(p->left != NULL)

206            queue.push(p->left);

207        if(p->right != NULL)

208            queue.push(p->right);

209    } 

210    cout<<endl;

211} 

212  

213//判断是否为二叉排序树，通过中序遍历，中序遍历的输出结果是从小到大排列的，

214//从跟节点开始记录每次弹出的数，如果比后一个弹出的数大，说明不是二叉排序树

215//是返回1，不是返回 0，错误 返回 -1 

216  

217int 
IsSortedTree(Node *root) 

218{ 

219    if(root == NULL)
return -1; 

220    Node *p = root;

221    stack<Node *> s;

222    int
pre_data = 0; 

223    while(!s.empty() || p != NULL)

224    { 

225        while(p != NULL){

226            s.push(p);

227            p = p->left;

228        }

229        if(!s.empty())

230        {

231            p = s.top();

232            if(pre_data == 0 || pre_data < p->data)

233            {

234                pre_data = p->data;

235            }

236            if(pre_data > p->data){

237                return
0; 

238            }

239            s.pop();

240            p = p->right;

241        }

242    } 

243    return
1; 

244} 

245  

246int 
main() 

247{ 

248    /*

249    Node *root = NULL;

250    int arr[] = {8,2,5,1,7,9,3,6,0,4};

251    int len = sizeof(arr)/sizeof(int);

252    for(int i = 0; i < len;i++){

253        //root = InsertTree(root,arr[i]);

254        InsertTree_(&root,arr[i]);

255    } 

256    */

257  

258    Node *root = NULL;

259    Node* a =
new Node(1);

260    Node* b =
new Node(2);

261    Node* c =
new Node(3);

262    root = a;

263    a->left = b;

264    a->right = c;

265  

266    cout<<"pre order :";

267    PreOrder(root);

268    cout<<endl;

269    cout<<"\t   ";

270    PreOrder_(root);

271  

272    cout<<"mid order :";

273    MidOrder(root);

274    cout<<endl;

275    cout<<"\t   ";

276    MidOrder_(root);

277  

278    cout<<"last order :";

279    LastOrder(root);

280    cout<<endl;

281  

282    cout<<"\t   ";

283    LastOrder_(root);

284  

285    cout<<"Level Order:";

286    LevelOrder(root);

287  

288    int
ret = IsSortedTree(root); 

289    if(ret == 1){

290        cout<<"Is BST"<<endl;

291    }else{

292        cout<<"Is NOT BST"<<endl;

293    } 

294    DeleteTree(root);

295  

296  

297 
return0; 

298}
OSC上的二叉树《代码》
