¿Cómo utilizar C++ para crear, insertar, eliminar e invertir una tabla lineal?
#include
#include.
#include
#define ListSize 100 // El tamaño del espacio de tabla se puede determinar de acuerdo con las necesidades reales.
h>
#define ListSize 100 //El tamaño del espacio de tabla se puede determinar de acuerdo con las necesidades reales, aquí se supone que es 100
typedef int DataType; puede ser cualquier tipo de datos correspondiente, como int, float o char
typedef struct //Definición de la tabla de secuencia
{ DataType data[ListSize] //Los datos de la matriz se utilizan para guardar nodos de tabla
int length; //La longitud actual de la tabla
}SeqList;
{
SeqList L,L1 ,L2,L3;
Tipo de datos newelem; //nuevo elemento
int position; //posición de inserción, posición de eliminación
char ch //usado en menu
int i,t;
int dlta[20]; // Secuencia ordenada por colinas
L.length=0; la lista de secuencias es 0
void CreateList(SeqList *L); //Crear tabla de secuencias L
void PrintList(SeqList L //Imprimir tabla secuencial L
);int LocateList(SeqList L,DataType newelem); // Encuentra la posición del elemento newelem en la tabla secuencial desordenada L
void InsertList(SeqList *L,DataType newelem,int position); DeleteList(SeqList *L,int position); //Eliminar el elemento en la posición en la lista de secuencia L
void Sort1List(SeqList *L); //Eliminar el elemento en la posición en la lista de secuencia L
void Sort1List(SeqList *L) .//Ordenación por inserción directa en la tabla secuencial L
void Sort2List(SeqList *L); //Ordenación por inserción plegable en la tabla secuencial L<; /p>
int Locate1List(SeqList L,DataType newelem) ; //Plegar búsqueda en tabla secuencial ordenada L.DataType posición del nuevo elemento de los elementos de datos
int Partition(SeqList *L, int low, int high); //Función de partición de clasificación rápida, utilizada para convertir low, high se divide en dos partes, los elementos de la primera mitad son más pequeños que los de la segunda mitad
void Qsort(SeqList *L, int low) , int high); // Función de partición de clasificación rápida, utilizada para dividir low y high en dos partes, los elementos de la primera mitad son más pequeños que los de la segunda mitad
void Qsort(SeqList *L, int low) , int high); //Completa la lista.
int low,int high); //Algoritmo recursivo de clasificación rápida, con bajo y alto como rango
void Merge(SeqList *L, int i,int m,int n); función, fusiona dos órdenes de i, mm+1, n en un orden de i, n
void MSort(SeqList *L, int s, int t //Algoritmo recursivo para ordenación por subsunción
void ShellInsert(SeqList *L,int dk); //Paso de clasificación en colina como función dk
void ShellSort(SeqList *L,int dlta[],int t);
void MergeList(SeqList L1,SeqList L2,SeqList *L3); //Fusiona las tablas de secuencia incremental L1 y L2 y almacena los resultados en la tabla de secuencia L3
void Merge1List( SeqList L1 ,SeqList L2,SeqList *L3);// Intersecta la tabla secuencial incremental L1, L2, el resultado se almacena en la tabla secuencial L3
void Merge2List(SeqList L1,SeqList L2,SeqList *L3); Tabla secuencial incremental L1, L2, el resultado se almacena en la tabla secuencial L3, es decir, eliminar duplicaciones.
L1,SeqList L2,SeqList *L2); //Fusiona las listas de secuencias crecientes L1 y L2, y almacena el resultado en la lista de secuencias L1
void reverse(SeqList *L); / /p>
void delall(SeqList *L, DataType newelem); //Eliminar elementos específicos (elementos duplicados en listas lineales)
do {
cout< cout<<" ************* ****** Menú de funciones de tabla lineal de secuencia********** **********"< cout<<" * a: construir una tabla lineal b: encontrar elementos desordenados *"< cout<<" * c: insertar elementos d: eliminar elemento *"< cout<<" * e: ordenación por inserción directa f: ordenación por inserción plegada *"< cout<<" * g: búsqueda de plegado ordenado h: ordenación rápida *"< cout<<" * i: Subsunción j: Ordenación en colina *"<< endl ; cout<<" * K: l: *"< cout<<" * m: n. l: *"< n：*"< cout<<" * m: n：*"< cout<" * m: n： * "< lt;<" * o: p: *"< cout<<" * q: Fusionar dos tablas de orden creciente r: Fusionar dos listas de orden creciente en su lugar*"< cout<<" * s: intersección de dos listas de orden creciente t: u: lista lineal inversa v: eliminar elementos específicos*" < cout<<" * w: x：*"< cout<<" * z: exit *"< cout <<" ******************************************* ***** ***********"< cout<<" Introduzca su elección: "; cin>>ch; cambiar (ch) { caso 'a': CreateList(&L); PrintList(L) ; break; case 'b': cout<<" Ingrese el valor a buscar: "; cin> >newelem; cout< /p> break; case 'c': cout<<" Por favor ingrese el elemento de datos a insertar: "; cin > >newelem; cout<<" Ingrese la posición donde desea insertar el elemento: "; cin>.>position; InsertList( &L,newelem,posición ); PrintList(L); break; caso 'd': cout<< " Ingrese lo que desea eliminar La posición del elemento: "; cin>>position; DeleteList(&L,position); PrintList (L); break; case 'e': Sort1List(&L); PrintList(L); ruptura; caso 'f': Sort2List(&L); PrintList(L); descanso; caso 'f': Sort2List(&L); PrintList(L); descanso; case 'g': cout<<" Introduzca el valor a encontrar: "; cin>>newelem; cout < case 'h': cout<<" Crear tabla secuencial"< CreateList(&L); Qsort(&L,1,L. length); case 'u': cout<<"Crear tabla de secuencia" < CrearLista(&L); ImprimirLista(L); invertir(&L); ImprimirLista(L ); break; case 'v': cout<< "Crear lista de secuencias (con duplicación)" << endl; CreateList(&L); cout<<." Ingrese el elemento de datos específico que desea eliminar: "; cin>>newelem; PrintList(L); delall(&L, newelem); PrintList(L); break Predeterminado; : descanso; } }mientras (ch! ='z'); } void CreateList(SeqList *L) // Para crear una lista de secuencia, primero determine el número de elementos de datos de entrada y luego ingrese los datos elementos en orden { int i,n; cout<<" Introduzca el número de elementos: "; p> cin>>n; cout<<" Por favor ingrese "< para (i=1; i<= n ; i++) cin>>L->datos[i]; L->longitud=n; } void PrintList(SeqList L) //Imprime la lista de secuencias, salida en orden { int i; cout<<" "; for (i=1; i<=L.i++) cout< cout< } int LocateList(SeqList L,DataType newelem) // Búsqueda de tabla secuencial desordenada, coloque el elemento que se busca en la unidad 0 como centinela y luego comience desde la cola hasta el head Buscar en secuencia { int i; i=L.length; L.data[0]=newelem ; //Tecnología de entrada while (L.data[i]!= newelem) i--; return i; } void InsertList(SeqList *L,DataType newelem,int position) // Para insertar elementos en la lista de secuencia, primero determine la racionalidad de la posición de inserción. Si excede el rango, lo hará. ser forzado a ser el primer elemento o el elemento de cola Insertar razonablemente en orden descendente desde la cola hasta la posición de inserción { int i; if; (position<1) position=1 ; // Fuerza la posición del primer elemento a insertar else if (position&&t gt;L- >length) position=L->length+ 1; //Forzar la posición de inserción del elemento de cola ; for (i=L-> length; i>=position; i--) //Al final de la secuencia Posición de inserción, es decir, la cola L->data[i+1]=L->data[i]; L->datos[posición]=newelem; L->longitud++; } void DeleteList(SeqList *L, int position) //Eliminar elementos en la lista de secuencia, primero determine la racionalidad de la eliminación, +1 eliminar posición, la cola avanza por turno { int L->. datos[posición]=newelem; if () if ((posición<1) || (posición>L->longitud)) { cout<<" ¡Posición de eliminación incorrecta! " ; } else { for (i=posición; i L->data[i]=L->data[i+1]; L->l ength--; } } void Sort1List(SeqList *L) //Ordenación por inserción directa, { i,j; for (i=2; i<=L->longitud; i++) { L-> data[0]=L->data[i]; //Tecnología Sentinel j=i-1; while (L->data[0] { L->data[j+1]=L->data[j]; j--; } L->datos[j+1]=L->datos[0] } }<; /p> } void Sort2List( SeqList *L) //Ordenación de inserción por la mitad { int low,mid,high, i,j; for (i=2; i<=L->longitud; i++) { bajo=1; high=i-1; L->datos[0]=L->datos[i]; //p> if (L->datos [1]>L->data[i]) //determina si es menor que el mínimo { low=1; high=1 ; } if (L->data[i-1] { bajo=i-1; alto=i-1; } mientras (bajo < alto) / /Determinar la posición de inserción { mid=(low+high)/2; if (L-> data[mid ]==L- >datos[0]) { bajo=medio; alto=medio; p> } else { if (L->datos[mid] bajo =medio+1; más alto=medio-1 } } } if (L->data[low] low++; for (j=i; j>low; j--) //Moverse hacia atrás en orden L->.data[j ]=L->datos [j-1]; L->datos[low]=L->datos[0]; } } int Locate1List(SeqList L,DataType newelem) // Doblar la lista de secuencias ordenadas por la mitad { int low,high,mid; si (newelem return 0; if (newelem>L.data[L.length] ) //Juzga si es mayor que el valor máximo Devuelve 0; low=1; high=L.length; while (bajo< =alto) { mid=(bajo+alto)/2; if ( newelem==L.data[ mid]) Devuelve mid; if (newelem Devuelve 0; If (newelem Devuelve 0; devuelve 0; } int Partition(SeqList *L, int bajo, int alto) { int pivot=L->datos[bajo]; L- >datos[0]=L-& gt;datos[bajo]; mientras (bajo<alto) { mientras ((bajo alto--; L-> while ( (low low++; L->.data[ alto]=L->datos[bajo ]; } L->datos[bajo]=L->datos[0]; Volver bajo; } void Qsort(SeqList *L, int bajo, int alto) { int pivotloc; if (bajo< alto) { pivotloc=Partición(L,bajo,alto); Qsort(L,bajo, pivotloc-1); Qsort(L,pivotloc+1,high); } } void Merge(SeqList *L, int i, int m, int n) { SeqList L1; int p,q,k; para (q=m+1; q<=n;q++) L1.data[q]=L->datos[q]; p=m; q=n ; k=n; mientras ((p>=i)& amp;&(q>=m+1)) { if (L->datos[p]>L1.datos[q]) { L->datos [k]=L->datos[ p]; p--; } els e { L->datos[k]=L1.data[q]; q--; } k--; } if (p for (p=q;p> =m+1;p--) { L->datos[k]=L1.datos[p]; k--; } } void MSort(SeqList *L, int s, int t) { int m; if (s!=t) { m=(s+t)/2; MSort(L,s,m); MSort(L,m+1,t); Fusionar(L,s,m,t); } } void ShellInsert(SeqList *L,int dk) { int i,j; for (i=dk+1;i<=L->longitud;i++) if (L->datos[i] { L->datos[0]=L->datos[i]; para (j=i-dk;(j>0)&&( L->datos[0] L->datos[j+dk]=L->datos[j]; L->datos[j+dk]=L->datos[0]; } } void ShellSort( SeqList *L,int dlta [],int t) { int k; for (k=1;k<=t;k++) ShellInsert(L,dlta[k]); } L3->longitud=k; mientras ((i >0)&&(j>0)) //rango de control { if (L1.data[i] { L3->.data[k]=L2.data[j]; j--; } else { L3->datos[k]=L1.data[i]; i--; } k--; } if (i==0) //procesamiento de cola for (i= j;i>0;i--) { L3->datos[k]=L2.data[i]; k-- ; } más para (j=i ; j>0;j--) { L3->datos[k]=L1.data[j]; k--; } } void Merge1List(SeqList L1,SeqList L2,Seq Lista * L3) //Interseca la lista secuencial incremental L1, L2 y almacena el resultado en la lista secuencial L3 { int i,j,k; i=1; j=1; k=1; mientras ((i<=L1.length)&&(j <=L2. length)) //rango de control { if (L1.data[i]==L2.data[j]) //elementos iguales, depositar en L3 { L3->datos[k]=L1.datos[i]; i++ j++; } más si (L1.data[i] i++; más j++; } L3->.length=k-1; } void Merge2List(SeqList L1,SeqList L2,SeqList *L3) //Para encontrar la concatenación de listas secuenciales incrementales L1, L2, es decir, y eliminar duplicaciones, eliminar datos duplicados y convertir los resultados almacenados en la lista de secuencia L3 { int i,j,k; i=1; j=1; k=1; while ((i<=L1.length)&&(j<=L2.length)) //Rango de control { if (L1.data[i]==L2.data[j]) //igualmente el resultado se almacena en la lista secuencial L3.data[j]) //igual, depósito a L3 { L3->datos[k]=L1.data[i]; i++; j++; } else if (L1.data[i] { L3->datos[k]=L1.datos[i]; i++; } más { L3->datos[k]=L2.datos[j]; j++; } k++; } if (i>L1.length) //procesamiento de cola for (i=j;i<=L2.length;i++) { L3->datos[k]=L2.datos[i]; k++; } else para (j=i;j<=L1.length;j++) { L3->datos[k]=L1 .datos[j] ; i=L1->longitud; j=L2.longitud; k=i+j; L1- >longitud=k; mientras ((i>=1)&&(j>=1)) { si (L1->datos[ i]>=L2.data[j]) { L1->datos[k]=L1->datos[i]; i --; } else { L1->.data[k] = L2.data[j]; j--; } k--; } si (i<1 ) para (i=j;i>=1;i--) { L1-> datos[k] =L2.datos[ yo];