程序员面试宝典8.2典型递归问题
今天看书看到8.2的递归问题,自己试了一下书上的代码,感觉尚有很多bug,于是自己写了一个。 主要是书中代码只是为了递归而递归,在递归的返回处理上做的不好。 贴上自己修改过的代码,仅作为日后复习之用。。 写程序时候发现几个问题,要注意: 1.一定要为v
今天看书看到8.2的递归问题,自己试了一下书上的代码,感觉尚有很多bug,于是自己写了一个。
主要是书中代码只是为了递归而递归,在递归的返回处理上做的不好。
贴上自己修改过的代码,仅作为日后复习之用。。
写程序时候发现几个问题,要注意:
1.一定要为vector
2.发现问题:使用*(*p+i)=i;赋值,调用时只能用指针+偏移值的方式,使用数组方式调用出错,如*p[i],而使用数组方式赋值,则只能使用数组方式调用。尚不明白是不是编译器的问题,留待学习。
#include
#include
#include
#include
using namespace std;
//建立比较串s在被比较串p中位置的vector。
void PrintfArrary(char* pstr,char* sstr,vector
{
for(int i=sstartnum;i
(*printarr[i]).push_back(j+1);
}
//递归调用,构建序列。
void printseq(vector
if(slen==0){
for(vector
cout
cout
}
else
{
int i=sum-slen;
if(i){
for(vector
if(*j>*((*out).end()-1)){
(*out).push_back((*j));
printseq(printarr,slen-1,out,sum);
(*out).erase((*out).end()-1,(*out).end());
}
}
}
else
for(vector
(*out).push_back((*j));
printseq(printarr,slen-1,out,sum);
(*out).erase((*out).end()-1,(*out).end());
}
}
}
//初始化及传递数据。
void ConnectSequence(char* pstr,char* sstr)
{
int plen=strlen(pstr);
int slen=strlen(sstr);
vector
for(int i=0;i
printarr[i]=new vector
}
vector
PrintfArrary(pstr,sstr,printarr,plen ,slen,0,0);
printseq(printarr,slen,out,slen);
}
int main(){
char* a="abdbccab";
char* b="abc";
ConnectSequence(a,b);
return 0;
}

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds





La profondeur de récursion des fonctions C++ est limitée et le dépassement de cette limite entraînera une erreur de débordement de pile. La valeur limite varie selon les systèmes et les compilateurs, mais se situe généralement entre 1 000 et 10 000. Les solutions incluent : 1. Optimisation de la récursion de queue ; 2. Appel de queue ; 3. Implémentation itérative ;

Oui, les expressions C++ Lambda peuvent prendre en charge la récursivité à l'aide de std::function : utilisez std::function pour capturer une référence à une expression Lambda. Avec une référence capturée, une expression Lambda peut s'appeler de manière récursive.

L'algorithme récursif résout des problèmes structurés grâce à l'auto-appel de fonctions. L'avantage est qu'il est simple et facile à comprendre, mais l'inconvénient est qu'il est moins efficace et peut provoquer un débordement de pile. L'algorithme non récursif évite la récursion en gérant explicitement le. structure de données de pile. L'avantage est qu'il est plus efficace et évite le débordement de pile, l'inconvénient est que le code peut être plus complexe. Le choix du récursif ou du non récursif dépend du problème et des contraintes spécifiques de la mise en œuvre.

Le 3 mars 2022, moins d'un mois après la naissance de Devin, le premier programmeur d'IA au monde, l'équipe NLP de l'Université de Princeton a développé un agent SWE pour programmeur d'IA open source. Il exploite le modèle GPT-4 pour résoudre automatiquement les problèmes dans les référentiels GitHub. Les performances de l'agent SWE sur l'ensemble de tests du banc SWE sont similaires à celles de Devin, prenant en moyenne 93 secondes et résolvant 12,29 % des problèmes. En interagissant avec un terminal dédié, SWE-agent peut ouvrir et rechercher le contenu des fichiers, utiliser la vérification automatique de la syntaxe, modifier des lignes spécifiques et écrire et exécuter des tests. (Remarque : le contenu ci-dessus est un léger ajustement du contenu original, mais les informations clés du texte original sont conservées et ne dépassent pas la limite de mots spécifiée.) SWE-A

Le charme de l'apprentissage du langage C : libérer le potentiel des programmeurs Avec le développement continu de la technologie, la programmation informatique est devenue un domaine qui a beaucoup attiré l'attention. Parmi les nombreux langages de programmation, le langage C a toujours été apprécié des programmeurs. Sa simplicité, son efficacité et sa large application font de l’apprentissage du langage C la première étape pour de nombreuses personnes souhaitant entrer dans le domaine de la programmation. Cet article discutera du charme de l’apprentissage du langage C et de la manière de libérer le potentiel des programmeurs en apprenant le langage C. Tout d’abord, le charme de l’apprentissage du langage C réside dans sa simplicité. Comparé à d'autres langages de programmation, le langage C

Une fonction récursive est une technique qui s'appelle à plusieurs reprises pour résoudre un problème de traitement de chaînes. Cela nécessite une condition de terminaison pour empêcher une récursion infinie. La récursivité est largement utilisée dans des opérations telles que l'inversion de chaînes et la vérification du palindrome.

L'optimisation de la récursivité de queue (TRO) améliore l'efficacité de certains appels récursifs. Il convertit les appels récursifs en instructions de saut et enregistre l'état du contexte dans des registres plutôt que sur la pile, éliminant ainsi les appels supplémentaires et les opérations de retour à la pile et améliorant l'efficacité de l'algorithme. En utilisant TRO, nous pouvons optimiser les fonctions récursives de queue (telles que les calculs factoriels). En remplaçant l'appel récursif de queue par une instruction goto, le compilateur convertira le saut goto en TRO et optimisera l'exécution de l'algorithme récursif.

Définition et optimisation récursive : Récursif : Une fonction s'appelle en interne pour résoudre des problèmes difficiles qui peuvent être décomposés en sous-problèmes plus petits. Récursion de queue : la fonction effectue tous les calculs avant d'effectuer un appel récursif, qui peut être optimisé en boucle. Condition d'optimisation de la récursion de queue : l'appel récursif est la dernière opération. Les paramètres d'appel récursif sont les mêmes que les paramètres d'appel d'origine. Exemple pratique : Calculer factoriel : La fonction auxiliaire factorial_helper implémente l'optimisation de la récursion de queue, élimine la pile d'appels et améliore l'efficacité. Calculer les nombres de Fibonacci : la fonction récursive de queue fibonacci_helper utilise l'optimisation pour calculer efficacement les nombres de Fibonacci.
