private void echanger(Facette[] tab, int i, int j) {
        Facette tmp = tab[i];
        tab[i] = tab[j];
        tab[j] = tmp;
    }

    private int partitionner (
            Facette[] tab,
            int premier, // élément le plus à gauche
            int dernier, // élément le plus à gauche // dans la partition
            int pivot // emplacement du pivot
            ) {

            echanger(tab, pivot, dernier);
            int j = premier;
            for (int i=premier; i <= dernier-1; i++) {
                if (tab[dernier].estAvant(tab[i])) {
                    echanger(tab, i, j);
                    j = j + 1;
                }
            }
            echanger(tab, dernier, j);
            return j;
    }

    private void quickSort(Facette[] tab, int premier, int dernier) {

        int pivot;

        if (premier < dernier) {
            pivot = premier;
            pivot = partitionner(tab, premier, dernier, pivot);
            quickSort(tab, premier, pivot-1);
            quickSort(tab, pivot+1, dernier);
        } else {
            System.out.println("c faux");
        }
    }

    /**
     * trie les facettes de la forme coutrante en fonction de la distance à
     * l'origine on utilisera un des algorithmes vus en cours
     */
    public void trieFacettes() {
        int premier  = 0;
        int dernier = this.nbfac - 1;

        // on mélange le tableau
        this.shuffle();
        this.quickSort(tab, premier, dernier);
        System.out.println("trié !");
    }