Algoritmos que aparecen a menudo en entrevistas integradas con ingenieros
Algoritmos que aparecen a menudo en las entrevistas de ingenieros integrados
Los sistemas integrados se centran en las aplicaciones y se basan en tecnología informática. Tanto el software como el hardware se pueden personalizar y son adecuados para sistemas informáticos especiales. sistemas con requisitos estrictos en cuanto a funcionamiento, confiabilidad, costo, tamaño y consumo de energía. A continuación he compilado un artículo sobre algoritmos que aparecen a menudo en entrevistas con ingenieros integrados. Espero que le resulte útil.
Código de búsqueda binario.
int bfind(int* a, int len, int val)
{
int m = len/2
int; l = 0;
int r = len
mientras(l!=m amp; amp; r!= m)
{
if(a[m] gt; val)
{
r = m
m = (ml)/2; >
}
else if(a[m] lt; val)
{
l = m
m; = (m r)/2;
}
más
devolver m; 1; //no encontrado
}
Escribe código para encontrar el número de veces que aparece una subcadena en una cadena principal.
int count1(char* str, char* s)
{
char* s1
char* s2; p>
p>
int recuento = 0
while(*str!='\0')
{
s1 = str;
s2 = s;
mientras(*s2 == *s1amp;amp;(*s2!='\0')amp;(*s1!= '0'))
{
s2;
s1
}<
si(* s2 == '\ 0')
recuento
str;
retorno recuento
}
Encuentra la primera posición de la subcadena coincidente, si se devuelve la longitud de s1, len1 significa no encontrado <
Encuentra la primera posición de la subcadena coincidente, si se devuelve la longitud de s1 len1 significa no encontrado<
size_t find(char* s1, char* s2)
{
size_t i =0;
tamaño_t len1 = strlen(s1)
tamaño_t len2 = strlen(s2);
if(len1-len2lt;0) return len1;
for(; i {
size_t m = i;
for(size_t j=0; j {
if(s1 [m]!= s2[j])
romper
m
}
if(j==len)
break;
}
return i }
Escribe código para una clasificación rápida o algún algoritmo de clasificación
Ordenación rápida:
int partición(int* a, int l, int r)
{
int i=l-1, j=r, v =a[r];
mientras(1)
{
mientras(a[ i] mientras(a[--j]gt; v) si (jlt;=i) romper
if(igt;=j)
romper
intercambiar(a[i], a[j]
}
intercambio(a[i], a[r]);
retorno i; p>
void qsort(int * a, int l, int r)
{
if(lgt;=r) return
int; i = partición(a, l, r );
qsort(a, l, i-1
qsort(a, i 1, r>);
}
Clasificación Colombo:
burbuja vacía (int *a, int n)
{
for(int i=0; i {
for(int j=1; j {
if(a [j] {
int temp=a[j];
a[j] = a[j-1]; ] = temp;
}
}
}
Orden de inserción:
void insertsort(int* a, int n)
{
int clave;
for(int j=1; j {
clave = a[ j];
for(int i=j-1;igt;=0amp;amp;a[i]gt;key;i --)
{
a[i 1] = a[i];
}
a[i 1] = clave
}
La frecuencia de aparición es bastante alta
Implementación de la función strcmp
int strcmp11(char* l, char* r)
{
afirmar(l!=0&r!=0);
while(*l == *r &*l != '\0') l, r;
p>if(*l gt; *r)
devuelve 1
else if(*l == *r)
return 0 ;
return -1;
}
Implementación del cambio de cadena
void reserve(char* str)
{
afirmar(cadena != NULL);
char * p1 = cadena
char * p2 = str-1;
while(* p2); // Generalmente no se requiere usar strlen
p2 -=
while(p1 {
char c = *p1;
*p1 = *p2;
*p2-- = c; > Lista inversa enlazada individualmente
struct list_node
{
list_node(int a
{}
int datos;
list_node* siguiente
};
reserva vacía(list_node* phead)
{
int datos;
p>
list_node* siguiente;
{
reserva vacía(list_node* phead )<
{
list_node* p = phead-gt; siguiente
if(p == NULL || p-gt; siguiente == NULL; ) regresar; //o
solo el nodo principal o un nodo
list_node* p1=p-gt;next;
p-gt;next=NULL
while(p1! =NULL)
{
p = p1-gt;
p1-gt; siguiente = phead-gt; p>phead-gt; siguiente = p1. phead-gt; siguiente-gt; siguiente = nuevo list_node(2, 0);
lt.reserva();
while(p)
{
coutnext;
}
Intercambio de nodos y eliminación de lista circular enlazada.
// Bucle bidireccional
list_node* earse(list_node* nodo)
{
// if(nodo == rear) return node-gt; next; // El nodo principal puede ser juzgado o no. Es mejor agregar
list_node* next = node-gt;next;
next-gt;prev = node-gt;prev
node-gt; prev-gt; siguiente = siguiente;
Eliminar nodo;
Eliminar nodo
Volver a ejecutar
}
// bucle único
list_node* earse(list_node* nodo)
{
// if(node == rear) nodo de retorno - gt; next; // para el nodo principal puede juzgarse o no. Es mejor agregar
list_node* p = rear
while(p-gt; next; ! = nodo ) p=p-gt; siguiente;
p-gt; siguiente = nodo-gt;
eliminar nodo; -gt; siguiente;
}
Convierte una cadena numérica en un número. 1234" --gt; 1234
int atoii(char* s)
{
afirmar(s!=NULL);
int num = 0;
int temp;
while(*sgt;'0' amp; amp; *slt;'9')
{
número *= 10
número = *s-'0';
s; p> return num;
}
Esta situación ocurre con frecuencia
Implementa una función para sumar o multiplicar números enteros de longitud arbitraria.
void bigadd(char* num, char* str, int len)
{
for(int i=len; igt; 0; i-- )
{
num[i] = str[i];
int j = i
while(num[j; ]gt;=10)
{
num[j--] -= 10
num[j] = 1; p> }
}
.Función de escritura para completar la copia de memoria
void* memcpy( void *dst, const void *src, unsigned int len)
{
Registrar char *d;
registrar char *s;
if (len == 0)
return dst;
if ( dst gt; src ) //considere sobrescribir
{
d = (char *)dst len - 1 ;
s = (char *)src len - 1;
while (len gt; = 4) // Desenrollado del bucle para mejorar la eficiencia de ejecución
{
*d-- = *s--;
*d-- = *s--
*d-- = *s--; ;
*d-- = *s--;
*d-- = *s--; >
}
mientras ( len-- )
{
*d-- = *s--; }
}
else if ( dst lt; src )
{
d = (char *)dst; >
s = (char *)src; int length = strlen(str);
m_data = new char[length 1] // Es mejor agregar NULL
strcpy( m_data, str);
}
// Destructor de cadena.
función
String::~String(void)
{
eliminar [] m_data // o eliminar m_data;
// Copiar constructor
String:: String(const String amp; other) // Punto de puntuación: el parámetro de entrada es de tipo const
{
int length = strlen(other.m_data);
m_data = new char[length 1]; // Puntuación: agregue NULL en el juicio de m_data
strcpy( m_data) , other.m_data);
// Función de asignación
String amp String::operate =(const String amp; ; other) // Crédito: parámetro de entrada de tipo constante
{
if(this == amp; other) // Crédito: verificar la autoasignación
Devolver *this;
eliminar [] m_data; // Puntuación: liberar recursos de memoria originales
int length = strlen( other.m_data); > m_data = new char[length 1]; // Puntuación: Agregar criterio NULL a m_data
strcpy(m_data, other.m_data);
Devolver *this; : Devuelve una referencia al objeto
}
Análisis:
Si el entrevistado puede escribir de forma precisa y correcta el constructor y copiar el constructor de las funciones de la clase String, funciones de asignación y destructores, entonces habrá dominado al menos 60 conocimientos básicos de C.
Esta clase contiene la variable miembro de clase puntero m_data. Cuando una clase contiene variables miembro de clase de puntero, asegúrese de sobrecargar su constructor de copia, función de asignación y destructor. Esto no es solo un requisito básico para los programadores de C, sino también una cláusula especialmente enfatizada en "C efectivo".
Implementar strcpy
char * strcpy( char *strDest, const char *strSrc)
{
afirmar( (strDest ! = NULL) amp; ;
Dirección del remitente;
}
Escribe una función para completar el trabajo de desplazar circularmente la cadena hacia la derecha n, por ejemplo, es ? abcdefghi?
El encabezado de la función es el siguiente:
//pStr es un puntero a una cadena que termina en '\0'
//steps es el solicitud para mover n cadenas
void LoopMove (char * pStr, int pasos)
{
//Por favor complete...
}
Solución:
Respuesta correcta 1:
void LoopMove (char * pStr, int pasos)
{
int n = strlen( pStr ) - pasos;
char tmp[MAX_ LEN]
strcpy (tmp, pStr n); strcpy (tmp pasos, pStr);
*( tmp strlen (pStr)) = '\0'; }
Respuesta correcta 2:
void LoopMove ( char *pStr, int pasos )
{
int n = strlen( pStr ) - pasos;
char tmp[MAX_LEN]
memcpy( tmp, pStr n, pasos
memcpy(pStr pasos, pStr, n ); >
memcpy(pStr, tmp, pasos);
}
pStr[MAX_LEN].