Composante connexe Java

Bonjour,
j'ai besoin de resortir à partir d'une ArrayList les composantes connexes voici mon code mais malheureusement il ne donne pas la bonne solution. par exemple pour la liste suivante: [24, 36, 35, 27, 14, 35, 23, 18, 12, 27, 27, 31, 12, 15, 28, 11, 23]
il me donne que tous appartiennent a une meme composante connexe alors que c'est pas vrai.

merci d'avance.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
  public ArrayList <Integer> composanteConnexe (ArrayList <Integer> ta){
    	connexe=false;
	ListIterator l=ta.listIterator();
	//t.add(ta.get(0));
	//t.add(ta.get(1));
	while(l.hasNext()){
		es++;
		int index=0;
		Object rech=ta.get(0);
		ta.remove(0);
		ListIterator i=ta.listIterator();
		while( i.hasNext()){
			if((i.next()).equals(rech)){
				int x=(i.previousIndex()-1);
				int x2=(i.previousIndex()+1);
				if(index % 2!=0 && es % 2!=0){
					if(t.contains(rech)||t.contains(ta.get(x2))){
					t.add(rech);
					t.add(ta.get(x2));connexe=true;}
					}
				else{
					if(index % 2!=0 || !i.hasNext()||es % 2!=0){
						if(t.contains(ta.get(x))||t.contains(rech)){
						t.add(ta.get(x));
						t.add(rech);connexe=true;}
						}
					else{
						if(t.contains(rech)||t.contains(ta.get(x2))){
						t.add(rech);
						t.add(ta.get(x2));connexe=true;}
						}
					}
				}		
			index++;
			}		
		}
	return t;
	}

Bonjour,

Le code que tu as mit ne compile pas... il manque connexe,es et t

Je ne saisi pas non plus comment tu veux sortir des composantes connexes d'une liste d'entier ?

Salut,

Ils sont déclarés plus haut j'ai juste oublié de les mettre dans ce code. En fait ces entiers sont les numéros des nœuds d'un graphe par exemple si X12 X26 un lien et il existe un autre lien entre X26 X32 donc X12, X26,X32 appartiennent a une même composante connexe pour mon problème normalement je l'ai résolu normalement.

Voici le code final :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
  public ArrayList <Integer> composanteConnexe (ArrayList <Integer> ta){
    	ArrayList tac=new ArrayList();
    	connexe=false;
    	tac=copie(ta);
	ListIterator l=ta.listIterator();
	//t.add(ta.get(0));
	//t.add(ta.get(1));
	while(l.hasNext()){
		es++;
		int index=0;
		l.next();
		Object rech=tac.get(0);
		int y=(l.previousIndex()-1);//non
		int y2=(l.previousIndex()+1);
		//ta.remove(0);
	//	System.out.println("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"+tac.size());
		if(tac.size()!=0)tac.remove(0);
		ListIterator i=tac.listIterator();
		while( i.hasNext()){
			if((i.next()).equals(rech)){
				int x=(i.previousIndex()-1);
				System.out.println(x);
				int x2=(i.previousIndex()+1);
				System.out.println(x2);
				if(index % 2!=0 && es % 2!=0){
					//if(t.contains(rech)||t.contains(ta.get(x2))){
					t.add(rech);
					t.add(tac.get(x2));
					t.add(rech);
					t.add(ta.get(y2));
					connexe=true;//}
					}
				else{
					if(index % 2!=0 || !i.hasNext()||es % 2!=0){
						//if(t.contains(ta.get(x))||t.contains(rech)){
						t.add(tac.get(x));
						t.add(rech);
						if(es%2!=0){
						t.add(rech);
						t.add(ta.get(y2));}
						if(es%2==0){
							t.add(ta.get(y));
						t.add(rech);}
 
						connexe=true;//}
						}
					else{
						//if(t.contains(rech)||t.contains(ta.get(x2))){
						t.add(rech);
						t.add(tac.get(x2));
						t.add(rech);
						t.add(ta.get(y2));
						connexe=true;//}
						}
					}
				}		
			index++;
			}		
		}
	return t;
	}

