Liste chane

Une liste chane est une suite linaire et finie dlments(maillons/nuds) dun mme type
qui sont arrangs dans un certain ordre.
Nous distinguons :
les listes chanes simples : Information stocke + une rfrence vers son successeur
2 attributs
les listes doublement chanes : Information stocke + deux rfrences( successeur et
prdcesseur).
les listes circulaires simples ou doubles : la tte et la queue sont relies.
Laccs un lment quelconque ne peut se faire l'aide d'un indice de position mais
ncessite le parcours de tous ses prdcesseurs.
Dans le souci de ne pas altrer (localement ou globalement) la rfrence de tte de liste, nous
utiliserons une variable temporaire note cur (pour current) qui servira parcourir une liste
chane.
En Java :

public class LinkedList {

class Element {
int data;
Element next = null;
Element(int value) {
data = value;
next = null;}
}

private Element head = null;

private int length = 0;}

public LinkedList() { // Constructeur par dfaut

head = null;
length = 0;}

public int getLength() { //getter

return length;}

public boolean isEmpty() { //methode

return length == 0;}

public boolean isEmpty() { //meme methode

return head == null;}

while (cur != null) { // Parcours de tous les lments de la liste

.... // Code de traitement
....
cur = cur.next; } // Passage au nud suivant
Mthodes:

public void display() { //affichage d1 liste

Element cur = head;

if (isEmpty())
System.out.println("La liste est vide.");
else {
System.out.println("La liste contient : ");
while (cur != null) {
System.out.print(cur.data + "|");
cur = cur.next;}
System.out.println();}

public int countValue(int value) {

Element cur = head;
int n = 0;
while (cur != null) {
if (cur.data == value)
n++;
cur = cur.next;}
return n;}

public static final int NOT_FOUND = -1; //constante utilise ds la methode suivante

public int findValue(int value) {

Element cur = head;
int n = NOT_FOUND;
while (cur != null) {
n++;
if (cur.data == value)
return n;
cur = cur.next;}
return NOT_FOUND;}

public boolean isInList(int value) {

return findValue(value) != NOT_FOUND;}

public void insertAtHead(int value){ // Insertion en tte de la liste

Element tmp = new Element(value); //insertion,creation,initialisation
tmp.next = head; // Insertion par ajustement des liens
head = tmp;
length++;}

public void insertAtRear(int value) { // Insertion en queue de la liste

Element cur, tmp; //insertion
tmp = new Element(value); // creation,initialisation
if (isEmpty())
head = tmp;
else {
cur = head; // Recherche de la queue de liste
while (cur.next != null)
cur = cur.next;
cur.next = tmp;}
length++;}
public void deleteAllElements() { //suppression de tous les elements
Element cur = head;
while (cur != null) {
cur = head.next;
head.next = null;
head = cur;
length--;}}

public void reverse() {

Element cur = head, next, tmp;
if (isEmpty())
return;
cur = head.next; // Inversion du premier lment
head.next = null;
next = head; // Inversion du reste des lments
while (cur != null) {
tmp = cur.next;
cur.next = next;
next = cur;
cur = tmp;}
head = next;}

public void insert(int value) {

Element cur, prev, tmp;
tmp = new Element(value); // Cration et initialisation d'un nouveau noeud
if (isEmpty()) // cas particulier : Liste vide
head = tmp;
else if (value <= head.data) { // cas particulier : Insertion en tte de liste
tmp.next = head;
head = tmp;}
else { // Cas gnral
cur = head; // Recherche de la position d'insertion
prev = null;
while ((cur != null) && (cur.data < value)) {
prev = cur;
cur = cur.next;}
prev.next = tmp; // Insertion par ajustement des liens
tmp.next = cur;}
length++;}

public void delete(int value) {

Element cur = head, prev = null; // Cas particulier : Liste vide
if (isEmpty())
return; // Cas particulier : Suppression de la tte de liste
if (value == head.data) {
head = head.next;
length--;
return;} // Cas gnral : Recherche de la position de suppression
while ((cur != null) && (cur.data != value)) {
prev = cur;
cur = cur.next;}
if (cur != null){ // si cur == null alors l'lment n'est pas dans la liste
prev.next = cur.next;
length--;}} // Suppression et ajustement des liens