Dans cette thèse, nous étudions des méthodes basées sur les systèmes de types à tailles pour la complexité en temps, en particulier pour l’analyse des processus du pi-calcul, un modèle basé sur les communications pour les calculs parallèles. L’idée centrale des types à tailles est de tracer la taille des valeurs d’un programme et d’utiliser cette information pour contrôler la récursion et en déduire des bornes de complexité en temps. Dans la première partie de cette thèse, nous nous intéressons à une approche théorique de la complexité, dans le cadre de la complexité computationnelle implicite (ICC). L’objectif de l’ICC est de caractériser des classes de complexité en utilisant la logique ou les types, généralement sans donner de bornes explicites. Plusieurs méthodes ont été développées pour la complexité en temps. Une approche principale vient de la logique linéaire, en utilisant des versions restreintes de la modalité "!", qui contrôle la duplication. Une autre approche est de se concentrer sur la taille des valeurs. Ces deux approches ont des défauts. La première approche induit une faible expressivité intentionnelle: certains programmes naturels en temps polynomial ne sont pas typables. Pour la seconde approche, elle est essentiellement linéaire, donc elle ne permet pas en particulier une utilisation non-linéaire des arguments d’ordres supérieurs. Dans cette thèse, nous surmontons ces contraintes en combinant les deux approches dans un système de type commun. Nous élaborons un système de type pour un langage abstrait fonctionnel qui autorise des arguments fonctionnels non-linéaires avec une expressivité intentionnelle vraisemblablement correcte. Notre approche se base sur la logique linéaire élémentaire combinée avec un système de types à tailles linéaires. Nous discutons de l’expressivité de ce système de type et nous prouvons qu’il donne une caractérisation des classes de complexité FPTIME et 2k-FEXPTIME. Dans la seconde partie de cette thèse, nous étudions l’analyse de complexité avec des types. Cette approche pour analyser la complexité des programmes est un sujet de recherche important, en particulier pour les langages fonctionnels dans lesquels la notion de composition est essentielle. Parmi toutes les approches possibles, nous nous intéressons aux types à tailles. Nous explorons comment utiliser ces types pour l’analyse de complexité parallèle dans le pi-calcul. Deux notions de complexités en temps sont étudiées: le temps de calcul total sans aucune parallélisation (travail), et le temps de calcul avec une parallélisation maximale (profondeur). Nous définissons des sémantiques opérationnelles pour refléter ces deux notions. La seconde sémantique est particulièrement importante car elle donne des preuves plus simple que d’autres notions apparentées à la profondeur. Nous présentons deux systèmes de types similaires à partir duquel on peut extraire une borne de complexité sur un processus. Ces systèmes sont inspirés à la fois par les types à tailles et les types entrée/sortie du pi-calcul, auxquels on ajoute des informations temporelles. Cependant, cette extension des types à tailles fonctionnels pour l’analyse de profondeur a une expressivité limitée, en particulier en présence de certains comportements concurrents comme les sémaphores. Dans le but d’avoir une analyse plus expressive, nous élaborons un système de type qui repose sur le concept des usages, utilisés originalement pour l’analyse des deadlocks.