árbol binario en busca de nodo sucesor

título

Encuentre un nodo en un nodo sucesor árbol binario
[Título] Hay un nuevo tipo de nodo de árbol binario es el siguiente:
public class Nodo {int valor público; pública el hijo izquierdo;
pública del nodo derecho; pública el padre del nodo;
pública el Nodo (int datos) {el presente datos = .Value;}
} de la
estructura de una pluralidad de puntero que apunta a un nodo padre de los padres de estructura de árbol binario de nodo convencional. Falsas
proporcionadas nodos de un tipo binario de nodo, cada nodo de la matriz puntero árbol es
correcta punto a su padre del nodo padre, el primer nodo a la nula. A sólo uno de
un nodo en un nodo de árbol binario, implementar una función que devuelve nodos sucesores del nodo. En el segundo
recorrido secuencia de preorden del árbol, el siguiente nodo de un nodo a otro se llama el nodo sucesor.

pensamiento

Recuerde estas dos reglas:
1. Si el nodo actual tiene un hijo derecho, que ha estado buscando para sus nodos más a la izquierda, hasta que no haya nodos izquierda para volver al nodo es el nodo sucesor;
2, si el nodo actual · cuando el punto no es subárbol derecho, se determina si el nodo padre del nodo izquierdo del nodo actual es el nodo actual, si se devuelve el nodo padre, si no luego dejar que el nodo padre * nodo actual repite secuencialmente el proceso anterior hasta encontrado hasta el momento,

código

// 中序遍历寻找后继结点->cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
using namespace std;

struct Node
{
	int val;
	struct Node*parent;
	struct Node*left;
	struct Node*right;
	struct Node(int data) : val(data), left(nullptr), right(nullptr) {};
};
Node*getmostleft(Node*node);
	Node* getsucessful(Node*node)
	{
		if (node == NULL)
			return node;
		if (node->right != NULL)
		{
		return	getmostleft(node->right);
			
		}
		else {
			Node*parent = node->parent;
			while (parent != NULL&&parent->left != node)
			{
				node = parent;
				parent = node->parent;
			}
			return parent;
		}
	}

	Node*getmostleft(Node*node)
	{
		if (node == NULL)
			return node;
		
		while (node->left != NULL)
		{
			node = node->left;
		}
		return node;
	}
int main()
{
	Node*head= new Node(10);
	head->parent = NULL;
	head->left = new Node(3);
	head->left->parent = head;
	head->left->left = new Node(1);
	head->left->left->parent = head->left;
	head->left->left->right = new Node(2);
	head->left->left->right->parent = head->left->left;
	head->left->right = new Node(4);
	head->left->right->parent = head->left;
	head->left->right->right = new Node(5);
	head->left->right->right->parent = head->left->right;
	head->right = new Node(9);
	head->right->parent = head;
	head->right->left = new Node(8);
	head->right->left->parent = head->right;
	head->right->left->left = new Node(7);
	head->right->left->left->parent = head->right->left;
	head->right->right = new Node(10);
	head->right->right->parent = head->right;
	
	Node* test = head->left->left;
	Node*result1 = getsucessful(test);
	cout << result1->val << " " << endl;

	Node*test1 = head->left->left->right;
	Node*result2= getsucessful(test1);
	cout << result2->val << " " << endl;

	Node*test02 = head->right->right;
	Node*result3 = getsucessful(test02);
	cout << result3<< " " << endl;

	Node*test04= test = head->right->left->left;
	Node*result4 = getsucessful(test04);
	cout << result4->val << " " << endl;
    return 0;
}