projetTRI.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import zeros,array\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tri_selection(tableau):\n",
    "    nb = len(tableau)\n",
    "    for en_cours in range(0,nb):    \n",
    "        plus_petit = en_cours\n",
    "        for j in range(en_cours+1,nb) :\n",
    "            if tableau[j] < tableau[plus_petit] :\n",
    "                plus_petit = j\n",
    "        if min is not en_cours :\n",
    "            temp = tableau[en_cours]\n",
    "            tableau[en_cours] = tableau[plus_petit]\n",
    "            tableau[plus_petit] = temp\n",
    "    return tableau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 4, 5, 6, 7, 9, 9, 9, 9, 9])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tableau = numpy.random.randint(0,10,size=10)\n",
    "tri_selection(tableau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tri_bulle(tableau):\n",
    "    permutation = True\n",
    "    passage = 0\n",
    "    while permutation == True:\n",
    "        permutation = False\n",
    "        passage = passage + 1\n",
    "        for en_cours in range(0, len(tableau) - passage):\n",
    "            if tableau[en_cours] > tableau[en_cours + 1]:\n",
    "                permutation = True\n",
    "                # On echange les deux elements\n",
    "                tableau[en_cours], tableau[en_cours + 1] = \\\n",
    "                tableau[en_cours + 1],tableau[en_cours]\n",
    "    return tableau  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 2, 4, 4, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tableau = numpy.random.randint(0,10,size=10)\n",
    "tri_bulle(tableau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tri_insertion(tableau):\n",
    "    for i in range(1,len(tableau)):\n",
    "        en_cours = tableau[i]\n",
    "        j = i\n",
    "        #décalage des éléments du tableau }\n",
    "        while j>0 and tableau[j-1]>en_cours:\n",
    "            tableau[j]=tableau[j-1]\n",
    "            j = j-1\n",
    "        #on insère l'élément à sa place\n",
    "        tableau[j]=en_cours\n",
    "    return tableau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 3, 4, 4, 4, 5, 7, 7, 9])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tableau = numpy.random.randint(0,10,size=10)\n",
    "tri_insertion(tableau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fusion(gauche,droite):\n",
    "    resultat = []\n",
    "    index_gauche, index_droite = 0, 0\n",
    "    while index_gauche < len(gauche) and index_droite < len(droite):        \n",
    "        if gauche[index_gauche] <= droite[index_droite]:\n",
    "            resultat.append(gauche[index_gauche])\n",
    "            index_gauche += 1\n",
    "        else:\n",
    "            resultat.append(droite[index_droite])\n",
    "            index_droite += 1\n",
    "    if gauche:\n",
    "        resultat.extend(gauche[index_gauche:])\n",
    "    if droite:\n",
    "        resultat.extend(droite[index_droite:])\n",
    "    return resultat\n",
    " \n",
    "def tri_fusion(m):\n",
    "    if len(m) <= 1:\n",
    "        return m\n",
    "    milieu = len(m) // 2\n",
    "    gauche = m[:milieu]\n",
    "    droite = m[milieu:]\n",
    "    gauche = tri_fusion(gauche)\n",
    "    droite = tri_fusion(droite)\n",
    "    return list(fusion(gauche, droite))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 2, 3, 4, 4, 5, 7, 7]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tableau = numpy.random.randint(0,10,size=10)\n",
    "tri_fusion(tableau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tri_rapide(t):\n",
    "    if t == []:\n",
    "        return []\n",
    "    else:\n",
    "        pivot = t[0]\n",
    "        t1 = []\n",
    "        t2 = []\n",
    "    for x in t[1:]:\n",
    "        if x<pivot:\n",
    "            t1.append(x)\n",
    "        else:\n",
    "            t2.append(x)\n",
    "    return tri_rapide(t1)+[pivot]+tri_rapide(t2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-11-fcc77b81c130>:2: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n",
      "  if t == []:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 3, 5, 5, 7, 7, 7, 8]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tableau = numpy.random.randint(0,10,size=10)\n",
    "tri_rapide(tableau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def temps_insertion(N):\n",
    "    n=100\n",
    "    t1 =time.time()\n",
    "    for k in range(n):\n",
    "        liste = numpy.random.randint(0,N,size=N)\n",
    "        tri_insertion(liste)\n",
    "    t1 = time.time()-t1\n",
    "    return t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.008867025375366211"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temps_insertion(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1319434642791748, 0.48674845695495605]\n"
     ]
    }
   ],
   "source": [
    "M=[50, 100]#, 3000, 4000, 5000, 6000]\n",
    "z=[]\n",
    "for i in M:\n",
    "    z.append(temps_insertion(i))\n",
    "print(z)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def temps_selection(N):\n",
    "    n=100\n",
    "    t1 =time.time()\n",
    "    for k in range(n):\n",
    "        liste = numpy.random.randint(0,N,size=N)\n",
    "        tri_selection(liste)\n",
    "    t1 = time.time()-t1\n",
    "    return t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def temps_bulle(N):\n",
    "    n=100\n",
    "    t1 =time.time()\n",
    "    for k in range(n):\n",
    "        liste = numpy.random.randint(0,N,size=N)\n",
    "        tri_bulle(liste)\n",
    "    t1 = time.time()-t1\n",
    "    return t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    " def temps_fusion(N):\n",
    "    n=100\n",
    "    t1 =time.time()\n",
    "    for k in range(n):\n",
    "        liste = numpy.random.randint(0,N,size=N)\n",
    "        tri_fusion(liste)\n",
    "    t1 = time.time()-t1\n",
    "    return t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def temps_rapide(N):\n",
    "    n=100\n",
    "    t1 =time.time()\n",
    "    for k in range(n):\n",
    "        liste = numpy.random.randint(0,N,size=N)\n",
    "        tri_rapide(liste)\n",
    "    t1 = time.time()-t1\n",
    "    return t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-11-fcc77b81c130>:2: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n",
      "  if t == []:\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.08915019035339355, 0.35381340980529785, 33.088910818099976, 158.21448850631714, 549.5056948661804, 457.4591693878174]\n",
      "[0.14602088928222656, 0.43216824531555176, 58.48090147972107, 177.48673224449158, 386.4924511909485, 508.84882712364197]\n",
      "[0.04137468338012695, 0.04687309265136719, 1.0640227794647217, 2.0109386444091797, 1.292917013168335, 1.630678653717041]\n",
      "[0.0688176155090332, 0.11904096603393555, 2.187227964401245, 3.904552698135376, 3.055255889892578, 4.220713138580322]\n",
      "[0.2834324836730957, 0.7083663940429688, 107.43686747550964, 345.099901676178, 650.8801052570343, 889.8133885860443]\n"
     ]
    }
   ],
   "source": [
    "M=[50, 100, 1000, 2000, 4000, 5000]#, 3000, 4000, 5000, 6000]\n",
    "ins=[]\n",
    "selc=[]\n",
    "rap=[]\n",
    "fusi=[]\n",
    "bulle=[]\n",
    "for i in M:\n",
    "    ins.append(temps_insertion(i))\n",
    "    selc.append(temps_selection(i))\n",
    "    rap.append(temps_rapide(i))\n",
    "    fusi.append(temps_fusion(i))\n",
    "    bulle.append(temps_bulle(i))\n",
    "print(ins)\n",
    "print(selc)\n",
    "print(rap)\n",
    "print(fusi)\n",
    "print(bulle)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "y_selection=selc\n",
    "y_insertion=ins\n",
    "y_bulle=bulle\n",
    "y_rapid=rap\n",
    "y_fusion=fusi\n",
    "plt.plot(M,y_selection,label='tri_de_selection')\n",
    "plt.plot(M,y_insertion,label='tri_dinsertion')\n",
    "plt.plot(M,y_bulle,label=\"tri abulle\")\n",
    "plt.plot(M,y_rapid,label=\"tri rapide\")\n",
    "plt.plot(M,y_fusion,label=\"tri de fusion\")\n",
    "plt.xlabel(\"la complexité N\")\n",
    "plt.ylabel(\"temps\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}