Je dispose de 3 régions et chaque région est constituée de 8 noeuds.
Chaque noeud est identifié par le numéro de région associé et le numéro de noeud, par exemple (X12: la région 1 et le 2ème noeuds).

Ma tache est de déterminer les composantes connexes qui seront à la responsabilité d'un même contrôleur et les les noeuds parallèles. Par exemple (X12 X21 et X13 X25) sont à la responsabilité d'un même contrôleur.

Mon code est le suivant:
La classe main:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package DOC;
import java.io.IOException;
import java.util.*;
import java.applet.*;
import java.io.*;
import java.lang.*;
 
public class Conseiller {
    //Declaration
            //Object [] t =new Object[100];
 
    static    Traitement o=new Traitement();
    static    ArrayList tab = new ArrayList(100);
    static    ArrayList tabc=new ArrayList();
    static    ArrayList cc=new ArrayList();
    static    ArrayList sd=new ArrayList();
    static    ArrayList res=new ArrayList();
    static    ArrayList verf=new ArrayList();
    static    ArrayList par1=new ArrayList();
    static    ArrayList par2=new ArrayList();
    static    ArrayList lcons=new ArrayList();
 
    public static void main(String[] args) throws IOException {
 
               RecupererXml r=new RecupererXml();
            myGenerator g=new myGenerator();
         r.parser();
           r.variableExterne();
            tab=o.convertir(r.lve);
            o.affich(tab);
           o.affich(o.concat(tab));
            //o.affich(tab);
            if(!tab.isEmpty()){
                int k=0;
                for(int i=0;i<=tab.size();i++){ 
                tabc=o.copie(tab);
                o.connexe=false;
                o.parallele=false;
                cc=o.composanteConnexe(tabc);
                System.out.println(o.connexe);
                if(o.connexe==true){
                    System.out.println("alooo");
                    sd=o.distinct(cc);
                    o.affich(sd);
                    tabc=o.copie(tab);
                    res=o.reste(tabc);
                    o.affich(res);
                //    verf=o.verification(res); 
                //    tabc=o.copie(tab);
                //    res=o.reste(tabc);
                    System.out.println("apreq verification");
                    o.affich(res);
                    par1=o.parallele(res);
                   if(o.t1.size()==tab.size()) {o.affichage(o.t1);  r.ajouterConseiller(o.concat(o.t1));
                     lcons.add(o.C); g.save("Random_8_8_60_70.xml",r.document);System.exit(0);}
                    System.out.println("par1");
                    o.affich(par1);
                    tabc=o.copie(tab);
                    res= o.reste(tabc);
                    System.out.println("lolllllllllllllllllle resteeeeeeeeeeeeeeee"+o.C);
                    o.affich(res);
                    o.affichage(o.t1);
                     r.ajouterConseiller(o.concat(o.t1));
                     lcons.add(o.C);
                    o.t1=new ArrayList();
                    o.C=o.C+1;
                    tab=o.copie(res);
 
                }
                else{
                    tabc=o.copie(tab);
                    par2=o.parallele2(tabc);
                    System.out.println(o.parallele);
                    if(o.parallele){
                        System.out.println("parallele2");
                        o.affichage(par2);
                        res=o.reste2(tabc);
                        r.ajouterConseiller(o.concat(par2));
                        lcons.add(o.C);   
                        o.t1=new ArrayList();
                        o.C=o.C+1;
                        tab=o.copie(res);
                    }
                    else
                    {
                        res=o.copie(tab);
                        ListIterator k6=res.listIterator();
                        while(k6.hasNext()){
                            ArrayList a=new ArrayList();
                            System.out.println("reste");
                            System.out.printf("\n le conseiller responsable de la contrainte X"+k6.next()+" X"+k6.next()+"est C"+o.C);
                            a.add(res.get(0));a.add(res.get(0));
                            r.ajouterConseiller(o.concat(tab));
                            lcons.add(o.C);
                            o.C=o.C+1;
                            res.remove(0);res.remove(0);
                            k6=res.listIterator();
                            tab=o.copie(res);
 
                        }
                        res=new ArrayList();
                    }
                }
                }
            }
            g.save("Random_8_8_60_70.xml",r.document);
    }
}

