408 Estructura de datos de King's Road Ejercicios de código después de clase (6)

¡Acostúmbrate a escribir juntos! Este es el décimo día de mi participación en el "Nuggets Daily New Plan · April Update Challenge", haz clic para ver los detalles del evento .

Planeo actualizar la implementación de todos los ejercicios de código extraescolares en la estructura de datos de King's Road 23. Aunque los exámenes generalmente están escritos en pseudocódigo, los he implementado todos para el trastorno obsesivo-compulsivo. El almacén está aquí.

• Mesa lineal

2.2.3, 12

• Encuentre elementos duplicados, y la cantidad de elementos es más de la mitad de la matriz, por lo que una matriz tiene como máximo un elemento principal
• La violencia es intercambiar espacio por tiempo, similar a la clasificación de cubos
• Abra una nueva matriz, el subíndice de la nueva matriz corresponde al valor del elemento y el valor corresponde al número de elementos (porque se determina el rango del número)
• Complejidad temporal O(n), complejidad espacial O(n)

int find_main(SqList list) {
  // 1.初始化一个默认值全为0的数组
  int tmp[list.length] = {0};

  // 2.下标对应元素值, 
  for (int i = 0; i < list.length; i++) {
    tmp[list.data[i]]++;
  }

  // 3.遍历找出主元素
  for (int i = 0; i < list.length; i++) {
    if (tmp[i] > list.length / 2 ) 
      return i;
  }

  // 4.没找到返回-1
  return -1;
}
复制代码

• El segundo método: primero ordenamos el orden y luego encontramos el elemento principal
• Registre el número de veces que aparece cada elemento y, si el siguiente número no es un elemento repetitivo, determine si el elemento actual es el elemento principal
• Debido a que se usa Quicksort, la complejidad de tiempo es O(nlogn) y la complejidad de espacio es O(logn)
• La puntuación total es de 13 puntos, y esta solución puede obtener hasta 11 puntos, así que no fuerces la solución óptima.

int find_main2(SqList list) {
  // 1.快排
  sort(list.data, list.data+list.length);

  // 2.记录每个元素出现的次数，找到主元素
  int cnt = 1;
  for (int i = 0; i < list.length - 1; i++) {
    if (list.data[i+1] == list.data[i]) {
      cnt++;
    } else {
      if (cnt > list.length / 2)
        return list.data[i];
      cnt = 1;
    }
  }
  return -1;
}
复制代码

• Cuando se prueba esta pregunta (probablemente probablemente) no puede escribir la implementación específica de clasificación que no tiene nada que ver con el tema
• Debido a que el espacio requerido para cada recursión de clasificación rápida es fijo, la cantidad de capas recursivas es la complejidad del espacio, por lo que la complejidad espacial promedio de clasificación rápida es O (logn)
• La implementación de quicksort es la siguiente:

void quick_sort(int l, int r) {
  if (l == r) return; 
  
  int x = a[(l+r)/2];     // 1.枢纽元素
	
  // 2.分成两块
  int i = l-1, j= r+1;
  while (i < j) {
    while (a[++i] < x);		// 找到左边比x大的元素
    while (a[--j] > x);		// 找到右边比x小的元素
    if (i < j) swap(a[i], a[j]); 	// 互换
  }
	
  // 3.递归
  quick_sort(l, j);
  quick_sort(j+1, r);
}
复制代码

• solucion optima
• Dado que el número de elementos principales es más de la mitad de la matriz, puede compensar todos los demás elementos y tener el resto
• Complejidad temporal O(n), complejidad espacial O(1)

int find_main3(SqList list) {
  int c, cnt = 1;
  c = list.data[0];

  // 1.选定候选主元素
  for (int i = 1; i < list.length; i++) {
    if (list.data[i] == c) cnt++;
    else {
      if (cnt > 0) {
        cnt--;
      } else {
        c = list.data[i];
        cnt = 1;
      }
    }
  }

  // 2.统计实际数量
  if (cnt > 0) {
    cnt = 0;
    for (int i = 0; i < list.length; i++)
      if (list.data[i] == c) 
        cnt++;
  }
  
  // 3.确认主元素
  if (cnt > list.length / 2) return c;
  return -1;
}
复制代码