Fonctions: divisées en fonctions de bibliothèque et fonctions
personnalisées . Les fonctions personnalisées, comme les fonctions de bibliothèque, ont des noms de fonction, des types de valeur de retour et des paramètres de fonction; mais la différence est que ces fonctions sont toutes conçues par nous-mêmes.
Appel de fonction: appel
par valeur:
les paramètres formels et réels de la fonction occupent différents blocs mémoire, et la modification des paramètres formels n'affectera pas l'
appel des paramètres réels : l'
appel par adresse passe l'adresse mémoire de la variable créée en dehors de la fonction à Une façon d'appeler des fonctions pour des paramètres de fonction
Cette façon de passer des paramètres permet à la fonction d'établir une connexion réelle avec des variables extérieures à la fonction, c'est-à-dire que les variables extérieures à la fonction peuvent être directement manipulées à l'intérieur de la fonction.
#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);
// retourne 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);
// Swap (a, b);
// / tmp = a;
// a = b;
// b = tmp; /
// printf ("a =% db =% d \ n", a, b);
// retour 0;
//}
Exercice:
1. Ecrivez une fonction pour déterminer si un nombre est un nombre premier.
2. Écrivez une fonction pour déterminer si une année est une année bissextile.
3. Ecrire une fonction pour effectuer une recherche binaire d'un entier et d'un tableau ordonné
4. Ecrire une fonction Chaque fois que cette fonction est appelée, la valeur de num sera augmentée de 1.
Récursivité de fonction:
la compétence de programmation d'un programme qui s'appelle lui-même est appelée récursivité. En tant qu'algorithme, la récursivité est largement utilisée dans les langages de programmation. Un processus ou une fonction a une méthode pour s'appeler directement ou indirectement dans sa définition ou sa description. Transformez un problème volumineux et complexe en un problème plus petit, similaire au problème d'origine. La stratégie récursive ne nécessite qu'un petit nombre de programmes pour décrire les multiples calculs répétitifs nécessaires au processus de résolution du problème, ce qui réduit considérablement le code. le montant. La principale façon de penser la récursivité réside dans
les deux conditions nécessaires pour transformer de grandes choses en petites récursions:
1. Il y a des restrictions, lorsque cette condition est remplie, la récursivité ne continuera pas.
2. Après chaque appel récursif, il se rapproche de plus en plus de cette restriction.
// Récursivité de la fonction
// int main ()
// {
// printf ("hehe \ n");
// main (); // débordement de pile
// return 0;
//}
void print (int n) // 1234
{
if (n> 9) // condition récursive 1
{
print (n / 10); // condition récursive 2
}
printf ("% d", n% 10);
}
int main ()
{
unsigned int num = 0;
scanf ("% d", & num); // 1234
print (num);
return 0;
}
L'écriture de fonctions n'est pas autorisée pour créer des variables temporaires, recherchez la longueur de la chaîne
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
// Crée une variable temporaire et trouve la longueur de la chaîne
// int my_strlen (char str)
// {
// int count = 0;
// while ( str! = '\ 0')
// {
// count ++;
// str ++;
//}
// return count;
//}
// La fonction de création n'est pas autorisée à créer des variables temporaires. Pour trouver la longueur de la chaîne, utilisez la méthode récursive
int my_strlen (char str)
{
if ( str! = '\ 0')
return 1 + my_strlen (str + 1);
else
return 0;
// De grandes choses se transforment en petites
// 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); // Trouver la longueur de la chaîne
// printf ("% d \ n", len);
// Implémenter un strlen Function
int len = my_strlen (arr); // arr est un tableau, le tableau reçoit des paramètres, ce qui est passé n'est pas le tableau entier, mais l'adresse d'un élément
printf ("len =% d \ n", len);
return 0;}
Récursivité et itération
Récursivité: la fonction s'appelle elle-même est récursivité;
itération: consiste à calculer une chose à plusieurs reprises et à faire une chose à plusieurs reprises;
trouver la factorielle de n
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
//// Boucle
// int Fac1 (int n)
// {
// int i = 0;
// int ret = 1;
// for (i = 1, i <= n, i ++)
// {
// ret * = i;
//}
// return ret;
//}
//
// int main ()
// {
// // Trouver la factorielle de
n // int n = 0;
// int ret = 0;
/ / scanf ("% d", & n);
// ret = Fac1 (n); // La façon de boucler
// printf ("% d \ n", ret);
//
// retourne 0;
//}
// 递归
int Fac2 (int n)
{
if (n <= 1)
return 1;
sinon
retourner n * Fac2 (n - 1);
}
int main ()
{
// Trouver la factorielle de
n int n = 0;
int ret = 0;
scanf ("% d", & n);
ret = Fac2 (n); // Le chemin de la boucle
printf ("% d \ n ", ret);
return 0;}
Trouvez le nième nombre de Fibonacci (sans tenir compte du débordement)
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;
tandis que (n> 2)
{
c = a + b;
a = b;
b = c;
n--;
}
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) // Teste le nombre de calculs du troisième nombre de Fibonacci
// {
/ / count ++;
//}
// int ret = 0;
// if (n <= 2)
// renvoie 1;
// else
//
// renvoie 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);
// renvoie 0;
//}
Plusieurs problèmes classiques de récursivité des fonctions (recherche indépendante):
1. Le problème de la tour de Hanoi
2. Le problème du saut de grenouille depuis la plate-forme
67 questions du test écrit de "Sword Finger Offer"