La classe qui traite les cas:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
package DOC;
 
import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Scanner;
 
public class Traitement {
    //Declaration
    Variable v,v2;
static ArrayList tab = new ArrayList(100);
Scanner sc=new Scanner(System.in);
static ArrayList tabc=new ArrayList();
static ArrayList tp=new ArrayList();
static ArrayList t1=new ArrayList();
static ArrayList t=new ArrayList();
static    ArrayList t2=new ArrayList(); //t2 remplace tab
static  ArrayList t4=new ArrayList();
static ArrayList res =new ArrayList();
static ArrayList t3=new ArrayList();
//static ArrayList lsc=new ArrayList();
static Object rech2=0;
static int C=1,es=0,m,e;
static boolean cc = false;
static boolean connexe=false;   
static boolean parallele=false;
    //***************************Composante connexe********************************
 
//avant de faire appel a la fonction composante connexe on doit faire une copie de tab et mettre le resultat dans le parametre
    public ArrayList <Integer> composanteConnexe (ArrayList <Integer> ta){
        ArrayList tac=new ArrayList();
        connexe=false;
        tac=copie(ta);
    ListIterator l=ta.listIterator();
    //t.add(ta.get(0));
    //t.add(ta.get(1));
    while(l.hasNext()){
        es++;
        int index=0;
        l.next();
        Object rech=tac.get(0);
        int y=(l.previousIndex()-1);//non
        int y2=(l.previousIndex()+1);
        //ta.remove(0);
    //    System.out.println("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"+tac.size());
        if(tac.size()!=0)tac.remove(0);
        ListIterator i=tac.listIterator();
        while( i.hasNext()){
            if((i.next()).equals(rech)){
                int x=(i.previousIndex()-1);
                System.out.println(x);
                int x2=(i.previousIndex()+1);
                System.out.println(x2);
                if(index % 2!=0 && es % 2!=0){
                    if(connexe==false || t.contains(rech)||t.contains(ta.get(x2))){
                    t.add(rech);
                    t.add(tac.get(x2));
                    t.add(rech);
                    t.add(ta.get(y2));
                    connexe=true;//}
                    }
                else{
                    if(index % 2!=0 || !i.hasNext()||es % 2!=0){
                    if(connexe==false || (t.contains(ta.get(x))||t.contains(rech))){
                        t.add(tac.get(x));
                        t.add(rech);
                        if(es%2!=0){
                        t.add(rech);
                        t.add(ta.get(y2));}
                        if(es%2==0){
                            t.add(ta.get(y));
                        t.add(rech);}
 
                        connexe=true;}
                        }
                    else{
                    if(connexe==false || (t.contains(rech)||t.contains(ta.get(x2)))){
                        t.add(rech);
                        t.add(tac.get(x2));
                        t.add(rech);
                        t.add(ta.get(y2));
                        connexe=true;}
                        }
                    }
                }        
            index++;
            }        
        }
    return t;
    } 
 
  //******************************************Garder les éléments distincts**************************
 
    //dans le paramêtre on doit mettre le resultat de la fonction composante connexe
    public ArrayList <Integer> distinct(ArrayList <Integer> ta){
    ListIterator l1=ta.listIterator();
    while(l1.hasNext()){
        m=0;e=0;
        Object rech=l1.next();
        t1.add(rech);
        if(ta.size()>=2)rech2=ta.get(1);
        ta.remove(0);
        l1=ta.listIterator();
        ArrayList t2=new ArrayList();
        ListIterator i=ta.listIterator();
        while (i.hasNext()){t2.add(i.next());}
        ListIterator j=t2.listIterator();
        while(j.hasNext()){
            Object najla=j.next();
            j.remove();
            if(najla.equals(rech))
                if(t2.size()!=0 &&t2.get(0).equals(rech2) ){
                    t2.remove(0);
                    ta.remove(e);
                    ta.remove(e);
                    e=e-1;
                    l1=ta.listIterator();
                    }
            j=t2.listIterator();e++;
            }
        t1.add(rech2);
        if(ta.size()>0)ta.remove(0);
        l1=ta.listIterator();
    }
    return t1;
    }
 
    //***********************************************Affichage**********************************
    public void affichage(ArrayList <Integer> ta){
        ListIterator k=ta.listIterator();
           while(k.hasNext())
        System.out.printf("\n le conseiller responsable de la contrainte X"+k.next()+" X"+k.next()+" est C"+C);
    }
    //**************************************************copie************************************
    public ArrayList <Integer>  copie(ArrayList <Integer>  ta){
        ArrayList t2=new ArrayList();
        ListIterator i=ta.listIterator();
        while (i.hasNext()){t2.add(i.next());}
        return t2;
    }
 
  //************************************************Le reste des contraintes***********************
    //Faire une copie sur le tab et ta1 cé le t1 sans doublons
    public ArrayList <Integer> reste(ArrayList ta){
        res=new ArrayList();
         ListIterator i=ta.listIterator();
         while (i.hasNext()){t2.add(i.next());}
         //ArrayList t3=new ArrayList(); //t3 remplace t1 qui est le resultat de la composante connexe
         ListIterator t4i=t1.listIterator();
         while(t4i.hasNext()){t4.add(t4i.next());}
         ListIterator i1=t2.listIterator();
    while(i1.hasNext()){
        m=0;e=0;
        boolean trou=false;
        Object rech=i1.next();
        if(t2.size()>=2)rech2=t2.get(1);
        t2.remove(0);
        t3=new ArrayList();
        ListIterator p=t4.listIterator();
        while (p.hasNext()){t3.add(p.next());}
        ListIterator x1=t3.listIterator();
        while(x1.hasNext() && trou==false){
            Object najla=x1.next();
            x1.remove();
            if(najla.equals(rech))
                if(t3.get(0).equals(rech2)){
                    t3.remove(0);
                    if(e!=0 && t3.size()!=0 )t3.remove(0); 
                    t4.remove(e);
                    t4.remove(e);
                    m++;x1=t3.listIterator(); trou=true;
                    }
            e++;        
            }
        if(m==0)
        {res.add(rech);res.add(rech2);}
        t2.remove(0);i1=t2.listIterator();
    }
    return res;
    }
 
  //********************Verifier s'il ya d'autre contrainte qui peuvent appartenir à t1 le cas de 14-28
    //sans doublons
    public ArrayList <Integer> verification(ArrayList<Integer> ta){
        ListIterator   i1=ta.listIterator();
        e=0;
        while(i1.hasNext()){
        boolean n1=false;
        Object najla=i1.next();
 
        if(t1.contains(najla)){
            if(e%2==0){
                //e=e-1;
                //System.out.println("alooooooooooooooooooooooo");
                t1.add(najla);
                t1.add(i1.next());
                //ta.remove(e);
                //ta.remove(e);
                ta.remove(0);
                ta.remove(0);n1=true;
                i1=ta.listIterator();//e=0;
            }
 
            else
                {//e=e-1;
                //System.out.println("alooooooooooooooooooooooo");//System.out.println(ta.get(i1.previousIndex()-1));
        t1.add(ta.get(i1.previousIndex()-1));
        t1.add(najla);
        //ta.remove(e);
        //ta.remove(i1.previousIndex()-1);
        ta.remove(0);
        ta.remove(0);n1=true;
        i1=ta.listIterator();//e=e-1;
        }}
        e++;
        if(e%2==0 && e>2 &&  n1==false){ta.remove(0);ta.remove(0);i1=ta.listIterator();}
    }
    //return ta;
    return t1;
    }
    //Fin vérification
 
 // **************************************VOIR LES LIENS PARALLèLES*********************************
 
    public ArrayList <Integer> parallele(ArrayList <Integer> ta){
    ListIterator i1=ta.listIterator();
    ArrayList res2=new ArrayList();
    while(i1.hasNext()){
        res2.add(i1.next());
    }
    i1=res2.listIterator();e=0;
    while(i1.hasNext()){
 
        boolean trou=false;
        Object rech=res2.get(0);
        res2.remove(0);
        i1=res2.listIterator();
         rech2=i1.next();
        int entier1=(Integer.parseInt(rech.toString()))/ 10;
        int entier2=(Integer.parseInt(rech2.toString()))/10;
        ListIterator i2=t1.listIterator();
        t2=new ArrayList();
        while(i2.hasNext()){
            t2.add(i2.next());
        }
        i2=t2.listIterator();
        while(i2.hasNext()&& trou==false){
            Object rech3=t2.get(0);
            t2.remove(0);
            i2=t2.listIterator();
            Object rech4=i2.next();
            int entier3=(Integer.parseInt(rech3.toString()))/10;
            int entier4=(Integer.parseInt(rech4.toString()))/10;
            if(entier1==entier3 && entier2==entier4|| entier1==entier4 && entier2==entier3){
                t1.add(rech);
                t1.add(rech2);trou=true;
                i1=ta.listIterator();
                ta.remove(e);ta.remove(e);
            }
            t2.remove(0);i2=t2.listIterator();
            }
        if(trou==false)
            e++;
        else
            e=0;
        res2.remove(0);i1=res2.listIterator();
    }
    return ta;
    }
    //Fin parallèle
 
    //****************************PARALELE SANS CONNEXE*************************************************
 
    public ArrayList <Integer> parallele2(ArrayList  ta){
        parallele=false;
    tp=new ArrayList();
     ListIterator  i1=ta.listIterator();
       ArrayList res2=new ArrayList();
       while(i1.hasNext()){
           res2.add(i1.next());
       }
       i1=res2.listIterator();
       e=0;
       while(i1.hasNext()){
           boolean trou=false;
           Object rech=res2.get(0);
           res2.remove(0);
           i1=res2.listIterator();
            rech2=i1.next();
           int entier1=(Integer.parseInt(rech.toString()))/ 10;
           int entier2=(Integer.parseInt(rech2.toString()))/10;
    ta.remove(rech);ta.remove(rech2);
           ListIterator i2=ta.listIterator();
           t2=new ArrayList();
           while(i2.hasNext()){
               t2.add(i2.next());
           }
           i2=t2.listIterator();
           ta.add(rech);ta.add(rech2);
           while(i2.hasNext()&& trou==false){
               Object rech3=t2.get(0);
               t2.remove(0);
               i2=t2.listIterator();
               Object rech4=i2.next();
               int entier3=(Integer.parseInt(rech3.toString()))/10;
               int entier4=(Integer.parseInt(rech4.toString()))/10;
               if(entier1==entier3 && entier2==entier4|| entier1==entier4 && entier2==entier3){
                   tp.add(rech);
                   tp.add(rech2);trou=true;
                   i1=ta.listIterator();parallele=true;
               }
               t2.remove(0);i2=t2.listIterator();
               }
           if(trou==false)
               e++;
           else
               e=0;
           res2.remove(0);i1=res2.listIterator();
       }
       if(tp.size()!=0) parallele=true;
       return tp;
    }
    //************************************************Le reste des contraintes***********************
    //Faire une copie sur le tab et ta1 cé le t1 sans doublons
    public ArrayList <Integer> reste2(ArrayList ta){
        res=new ArrayList();
         ListIterator i=ta.listIterator();
         while (i.hasNext()){t2.add(i.next());}
         //ArrayList t3=new ArrayList(); //t3 remplace t1 qui est le resultat de la composante connexe
         ListIterator t4i=tp.listIterator();
         while(t4i.hasNext()){t4.add(t4i.next());}
         t4i=t4.listIterator();
         ListIterator i1=t2.listIterator();
        t2=distinct(t2);
        i1=t2.listIterator();
    while(i1.hasNext()){
        m=0;e=0;
        boolean trou=false;
        Object rech=i1.next();
        if(t2.size()>=2)rech2=t2.get(1);
        t2.remove(0);
        t3=new ArrayList();
        ListIterator p=t4.listIterator();
        while (p.hasNext()){t3.add(p.next());}
        ListIterator x1=t3.listIterator();
        while(x1.hasNext() && trou==false){
            Object najla=x1.next();
            x1.remove();
            if(najla.equals(rech))
                if(t3.get(0).equals(rech2)){
                    t3.remove(0);
                    if(e!=0 && t3.size()!=0)t3.remove(0); 
                    t4.remove(e);
                    t4.remove(e);
                    m++;x1=t3.listIterator(); trou=true;
                    }
            e++;        
            }
        if(m==0)
        {res.add(rech);res.add(rech2);}
        t2.remove(0);i1=t2.listIterator();
    }
    return res;
    }
    //***********************Convertir le tableau des variables externes en string*******************************
    public ArrayList <String> convertir(ArrayList <Variable> ta){
        ListIterator i=ta.listIterator();
        ArrayList nv=new ArrayList();
        while(i.hasNext()){
            v=(Variable)i.next();
            if(v!=null) nv.add(Integer.parseInt(v.getIdVar().toString()));
        }
        return nv;
    }
 
    //************************************concatener 2 case du tableau pour le comparer a scope******************
 
    public ArrayList <String> concat(ArrayList ta){
        ListIterator i=ta.listIterator();
        ArrayList lsc=new ArrayList();
        while(i.hasNext()){
            String x="";
            x="X"+i.next()+" X"+i.next();
            lsc.add(x);
        }
        return lsc;
    }
 
    public ArrayList dist(ArrayList ta){
        boolean trouve=false;
        ListIterator i=ta.listIterator();
        ArrayList acc=new ArrayList();
        ArrayList inter=new ArrayList();
        int j=0;
        while(i.hasNext()){
            j=0;
            inter=new ArrayList();
            trouve=false;
            Object ki=i.next();
            acc.add(ki);
            j++;
            while(j<ta.size()-1){
                if(ki.equals(ta.get(j))){
                    inter.add(ki);
                    inter.add(ta.get(j));
                    trouve=true;
                }
                j++;
            }
        if(trouve==true)
            ta.remove(inter);
 
            i=ta.listIterator();
        }
        return acc;
    }
 
 
  //********************************Affichernv**********************************************
    public void affich(ArrayList ta){
        System.out.println(ta);
    }   
}

Merci d'avance pour votre aide.

Avant d'entrer dans le coeur du problème, on va élaguer un peu le code :

1) Utilise des noms de variables compréhensible pour quelqu'un d'autre que toi:

