Funciones: Divididas en funciones de biblioteca y funciones personalizadas.
Las funciones personalizadas, como las funciones de biblioteca, tienen nombres de función, tipos de valor de retorno y parámetros de función, pero la diferencia es que todas las diseñamos nosotros mismos.
Llamada de función: llamada
por valor:
los parámetros formales y los parámetros reales de la función ocupan diferentes bloques de memoria, y la modificación de los parámetros formales no afectará la
llamada de los parámetros reales : la
llamada por dirección pasa la dirección de memoria de la variable creada fuera de la función a Una forma de llamar a funciones para parámetros de función
Esta forma de pasar parámetros permite que la función establezca una conexión real con variables externas a la función, es decir, las variables externas a la función se pueden manipular directamente dentro de la función.
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void Swap2 (int pa, int pb)
{
int tmp = 0;
tmp = pa;
pa = pb;
pb = tmp;
}
int main ()
{
int a = 10;
int b = 20;
printf ("a =% db =% d \ n", a, b);
Swap2 (& a, & b);
printf ("a =% db =% d", a, b);
return 0;
}
// int main ()
// {
// int a = 10;
// int pa = & a;
// pa = 20;
// printf ("% d \ n", a);
// devuelve 0;
//}
// Void Swap (int x, int y)
// {
// int tmp = 0;
// tmp = x;
// x = y;
// y = tmp;
//)
//
// int main ()
// {
// int a = 10;
// int b = 20;
// / int tmp = 0; /
// printf ("a =% db =% d \ n", a, b);
// Intercambiar (a, b);
// / tmp = a;
// a = b;
// b = tmp; /
// printf ("a =% db =% d \ n", a, b);
// volver 0;
//}
Ejercicio:
1. Escribe una función para determinar si un número es primo.
2. Escribe una función para determinar si un año es bisiesto.
3. Escriba una función para realizar la búsqueda binaria de un entero y una matriz ordenada
4. Escriba una función. Cada vez que se llame a esta función, el valor de num aumentará en 1.
Recursividad de función:
la habilidad de programación de un programa que se llama a sí mismo se llama recursividad. Como algoritmo, la recursividad se usa ampliamente en los lenguajes de programación. Un proceso o función tiene un método de llamarse a sí mismo directa o indirectamente en su definición o descripción. Transforma un problema grande y complejo en un problema más pequeño similar al problema original. La estrategia recursiva requiere solo una pequeña cantidad de programas para describir los múltiples cálculos repetitivos requeridos en el proceso de resolución del problema, lo que reduce en gran medida el código. la cantidad. La principal forma de pensar sobre la recursividad radica en
las dos condiciones necesarias para convertir las cosas grandes en pequeñas recursiones:
1. Hay restricciones, cuando se cumple esta condición, la recursividad no continuará.
2. Después de cada llamada recursiva, se acerca cada vez más a esta restricción.
// Recurrencia de la función
// int main ()
// {
// printf ("hehe \ n");
// main (); // desbordamiento de pila
// return 0;
//}
void print (int n) // 1234
{
if (n> 9) // condición recursiva 1
{
print (n / 10); // condición recursiva 2
}
printf ("% d", n% 10);
}
int main ()
{
unsigned int num = 0;
scanf ("% d", & num); // 1234
print (num);
return 0;
}
No se permite escribir funciones para crear variables temporales, encuentre la longitud de la cadena
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
// Crea una variable temporal y encuentra la longitud de la cadena
// int my_strlen (char str)
// {
// int count = 0;
// while ( str! = '\ 0')
// {
// count ++;
// str ++;
//}
// recuento de retorno;
//}
// La función de creación no tiene permitido crear variables temporales Para encontrar la longitud de la cadena, use el método recursivo
int my_strlen (char str)
{
if ( str! = '\ 0')
return 1 + my_strlen (str + 1);
si no,
return 0;
// Las cosas grandes se transforman en pequeñas
// my_strlen ("bit");
// 1 + my_strlen ("it");
// 1 + 1 + my_strlen ("t");
// 1 + 1 + 1 + my_strlen (" \ 0 ");
// 1 + 1 + 1 + 0;
// 3
}
int main ()
{
char arr [] = "bit";
// int len = strlen (arr); // Encuentra la longitud de la cadena
// printf ("% d \ n", len);
// Simula una cadena Función
int len = my_strlen (arr); // arr es una matriz, a la matriz se le pasan parámetros, lo que se pasa no es la matriz completa, sino la dirección de un elemento
printf ("len =% d \ n", len);
return 0;}
Recursión e iteración
Recursión: la función que se llama a sí misma es recursividad;
iteración: consiste en calcular una cosa repetidamente y hacer una cosa repetidamente;
encuentra el factorial de n
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
//// Bucle
// int Fac1 (int n)
// {
// int i = 0;
// int ret = 1;
// for (i = 1, i <= n, i ++)
// {
// ret * = i;
//}
// return ret;
//}
//
// int main ()
// {
// // Encuentra el factorial de
n // int n = 0;
// int ret = 0;
/ / scanf ("% d", & n);
// ret = Fac1 (n); // La forma de hacer un bucle
// printf ("% d \ n", ret);
//
// return 0;
//}
// 递归
int Fac2 (int n)
{
if (n <= 1)
return 1;
de lo contrario,
devuelve n * Fac2 (n - 1);
}
int main ()
{
// Encuentra el factorial de
n int n = 0;
int ret = 0;
scanf ("% d", & n);
ret = Fac2 (n); // La forma del bucle
printf ("% d \ n ", ret);
return 0;}
Encuentre el número n de Fibonacci (sin considerar el desbordamiento)
1 1 2 3 5 8 13 21 34
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
// 迭代
int Fib (int n)
{
int a = 1;
int b = 1;
int c = 0;
mientras que (n> 2)
{
c = a + b;
a = b;
b = c;
norte--;
}
return c;
}
int main ()
{
int n = 0;
int ret = 0;
scanf ("% d", & n);
ret = Fib (n);
printf ("ret =% d \ n", ret);
return 0;
}
//// Recursion
// int count = 0;
// int Fib (int n)
// {
// if (n == 3) // Probar el número de cálculos del tercer número de Fibonacci
// {
/ / count ++;
//}
// int ret = 0;
// if (n <= 2)
// return 1;
// else
//
// return Fib (n-1) + Fib (n-2);
/ /
//}
//
// int main ()
// {
// int n = 0;
// int ret = 0;
// scanf ("% d", & n);
// ret = Fib (n);
// printf ("ret =% d \ n", ret);
// printf ("count =% d \ n", count);
// return 0;
//}
Varios problemas clásicos de recursividad de funciones (investigación independiente):
1. El problema de la Torre de Hanoi
2. El problema del salto de la rana desde la plataforma
67 preguntas escritas de prueba de la "Oferta del dedo espada"