estructura de datos 2019 de prueba de la tabla de secuencia Wang Problema

// acabado rugoso personal, debido a la depuración constante, código ligeramente rugosa, por favor, perdóname.

#include <stdio.h>
#include <malloc.h>

#define MAXSIZE 50

typedef int elemtype;

typedef struct // tipo de almacenamiento de tabla de secuencia definida
{
elemType de datos [MAXSIZE];
longitud int;
} sqlist;

//2.2.1
bool del_Min (sqlist & Q, elemtype e) {
    si es falso (q.length == 0) return;
    e = q.data [0];
    int temp = 0;
    for (int i = 1; i <q.length; i ++) {
        si (q.data [i] <e) {
             e = q.data [i];
             temp = i;
            }
       }
    Q.data [temp] = q.data [q.length-1];
    q.length--;
    return true;
}

//2.2.2
inversa vacío (sqlist y q) {

    elemtype temp;
    for (int i = 0; i <q.length / 2; i ++) {
        temp = q.data [i];
        q.data [i] = q.data [q.length-i-1];
        q.data [q.length-i-1] = temp;
    }
}

//2.2.3
del_x void (sqlist y q, elemtype x) {
    int k = 0;
    for (int i = 0; i <q.length; i ++) {
        si (q.data [i] == x) k ++;
        más q.data [ik] = q.data [i];
    }
    Q.length = q.length-k;
}

//2.2.4
del_s_t void (sqlist y q, elemtype s, elemtype t) {
    int k = 0;
    si (s> = t || q.length == 0) printf ( "falso");
    for (int i = 0; i <q.length; i ++) {
        si (q.data [i] <= s || q.data [i]> = t) {
            q.data [k] = q.data [yo];
            k ++;
        }
    }
    Q.length = k;
}

//2.2.5
del_s_t_1 void (sqlist y q, elemtype s, elemtype t) {
    int k = 0;
    si (s> = t || q.length == 0) printf ( "falso");
    for (int i = 0; i <q.length; i ++) {
        si (q.data [i] <s || q.data [i]> t) {
            q.data [k] = q.data [i ];
            k ++;
        }
    }
    Q.length = k;
}

//2.2.6
vacío del_rep (sqlist y q) {

    int k = 1;
        si (q.length == 0)
        printf ( "有序表为空");
    for (int i = 1; i <q.length; i ++) {
        si (q.data [i] = q.data [i-1]) {
            q.data [k] = q.data [i];
        k ++;
        }
    }
    Q.length = k;
}

//2.2.7
Combinar sqlist (sqlist & Q, sqlist & p) {
    sqlist O;
    o.length = q.length + p.length;
    si (o.length == 0) o de retorno;
    int i = 0, j = 0, k = 0;

    mientras que (i <q.length && j <p.length) {
        si (q.data [i] <= p.data [j])
            o.data [k ++] = q.data [i ++];
        más
            o.data [k ++] = p.data [j ++];
    }
    While (i <q.length) {//一个数组有还有剩余
    O.Data [k ++] = q.data [i ++];
    }
     While (i <p.length) {
    o.data [k ++] = p.data [j ++];
    }

    for (int m = 0; m <o.length; m ++) {
        printf ( "% d", o.data [m]);
}
    O RETURN;
}

//2.2.8
void Reverse1 (sqlist & Q, L int, int R & lt) {
    IF (L> = R ^ || R & lt> = MAXSIZE) return;
    int I, J;
    elemType TEMP;
    // encontrar un punto medio, correspondiente a ambos lados intercambio
    int m = (L + R & lt) / 2;
    for (i = 0; I <ml; i ++) {
        temp = q.data [L + I];
        q.data [L + I] = q.data [ RI];
        q.data [RI] = TEMP;
    }
}
void Exchange (sqlist & Q, m int, int n) {// la primera m y la n
    // toda la tabla orden inverso, respectivamente, y, a continuación, invertir la parte delantera y trasera de dos parte
    Reverse1 (q, 0, m + n-1); // toda flip
    Reverse1 (q, 0, n- 1); // n meses después de la primera n se convierte, su invertida
    Reverse1 (q, n, m . 1-n- +);
}

Encuentra el más rápido //2.2.9 necesario, a continuación, utilizar la dicotomía
vacío Search_x (Q & sqlist, elemType X) {
    int = 0 Bajo, Alto = q.length 1;.
    Int MID, TEMP, I;

    el tiempo (Low <= Alta) {
        MID = (High + Low) / 2;
        IF (X == q.data [MID]) PAUSA;
        el otro IF (X> q.data [MID])
            Low + 1 = MID.;
        .-alta MID 1 = la persona;
    }
    // encontrar y x no es el último
    SI {(q.data [MID] == x && = MID-q.length 1.!)
        TEMP = q.data [MID];
        q.data [MID ] = q.data [MID + 1];.
        q.data [MID + 1] = TEMP;.
    }
    // no se encuentra, debido a que la secuencia ordenada se incrementa, insertar
    IF (Low> High) {
        for (i = q.length -1; I> High; i--)
            q.data [I + 1.] = q.data [I]; // cambio después de
            q.data [i + 1] = x ; // inserto X
            q.length ++;

    }
    Devolver;
}