Par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 static Traitement o = new Traitement(); static ArrayList tab = new ArrayList(100); static ArrayList tabc = new ArrayList(); static ArrayList cc = new ArrayList(); static ArrayList sd = new ArrayList(); static ArrayList res = new ArrayList(); static ArrayList verf = new ArrayList(); static ArrayList par1 = new ArrayList(); static ArrayList par2 = new ArrayList(); static ArrayList lcons = new ArrayList();
Je ne sais pas ce qu'est cc, tab versus tabc...
Essaye de mettre des bon noms de variable :)

2) Utilise les interfaces plutôt que les types réels :
Ex remplace

Code:

static ArrayList tab = new ArrayList(100);

par

Code:

static List tab = new ArrayList(100);

Même chose pour les signatures de méthodes.

3) Mets les generics partout :

Ex remplace

Code:

static ArrayList tab = new ArrayList(100);

par

Code:

static List<Integer> tab = new ArrayList<Integer>(100);

4) Tu as beaucoup de variable qui sont static alors que ça ne semble pas utile. Essai d'avoir un minimum de variable static

5) Sort les méthodes affichage et copie de classe Traitement et mets les dans un classe "Utilitaire". Par exemple ArrayConnexeUtils, tu dois mettre ces méthodes en static.

Bon courage :ccool: