Pregunta de matriz OJ

Tema uno

(1. Descripción

Dada una matriz de nums y un valor de val, debe eliminar todos los elementos cuyo valor sea igual a val en su lugar y devolver la nueva longitud de la matriz eliminada.

No use espacio adicional en la matriz, debe usar solo O (1) espacio adicional y modificar la matriz de entrada in situ. El orden de los elementos se puede cambiar. No necesita considerar los elementos de la matriz más allá de la nueva longitud.

(2) Ejemplo

输入nums=[3,2,2,3]，val=3
输出nums=[2,2],数组长度位2

(3) Pensar

Método de doble puntero

1. Primero defina un puntero lento lento y estipule que el valor del elemento 0-lento no es val

2. Luego use el puntero rápido para recorrer la matriz
y compare el elemento apuntado por rápido con val, habrá dos situaciones: el valor del elemento apuntado es igual o no igual a val rápido
3. Si el valor de el elemento apuntado es igual a val (como se muestra arriba), porque estipulamos que o-slow es para almacenar un elemento

cuyo valor no es val, el puntero rápido se mueve hacia atrás, buscando el siguiente elemento que llegó a "2" en este momento, y encontró que su valor no es val, póngalo en En el intervalo 0-lento, es decir, en este momento, asigne el elemento apuntado por rápido a lento. Una vez

completada la asignación, el puntero lento debe moverse hacia atrás
. 4. Repita los pasos anteriores

(4) Implementación del código

int removeElement(int* nums, int numsSize, int val)
{
    
    
    int slow=0;
    int fast=0;
    for(fast=0;fast<numsSize;fast++)
    {
    
    
        if(nums[fast]!=val)
        {
    
    
            nums[slow]=nums[fast];
            slow++;
        }
    }
    return slow;
}

Tema dos

(1. Descripción

Dada una matriz ordenada, debe eliminar los elementos repetidos en su lugar, de modo que cada elemento solo aparezca una vez, devuelva la nueva longitud de la matriz eliminada.
No use espacio de matriz adicional, debe modificar la matriz de entrada en su lugar y usar O (1) Completo con espacio adicional.

(2) Ejemplos

输入nums=[1,1,1,2,2,2,3]
输出nums=[1,2,3]
返回数组长度为3

(3) Pensar

Esta pregunta es un poco similar a la primera pregunta, consulte la figura a continuación para obtener ideas específicas.

(4) Código

int removeDuplicates(int* nums, int numsSize)
{
    
    
    int front=0;
    int behind=0;
    if(numsSize==0)//特别注意空数组的情况，往往就是这一个测试用例无法通过
    {
    
    
        return 0;
    }
    else
    {
    
    
        for(behind=1;behind<numsSize;behind++)
        {
    
    
            if(nums[front]!=nums[behind])
            {
    
    
                front++;
                nums[front]=nums[behind];
            }
        }
        return front+1;
        //注意这里要返回front+1，因为测试在输出时在到front时会停止
    }
}

Tema tres

(1. Descripción

Para el entero no negativo X, la forma de matriz de X es una matriz formada por cada dígito de izquierda a derecha. Por ejemplo, si X = 1231, entonces su forma de matriz es [1,2,3,1].

Dada la forma de matriz A del entero no negativo X, devuelve la forma de matriz del entero X + K.

(2) Ejemplo

(3) Pensar

Por ejemplo, X = 1200, la forma de matriz A = [1,2,0,0], si K es 34, entonces X + K = 1234, y la forma de matriz de X + K = [1,2,3, 4].
Así que comienza desde el lugar de las unidades y agrégalas una por una. Después de agregar una, colócalas en la matriz. Ya que están ordenadas, la matriz debe invertirse al final.

Primero, pedimos el número de K para determinar qué tan grande es la matriz.

int* addToArrayForm(int* A,int ASize,int K,int* returnSize)
{
    
    
	int KSize=0;
	int KNum=k;
	while(KNum)
	{
    
    
		++KSize;
		KNum/=10;
	}
}
int len=ASize>KSize?ASize:KSize;
int* retarr=(int*)malloc(sizeof(int)*(len+1));//找出这两个数组哪个大，新的数组最厉害也只能比它大一位

El siguiente paso es sumar uno por uno comenzando desde el lugar de las unidades, el problema del acarreo estará involucrado al sumar.

int Ai=ASize-1;//找到数组A的最后一位
int reti=0;//reti用于控制相加后的下标
int nexnum=0;//用于控制进位
while(len--)//比如说最大长度为4为，那么他就要进行4次运算
{
    
    
	int a=0;
	if(Ai>=0)//如果是1200+34那都没有问题，因为Ai不会越界，但是如果是34+1200，Ai就会成为负数，所以此时对于34，如果Ai被检测为负数，说明到达了百位，那么它的百位和千位就都是0了.如果Ai是正数，那么就把正常的值赋值给a
	{
    
    
		a=A[Ai];
		Ai--;
	}
	int ret=a+K%10+nextnum;
	K/=10;//比如K=1234，%10,取出个位4，%10相当于取前三位进入下次循环，再取此时的个位3，以此类推
	if(ret>9)
	{
    
    
		ret-=10;//比如个位是9+9=18，那么个位的数字就是18-10=8；
		nexnum=1;//置为1，下一位就会进1
	}
	else
	{
    
    
		nexnum=0;
	}
	retarr[reti]=ret;
	++reti;//一次循环后，计算得到数字依次放到数组中
}
if(nexnum==1)
{
    
    
	retarr[reti]=1;
	++reti;//比如800+200=1000，相加时，计算到8+2的时候，已经算了三次，所以不会再进入循环，但是这一位没有进上去，所以对于这种情况要单独处理
}

Finalmente, debido a que los elementos se colocan desde 0 al sumar, es decir, se colocan en orden, por lo que el resultado final es opuesto al resultado real, por lo que se requiere la inversión

int left=0,right=reti-1;
while(left<right)
{
    
    
	 int temp=retarr[left];
	 retarr[left]=retarr[right];
	 retarr[right]=temp;
}

Además, el valor de retorno es una matriz. Asegúrese de prestar atención al int * returnSize del parámetro formal. Significa desreferenciar el interior para modificar la longitud de la matriz; de lo contrario, la matriz no se puede enviar al exterior porque no hay longitud .

	*returnSize=reti;
	return retarr;