//2.2.10 sustancialmente similar a Q8, las dos partes entregados, invirtiendo toda la
Converse void (sqlist & Q, P int, int n-) {
    Reverse1 (Q, 0 ,. 1-P);
    Reverse1 (Q, P ,. 1-n- );
    Reverse1 (Q, 0, n-- 1);.
}
/ * complejidad 3 funciones Reverse1 de tiempo son O (P / 2), O ((NP) / 2),
O (n- / 2), por lo La complejidad de tiempo es O (n / 2). espacio complejidad es O (1).
* /

//2.2.11 dos secuencias de longitud iguales
int M_SEARCH (Q & sqlist, sqlist & P) {
    int F1 = 0, F2 = 0, E1 = -q.length 1, E2 = -p.length 1, MID1, MID2;..
    El mientras (!! || F1 = F2 = E2 E1) {
        MID1 = (F1 + E1) / 2;
        MID2 = (F2 + E2) / 2;

        si (q.data [Mid1] == p.data [Mid2])
            de retorno q.data [Mid1];

        si (q.data [Mid1] <p.data [Mid2]) {// menor q y p redondeo mayor
           (% (f1 + e1) si 2 == 0) {// un número impar de elementos
            f1 MID1 =;
            E2 = MID2;
           }
           la else {// el incluso
            F1 = MID1 + 1;.
            E2 = MID2;
           }
        }
        else {// q gran truncamiento y p es pequeño
            si ((f2 + e2)% 2 == 0) {
                E1 = MID1;
                F2 = MID2;
            }
            la else {
                E1 = MID1;
                . F2 = + MID2 1;
            }
        }
    }

    retorno q.data [F1] <p.data [F2] q.data [F1]: p.data [F2];?

} // similares tiempo medio complejidad, O (log2N), la complejidad espacial: O (1)

//2.2.12
int Mayoría (sqlist y q) {
   int x = q.data [0], count = 1, i;
   for (i = 1; i <q.length; i ++)
    {
        si (q.data [i] == x)
            recuento ++;
        otra cosa
        {
            si (contador> 0)
                count--;
            otra cosa
                x = q.data [i];
                count = 1;
        }
    }
    Si (recuento de> 0) {//计数
        for (i = count = 0; i <q.length; i ++) {
            si (q.data [i] == x)
                recuento ++;
        }
    }
    Si (recuento> q.length / 2) x retorno;
    else return -1;
} //时间复杂度O (n),空间复杂度O (1)

//2.2.13
/ *
espacio por el tiempo, una matriz de etiqueta correspondiente a 1 ~ n es un entero positivo, una matriz en comparación con una secuencia dada
número es menor que 0 o mayor que se produce la longitud de la secuencia, una vacante 1 ~ n, una primera un no
número marcado entero positivo que es la solicitud.
* /
Int FindMin (sqlist & Q) {
   int I, X;
   int A [q.length];
   for (i = 0; I <q.length; i ++) {
    A [I] = 0;
   }
   for (i = 0 ; I <q.length; i ++) {
    IF (q.data [I]> 0 && q.data [I] <q.length)
        a [q.data [I] -1] ++;
   }
   for (i = 0 ; I <q.length; i ++) {
    IF (a [i] == 0) PAUSA;
   }
   regrese I + 1;.
} // tiempo O (n), un adicional asignado un [n], el O espacial (n )

int main ()
{
sqlist q = {{0,1,1,2,3,4,5,6,7,8,9}, 11};
sqlist o = {{5,6,7,8}, 4};
sqlist p = {{1,2,3,4}, 4};
sqlist a = {{2,1,2,1,2}, 5};

elemtype e = 0;
for (int i = 0; i <q.length; i ++)
    {
        printf ( "% d", q.data [i]);
    }

 printf ( "\ n");
/ * del_Min (q, e);
printf ( "% d", e); * /

// inversa (q);

//del_x(q,3);

// del_s_t (q, 1,3);

// del_s_t_1 (q, 1,3);

// del_rep (q);

// Merge (q, p);

// intercambio (q, 5,6);

// Search_x (p, 2);
// Search_x (p, 4);

// Converse (q, 3,11);

// printf ( "% d", M_search (o, p));

// printf ( "% d", la mayoría (a));

printf ( "% d", FindMin (q));
 printf ( "\ n");
for (int i = 0; i <q.length; i ++)
    {
        // printf ( "% d", i);
        printf ( "% d", q.data [i]);
    }
}