Experimento de estructura de datos. C++
#ifndef __CNODE_H__
#Definición __CNODE_H__
# include & ltiostream & gt
Usar espacio de nombres std
Estructura ST datos // Fecha de nacimiento estructura
{
int m _ nAño
int m _ nMes
int m _ nDay
};
Resultados de presión estructural//Estructura de calificaciones de cinco cursos
{
doble m _ d sujeto _ 1; //Cambia el nombre del grado tú mismo
double m _ d sujeto _ 2;
double m _ d sujeto _ 3;
double m_d sujeto_4;
double m_d sujeto_5;
};
Struct stStudent //Declara la estructura de la información del estudiante.
{
String m _ strNumber//ID de estudiante
String m _ strName//Nombre
char m _ chSex // Género
struct stData m _ stData//Fecha de nacimiento
Cadena m _ strApariencia//Opinión política
struct stResult m _ stResult//cinco calificaciones del curso
};
typedef clase CNode
{
Privado:
struct stStudent m _ stStudent
CNode * m _ Next
Público:
CNode();//Constructor
~ CNode();/ /Destructor
void SetNodeData(); //Miembros de función que establecen el contenido del nodo
ST Student GetNodeData(); //Miembros de función que obtienen el contenido del nodo.
void SetNodeNext(CNode * _ Next); //Establece el miembro de función del siguiente puntero del nodo.
void ShowNodeData(); //Miembro de función que genera el contenido del nodo
CNode * GetNodeNext(); //Miembro de función que obtiene el siguiente puntero del nodo.
} LinkNode
#endif
//Clase CLinkList
#ifndef __CLINKLIST_H__
#define __CLINKLIST_H__
#Contiene "CNode.h"
clase typedef CLinkList
{
Privado:
LinkNode * m _ Head//Puntero principal de la lista enlazada
LinkNode m _ Node//Nodo principal de la lista enlazada
Público:
clink list(); //Constructor
~ clink list(); //Destructor
void create list(); //Inicializa los miembros de la función de la lista enlazada
LinkNode * GetListNode(int _ nIndex); //Encontrar la función miembro del nodo especificado por posición
void insert list(int _ nIndex); //Insertar la función miembro del nodo.
void delete list(int _ nIndex); //Eliminar la función miembro de un nodo.
LinkNode * GetHeadList(); //Función miembro para obtener el puntero principal
void SetListData(int _ nIndex); //Función miembro para establecer el valor del nodo en la lista enlazada;
void ShowListData(int _ nIndex); //Esta es una función miembro de un valor de nodo en la lista enlazada real.
void DestroyList(int _ nIndex); //Función miembro para destruir la lista enlazada después de una determinada posición.
void ShowList(); //Muestra las funciones miembro de la lista vinculada.
}Lista de enlaces;
#endif
//Clase CLinkList
#Contiene "CLinkList.h"
#Contiene "CNode.h"
CLinkList::CLinkList()
{
cout & lt& lt"Este es el constructor"
m _ Head = & ampm _ Node//El puntero principal de la lista vinculada apunta al nodo principal
m _Node. SetNodeNext(NULL); //Establece el siguiente puntero del nodo principal en NULL
}
CLinkList::~CLinkList()
{
cout & lt& lt"Esto es un destructor"
}
Void CLinkList::CreateList() //Crea una lista vinculada agregando hacia atrás, ingresa 0 para salir.
{
int nTemp = 0; //Definir una variable temporal para marcar el final del programa.
cout & lt& lt"¡Bienvenido a crear una lista vinculada!" & lt& ltendl
CNode * pTemp = NULL // Define el puntero de nodo temporal utilizado para agregar nuevos nodos.
CNode * pNode = m _ Head//Defina un puntero de marca, primero llámelo para que apunte al nodo principal.
while(1)
{
pTemp = new LinkNode
cout & lt& lt"Ingrese el contenido del siguiente nodo ! ”& lt& ltendl
pTemp-& gt;SetNodeData();//Establece el contenido del nodo en la lista vinculada.
cout & lt& lt "Si desea continuar ingresando la información del siguiente estudiante, ingrese 1; de lo contrario, ingrese 0" < & lt; /p> p>
if ('0' == nTemp)
{
Romper;
}
pNodo -& gt ;SetNodeNext(pTemp); //Deje que Siguiente al final de la cadena apunte al nodo recién creado.
pNode = pTemp//Mover el elemento final hacia atrás.
}
cout & lt& lt"Fin de la creación de la lista de enlaces"
}
LinkNode * clink list::GetListNode(int _ nIndex)
{
cout & lt& lt"Esta es una función miembro que encuentra el nodo especificado por posición"
enlazar nodo * pNode = m _ Head- & gt; GetNodeNext(); // Defina un puntero de nodo temporal e inicialice el nodo que apunta al encabezado.
int Temp = 0; //Definimos una variable temporal para marcar el número de nodos seleccionados.
If(-1 == _nIndex) //Devuelve el nodo principal (es decir, el puntero principal).
{
Devolver m_Head
}
if(_ nIndex & lt; -1) //_nCondición de control de índice
{
cout & lt& lt"¡Estás en la posición equivocada!"& lt& ltendl
Devuelve 0;
}
Y (pNode!=null)
{
if(_nIndex == Temp)
{
Devolver pNode
}
pNode = pNode-& gt;GetNodeNext(); //Mover el nodo temporal hacia atrás.
++Temperature;
}
Devuelve pNode//Si no se encuentra el nodo, devuelve NULL.
}
lista de clink vacía::ShowListData(int _ nIndex);
lista de clink vacía::Insert List(int _ nindex)//Insertar nodo miembro de la función.
{
cout & lt& lt"Esta es la función miembro para insertar el nodo"
LinkNode * pNode = GetListNode(_ nIndex-1); /Definición Un puntero a la clase de nodo, que apunta al puntero anterior en el que insertar.
LinkNode* pTemp =Nuevo CNodo//Define el puntero de nodo temporal utilizado para agregar nuevos nodos.
pTemp-& gt; SetNodeData(); //Establece el contenido del nodo insertado.
pTemp-& gt;SetNodeNext(pNode-& gt;GetNodeNext());
pNode-& gt;SetNodeNext(pTemp);
}
void clink list::delete list(int _ nIndex)
{
cout & lt& lt"Esta es una función miembro que elimina nodos"
LinkNode * pNode = GetListNode(_ nIndex-1); //Defina un puntero a la clase de nodo, apuntando al puntero anterior a la ubicación que se eliminará.
LinkNode * pTemp = NULL//Defina un puntero de nodo temporal que apunte al nodo que se eliminará.
pTemp = pNode-& gt; GetNodeNext() // Apunta pTemp al nodo que se eliminará.
pNode->SetNodeNext(pTemp->GetNodeNext()); //Apunta pNode al nodo después del nodo que se va a eliminar.
Eliminar pTemp//Eliminar nodo
pTemp = NULL
}
LinkNode * clink list::GetHeadList()
{
cout & lt& lt"Esta es una función miembro para obtener el puntero principal"
Devolver m _ Head
}
void clink list::SetListData(int _ nIndex)
{
cout & lt& lt"Esta es una función miembro que establece el valor del nodo en el enlace list"
CNode * pNode = GetListNode(_ nIndex); //Defina un puntero a la clase de nodo, apuntando al nodo donde se modificará la ubicación del contenido.
pNode-& gt;SetNodeData();//Modificar contenido
}
void clink list::ShowListData(int _ nIndex)
{
cout & lt& lt"Esta es una función miembro que muestra el valor del nodo en la lista vinculada"
CNode * pNode = GetListNode(_ nIndex); // La definición apunta a Un puntero a la clase de nodo, que apunta al nodo donde se obtendrá la ubicación del contenido.
pNode->show nodedata(); //Devuelve el contenido del nodo en la ubicación requerida.
}
void clink list::DestroyList(int _ nIndex)
{
cout & lt& lt"Este es el enlace lista en la función miembro después de que se destruye una determinada posición"
LinkNode * pTemp = GetListNode(_ nIndex-1); //Defina un puntero de nodo que apunte al nodo antes de la posición que se destruirá.
link node * pNode = pTemp-& gt; GetNodeNext(); //Define un puntero de nodo que apunta al nodo que se va a destruir.
while(pTemp-& gt; GetNodeNext()!= NULL) //Condición final o condición inicial de la operación de destrucción
{
pTemp-& gt ;SetNodeNext(pNode->GetNodeNext()); //Apunta el siguiente nodo anterior a la ubicación que se destruirá al siguiente nodo en la ubicación de destrucción.
Eliminar pNode // Destruir nodo
pNode = pTemp-> GetNodeNext(); // Redirigir pNode al nodo en la ubicación que se va a destruir.
}
}
void CLinkList::ShowList()
{
cout & lt& lt" Esta es una función miembro que muestra una lista vinculada"
int nTemp = 0; //Defina una variable entera temporal para controlar el número de entradas.
enlazar nodo * pTemp = m _ Head-& gt; GetNodeNext(); //Definir un puntero de clase de nodo, apuntando al nodo con el bit 0.
if(NULL == pTemp)
{
cout & lt& lt"Esta es una cadena vacía"
}
mientras(pTemp!=null)
{
pTemp-& gt;mostrar nodedata();
++ nTemp; p>
if(0 = = nTemp % 5 &&nTemp!= 0) // Controla que solo se puedan generar cinco nodos en cada línea.
{
cout & lt& ltendl
}
pTemp = pTemp-& gt;GetNodeNext();
}
}
//Clase CNode
#Contiene "CNode.h"
CNode::CNode() / /Constructor
{
//m _ ST estudiante = { 0 }
m _ Siguiente = NULL
}< / p>
CNode::~CNode() //Destructor
{
}
void CNode::SetNodeData()
{
char * p número = new char[30]; //Variable temporal utilizada para recibir cadenas.
char * pName = nuevo char[30];
char * pAppearance = nuevo char[30];
CIN & gt;& gtpNumber
m _ ST estudiante . m _ str número = p número
cout & lt& lt"Nombre:" p>
CIN>& gtpName
m _ stStudent.m _ strName = pName
cout & lt& lt"Género:"
CIN & gt;& gtm _ ST estudiante . m _ CHS ex;
cout & lt& lt"Fecha de nacimiento:"
cout & lt& lt" m _ stData.m _ nAño " & lt& ltendl
CIN & gt;& gtm _ ST estudiante . m _ stdata . m _ Nye ar;
cout & lt& lt" m _ stData.m _ nMes " & lt& ltendl
CIN & gt;& gtm _ ST estudiante . m _ stdata .
cout & lt& lt" m _ stData.m _ nDay " & lt& ltendl
CIN & gt; & gt;& gtpApariencia
m _ ST estudiante . m _ strap pearance = pap pearance
cout & lt& lt" Puntuaciones de cinco cursos:"
cout & lt& lt" m _ d materia _ 1:" & lt;& ltendl
CIN & gt;& gtm _ ST estudiante . m _ stresult . m _ d sujeto _ 1;
cout & lt& lt" m _ d sujeto _ 2:" & lt;& ltendl
CIN & gt;& gtm _ ST estudiante . m _ stresult . m _ d sujeto _ 2;
cout & lt& lt" m _ d sujeto _ 3:" & lt；& ltendl
CIN & gt;& gtm _ ST estudiante . m _ stresult . m _ d materia _ 3;
cout & lt& lt" m _ d materia _ 4:" & lt;& ltendl
CIN & gt ;& gtm _ ST estudiante . m _ stresult . m _ d sujeto _ 4;
cout & lt& lt" m _ d sujeto _ 5:" & lt;& ltendl
CIN>>m_ST estudiante.m_stresult.m_d asignatura_5;
>Eliminar []p número; //Liberar memoria
pNumber = NULL//El puntero es nulo
Eliminar []pName //Liberar memoria
pName = NULL
Eliminar [] apariencia de la página //Liberar memoria
pAppearance = NULL
}
ststudentcnode::get nodedata ( )//Contenido del nodo de retorno (es decir, información del estudiante).
{
Devolver m _ stStudent
}
void CNode::SetNodeNext(CNode * _ Next)
{
m _ Siguiente = _ Siguiente
}
void CNode::ShowNodeData()
{
const char * p número = m _ ST estudiante. m _ strnumber . c _ str() //Variable temporal utilizada para recibir cadenas.
const char * pName = m _ ST estudiante . m _ strnumber .
const char * pApariencia = m _ ST estudiante . _ str();
cout & lt& lt"ID de estudiante:"
cout & lt& lt"Fecha de nacimiento:"
cout & lt& lt" Funciones de política: "
cout & lt& lt" m _ d sujeto _ 1: " & lt; & ltm _ ST estudiante . m _ stresult . m _ d sujeto _ 1 & lt; & ltendl
cout & lt& lt" m _ d sujeto _ 2:" & lt;& ltm _ ST estudiante . m _ stresult . & lt& lt" m _ d materia _ 3:" & lt;& ltm _ ST estudiante . d materia _ 4:" & lt;& ltm _ ST estudiante . m _ stresult . m _ d materia _ 4 & lt; lt;& ltm _ ST estudiante . m _ stresult . m _ d materia _ 5 & lt;& ltendl
}
CNode* CNode::GetNodeNext()
{
Devolver m_Next
}
#Contiene "CLinkList.h"
#Contiene "CNode.h "
void text(); //Declaración de función de prueba
int main()
{
cout & lt& lt"Esta es la función de Mian"
text();
Devuelve 0 ;
}
Texto no válido()
{
cout & lt& lt"Esta es una función de prueba"
LinkList* pList = Nueva lista enlazada //Crear un objeto de lista enlazada en memoria
cout & lt& lt"-Crear lista-" & lt;& ltendl
pList- >; create list(); //Inicializa los miembros de la función de la lista enlazada
pList->;
cout & lt& ltendl
cout & lt& lt"-GetListNode-" & lt;& ltendl
LinkNode * pNode = NULL//Defina un puntero de clase de nodo temporal para detectar miembros de la función de búsqueda.
pNode = pList-& gt; GetListNode(3); //Prueba de la función miembro del nodo de bits especificado por posición.
Frecuencia intermedia (pNodo)
{
cout & lt& lt"El nodo especificado se encontró buscando por posición"
}
Otro
{
cout & lt& ltLo sentimos, el nodo de bits especificado no se encontró al buscar por posición
}
cout & lt& ltendl
cout & lt& lt"-insert list-" & lt;& ltendl
pList->;insert list(0); la función miembro del nodo insertado
pList->;ShowList();
cout & lt& ltendl
cout & lt& lt"-delete list-" & lt ;& ltendl
pList->;Delete list(0);//Eliminar la prueba de la función miembro de un nodo.
pList->;ShowList();
cout & lt& ltendl
cout & lt& lt"-GetHeadList-" & lt;& ltendl
pNode = NULL
pNode = pList-& gt; GetHeadList() //Prueba de la función miembro para obtener el puntero principal
IF (pNode)
{
cout & lt& lt"Puntero de cabeza devuelto"
}
Otro
{
cout & lt& ltLo sentimos, el puntero principal está vacío
}
cout & lt& ltendl
cout & lt& lt"-GetHeadList-" & lt ;<endl
pList->;SetListData(3);//Pruebe la función miembro que establece el valor del nodo en la lista vinculada.
pList->;ShowList();
cout & lt& ltendl
cout & lt& lt"-getlist data-" & lt;& ltendl p>
cout & lt& lt" pList->;showlist data(3)= ";
pList->;showlist data(3);//Prueba la función miembro para obtener el Valor de nodo en la cadena.
cout & lt& ltendl
cout & lt& lt"-destroy list(3)-" & lt;& ltendl
pList->;destroy list( 3); // Pruebe la función miembro de la lista vinculada después de destruir la tercera posición.
pList->;ShowList();
cout & lt& ltendl
cout & lt& lt"-destroy list(0)-" & lt;& ltendl
pList->; DestroyList(0); //Prueba la función miembro de la lista vinculada después de destruir el bit cero.
pList->;ShowList();
cout & lt& ltendl
Eliminar pList//Liberar memoria
pList = NULL/ /El puntero es nulo
}