C# contorni numerici

Question

Sto cercando di sviluppare un algoritmo in C# che possa prendere un elenco di array di URL e visualizzarli in un elenco numerato di contorni.

Come potete immaginare ho bisogno di aiuto. Qualcuno ha qualche suggerimento sulla logica da utilizzare per generare questo elenco?

Esempio di output:

1 - http://www.example.com/aboutus 
1.2 - http://www.example.com/aboutus/page1 
1.3 - http://www.example.com/aboutus/page2 
1.3.1 - http://www.example.com/aboutus/page2/page3 
1.3.1.1 - http://www.example.com/aboutus/page2/page3/page4 
1.3.2 - http://www.example.com/aboutus/page5/page6 
1.3.2.1 - http://www.example.com/aboutus/page5/page7/page9 
1.3.2.2 - http://www.example.com/aboutus/page5/page8/page10 

1.4 - http://www.example.com/aboutus/page10 
1.4.1 - http://www.example.com/aboutus/page10/page11 
1.4.2 - http://www.example.com/aboutus/page10/page12 

1.1.5 - http://www.example.com/aboutus/page13 

1.1.6 - http://www.example.com/aboutus/page14 
1.1.6.1 - http://www.example.com/aboutus/page14/page15 
1.1.6.2 - http://www.example.com/aboutus/page14/page16 
1.1.6.3 - http://www.example.com/aboutus/page14/page17 

... e così via

Answer 1

Probabilmente dovrete smantellare il protocollo e interrogare i parametri di stringa, quindi +1 al consiglio di usare la classe System.URI per gestirlo.

Per quanto riguarda la stampa in forma di albero - un approccio diretto è quello di utilizzare un Dictionary<string, string> per mantenere l'associazione di child (chiave) a un genitore (valore).

Un altro modo è sfruttare List<T>.Sort, ad es. in questo modo:

public static void Print(List<string> list) 
{ 
    var path = new Stack<string>(); 
    var count = new Stack<int>(); 
    path.Push(""); 
    count.Push(0); 

    list.Sort(new Comparison<string>(UrlComparison)); 

    foreach (var x in list) 
    { 
     while (!x.StartsWith(path.Peek())) { path.Pop(); count.Pop(); } 
     count.Push(count.Pop() + 1); 
     foreach(var n in count.Reverse()) Console.Write("{0}.", n); 
     Console.WriteLine(" {0}", x); 
     path.Push(x); 
     count.Push(0); 
    } 
} 

Purtroppo, p.campbell è giusto, un confronto personalizzato è effettivamente necessaria qui, il che rende questa applicazione ancora piuttosto performante, ma più ingombranti (?:-abuse avvertimento):

public static int UrlComparison(string x, string y) 
{ 
    if (x == null && y == null) return 0; 
    if (x == null) return -1; 
    if (y == null) return 1; 
    for(int n = 0; n < Math.Min(x.Length, y.Length); n++) 
    { 
     char cx = x[n], cy = y[n]; 
     if(cx == cy) continue; 
     return 
      (cx == '/' || cx == '.' || cx == '?') ? -1 : 
      (cy == '/' || cy == '.' || cy == '?') ? 1 : 
      (cx > cy) ? 1 : -1; 
    } 
    return (x.Length == y.Length) ? 0 : (x.Length > y.Length) ? 1 : -1; 
} 

PS: Basta per mettere un disclaimer, sento che la logica di stack è consize, ma un po 'più complessa da capire. In un progetto a lungo termine, rimango con un dizionario genitore figlio.

Answer 2

Può essere questo Generic Tree Collection sarà utile.

Ci sono alcune raccolte di alberi su Code Project: one, two.

Answer 3

Dai un'occhiata alla classe System.URI. Dovrebbe avere alcuni metodi e caratteristiche che dovrebbero essere utili, come la proprietà dei segmenti che fa splendere l'uri nelle sue parti segmentate (diviso in base alla barra). È possibile creare un elenco degli array di segmenti, ordinare l'elenco, quindi semplicemente iterare l'elenco regolando i numeri a seconda che i segmenti di indice dell'elenco corrente corrispondano ai segmenti dell'indice di elenco precedenti.

Answer 4

Penso che sia necessario implementare una sorta di raccolta di alberi per gestire l'ordine. Perché se aggiungessi un nuovo collegamento chiamato http://www.example.com, diventerebbe 1 invece di http://www.example.com/aboutus.

Quindi è possibile stampare l'attraversamento in ordine dell'albero e sarà estremamente semplice.