Apuntes de clase: lista enlazada circular, lista doblemente enlazada, lista enlazada estática

Lista enlazada circular: vincular los nodos de cabecera y cola de una sola lista enlazada o una lista enlazada doble es una lista enlazada circular. A partir de cualquier nodo en la tabla circular, puede acceder a otros nodos en la tabla.
Características: 1. Una lista vinculada conectada de extremo a extremo. 2. Puede comenzar desde cualquier nodo y acceder a todos los nodos en la lista vinculada. 3. Juzgue las características del nodo de cola en la lista circular vinculada: q-> siguiente == primera
estructura de tabla vacía:

template<class T>
CycleLinkList<T>:: CycleLinkList( )
{
     first=new Node<T>; 
     first->next=first;
}

Método de inserción de cola para construir una lista enlazada circular:

template<class T>   
CycleLinkList<T>:: CycleLinkList(T a[ ], int n)
{
     first=new Node<T>;    
     Node<T> *r,*s;      
     r=first;  
     for(int i=0; i<n; i++)
     {
          s=new Node<T>;          
          s->data=a[i];           
          r->next=s;
          r=s;
     }
     r->next=first; 
}      

Método de inserción de cabezales para construir una lista enlazada circular:

template<class T>
CycleLinkList<T>:: CycleLinkList(T a[ ], int n,int k)
{
     first=new Node<T>; 
     first->next=first; 
     Node<T> *s; 
     for(int i=1; i<n; i++)
     {
          s=new Node<T>; 
          s->data=a[i]; 
          s->next=first->next;
          first->next=s;
     }
}

Transforme las listas acíclicas de un solo enlace en listas circulares de un solo enlace:

p=first;
while(p->next)
{
     p=p->next;
}
p->next=first

Lista de doble enlace La principal desventaja de la lista de un solo enlace es que el campo de enlace solo apunta a nodos posteriores y no puede encontrar efectivamente el predecesor. La lista de doble enlace compensa las deficiencias mencionadas anteriormente, agregando un puntero al precursor.
Estructura de nodo de la lista de doble enlace:

template<class T>
struct  DNode
{
     T data; 
     DNode<T> *llink; 
     DNode<T> *rlink;
}; 

Características estructurales de las listas doblemente enlazadas:
dado que hay enlaces hacia adelante y hacia atrás en una lista doblemente enlazada, es muy conveniente encontrar los nodos directos predecesores y sucesores directos de cualquier nodo. Establezca el puntero p para que apunte a un nodo en la lista doblemente vinculada, luego se cumple la siguiente fórmula: p-> llink-> rlink = p = p-> rlink-> llink
inserta el nodo después de la lista doblemente vinculada P (hay un nodo posterior en p)

q->rlink=p->rlink; 
q->llink=p;
p->rlink=q;
q->rlink->llink=q; 

Principio de procesamiento: primero procese el puntero del extremo lejano en cada dirección y luego procese el puntero del extremo cercano.
Inserte el nodo después de la lista doblemente vinculada P (hay un nodo sucesor en p)

q->rlink=p->rlink;
p->rlink=q;
q->llink=p;
q->rlink->llink=q;

Principio de procesamiento: primero inserte en la lista vinculada hacia adelante, y luego inserte en la lista vinculada inversa.
Inserte un nodo en una tabla vacía (inserte un nodo al final de la tabla)

q->rlink=p->rlink;
p->rlink=q;
q->llink=p;
if(q->rlink)
    q->rlink->llink=q;

Eliminar operación de lista doblemente vinculada

p->llink->rlink=p->rlink;
p->rlink->llink=p->llink;
delete(p);

Eliminar el nodo de cola

p->llink->rlink=p->rlink;
if(p->rlink)
    p->rlink->llink=p->llink;
delete(p);

Construcción de listas doblemente enlazadas-construcción de listas vacías

template<class T>
DoubleLink <T>::DoubleLink(){
    head=new Node<T>; 
    head->rlink=NULL; 
    head->llink=NULL; 
}

Inserción de la cabeza

template<class T>
void DoubleLink<T>::Append(T data){
     Node<T> *s;
     s=new Node<T>;
     s->data=data;
     s->rlink=head->rlink;
     head->rlink=s;
     s->llink=head;
     if(s->rlink)
         s->rlink->llink=s;
     return;
}

Atravesar

template<class T>
void DoubleLink<T>::Display(){
    Node <T> *p;
    p=head->rlink;
    while(p){
        cout<<p->data<<"   ";
        p=p->rlink;
    }
    cout<<endl;
    return;
}

Desestructuración

template<class T>
DoubleLink<T>::~DoubleLink(){
    Node<T>  *p,*q;
    p=head;
    while(p)
    {
        q=p->rlink;
        delete p;
        p=q;
    }
}

Listas enlazadas estáticas La necesidad de listas enlazadas estáticas: algunos lenguajes de programación no admiten tipos de puntero.
Características: Use una estructura de almacenamiento secuencial (matriz) para simular una lista vinculada.
La lista enlazada estática se puede describir con la ayuda de una matriz unidimensional:

＃define  Maxsize= 链表可能达到的最大长度
template<class T>
structNode{
    ElemType data; 
    int  next;
}; 

Ventajas: no es necesario mover elementos al insertar y eliminar, solo modifique el puntero, de modo que la eficiencia sea mayor.
Desventajas: las listas enlazadas estáticas se implementan mediante matrices, por lo tanto, el tamaño de la matriz no se puede modificar dinámicamente y el espacio de almacenamiento no se puede asignar según sea necesario, como las matrices estáticas.