Notas de clase de estructura de datos

template < class T>
 void SeqList <T> :: reSize ( int newsize) 
{ 
    if (newSize! = maxSize) 
    { 
        T * newarray = new T [newSize];
        / * 
        Abre el espacio de memoria de tamaño newSize El 
        tipo de datos es T         
        * / 
       if (newarray == NULL) 
       { 
        cerr << " Falló la asignación de almacenamiento " << endl; 
        exit ( 1 ); 
       } 
    } 
    int n = last + 1 ; 
    T * scrptr =datos; 
    T * destptr = newarray;
    while (n--) * destptr ++ = * srcptr ++ ; 
    borrar datos; 
    data = newarray; 
    maxSize = newSize; 
} 


template < class T>
 int SeqList <T> :: search (T & x) const 
{ 
    for ( int i = 0 ; i <= last; i ++ ) 
    { 
        if (data [i] == x) return i + 1 ; 
    } 
} 

/ * 
在 第 i 个 位置 插入 x 
插入 前 ： a1, ...., ai-1, ai, ..., un 
插入 后 ： a1, ..., ai-1, x, ai, ..., un
La lógica entre ai-1 y ai ha cambiado. La 
tabla está llena: último> = MaxSize-1 
último es el último índice de matriz de elementos 
1 <= i <= último + 2 
Cuanto menos se mueva al insertar un elemento, más eficiente será 
moverlo. no sólo el número y la longitud de la tabla relativa a la inserción y la ubicación del 
mejor de los casos (i = n + 1) declaración base se ejecuta cero, la complejidad en tiempo de O (1). 
* / 

/ * 
tabla de secuencia implementado - borrar 
todos los a Avanzar un bit es equivalente a sobrescribir. En 
primer lugar, es necesario determinar si la posición de eliminación es legal. 
1 <= i <= last + 1 
* / 
template < class T>
 bool SeqList <T> :: Remove ( int i, T & x) 
{ 
    if (last == - 1 || i < 1 || i> last + 1 ) return  false ; 
    x = data [i- 1 ];// El índice de la matriz de elementos i-ésimo es i-1
    for ( int j = i; j <= last; j ++ ) 
    { 
        data [j - 1 ] = data [j]; // contraportada frontal 
    } 
    last- ; // longitud de la tabla-1 
} 


// entrada de la tabla de secuencia 
Plantilla de algoritmo < clase T>
 void SeqList <T> :: input () 
{ 
    cout << " Número de elementos de entrada " ;
     while ( 1 ) 
    { 
        cin >> last;
         if (last <= maxSize- 1 ;) break 
        cout << "El número es incorrecto " ; 
    } 
    for ( int i = 0 ; i <= last; i ++ ) 
    { 
        cin > data [i]; 
        cout << i + 1 << endl; 
    } 
} 
 
// Order 
Plantilla de algoritmo de salida de tabla < clase T>
 void SeqList <T> :: output () 
{ 
    cout << " La última posición del elemento actual es " << last << endl;
    para ( int i = 0; i <= last; i ++ ) 
    { 
        cout << " # " << i + 1 << " : " << data [i] << endl; 
    } 
} 

// 顺序 表 的

应用// 并 运算
void Union (SeqList < int > & A, SeqList < int > & B) 
{ 
    int n = A.length (), x;
    int m = B.length ();
    para ( int i = 1 ; i <= m; i ++ ) 
    { 
        B.getData (i, x);
        intk = A.Búsqueda (x); // Búscalo en A 
        si (k == 0 )      // Si no se encuentra el último resultado insertado en A, coloca el resultado combinado en A (si vuelves a abrir el espacio, se desperdiciará) 
        { A.Insert (n, x); n ++ ;} 
    } 
} 

// Operación de intersección 
void Intersection (SeqList < int > & A, SeqList < int > & B) 
{ 
    int n = A.Length ();
     int m = B.Length (); int i = 1 , x;
     while (i <= n) 
    { 
        A.getData (i, x); 
        int k = B.search (x);
         if (k == 0 ) A.Remove (i, x), n-- ;
         else i ++ ; 
    } 
} 

// Ventaja de la tabla de secuencia: 
/ * 
No es necesario agregar espacio de almacenamiento adicional para representar la relación lógica entre los elementos de la tabla. 
El acceso aleatorio puede Acceda rápidamente a los elementos en cualquier posición de la 
tabla Desventajas de la tabla de secuencia: 
(1) Las operaciones de inserción y eliminación necesitan mover una gran cantidad de elementos 
(2) La capacidad de la tabla es difícil de determinar, la capacidad de la tabla es difícil de expandir 
(3) La 

lista enlazada fragmentada que causa espacio de almacenamiento Muy adecuado para la inserción o eliminación frecuente, y los requisitos de espacio de almacenamiento varían mucho 
* /  


/ * La 
lista enlazada simple es la lista enlazada más simple, también conocida como lista enlazada lineal, que utiliza punteros para representar la relación lógica entre nodos. El 
nodo almacena campos de datos y campos de puntero 
lineales primera estructura de puntero para la primera 
nodo puede ser una memoria 99,99% discontinua almacenamiento discontinua continua 
orden lógico y el orden de los nodos puede ser diferente físicas 
tablas se expanden fácilmente 
* /  

/ * 
la tabla de secuencia es una capacidad fija 
de una sola cadena no fijado   
* /  

/ * 
pluralidad expresión de un concepto de clase (de cadena sencilla) 
nodo lista (NodoLista) clase de 
clase lista (LIST)
* /  

// 1. Clases de composite. 1 
clase de lista; // lista define la clase (a modo de compuesto) 
de clase LinkNode 
{ 
    amigo clase de lista; // objectlist su clase amigo 
    privada :
         int datos; 
        LinkNode * Enlace; 
}; 
clase List 
{ 
    private : 
        LinNode * first; 
}; 
// ¿La clase Friend no tiene simetría? ?
// Clase compuesta 2: Definir la clase linkNode 
struct LinkNode 
    con struct 
{ int data: 
    LinkNode * link; 
};
class List 
{ 
    private : 
        LinkNode * first;
     public : 
}; 
/ * 
Aunque la estructura hace que List pierda su encapsulación, 
solo se puede acceder a todos los nodos LinkNode que pertenecen a los objetos LIst primero. 
* /  
// 2. Clase de 
clase anidada Lista 
{ 
    
}   
 
 // 3. 
Clase de herencia   LinkNode 
{ 
     protegido :
          datos int ; 
         LinkNode * link; 
}; 
clase Lista 
{ 
    
} 
// Si no puede terminar de escribir, vaya al PPT.

1