C# sortowanie tablic w porządku rosnącym i malejącym

Question

Mam problem z zapisaniem metody, która zwraca wartość true, jeśli elementy tablicy (liczby) są posortowane, rosnące lub malejące, i fałsz, jeśli nie są posortowane zamówienie. Mogę zwrócić poprawną wartość boolowską, jeśli tablica jest rosnąca, ale nie wiem, jak sprawdzić w porządku malejącym, również w tej samej metodzie. Obecnie mam:

public static bool IsArraySorted(int[] numbers) 
    { 
     for (int i = 1; i < numbers.Length; i++) 
     { 
      if (numbers[i - 1] > numbers[i]) 
      { 
       return false; 
      } 

     } 

     return true; 
    } 

Czy ktoś może zaoferować pomoc w zakresie sprawdzania uporządkowanego układu zstępującego? Twoje zdrowie!

Answer 1

To powinno być coś takiego:

public static bool IsArraySorted(int[] numbers) 
{ 
    bool? ascending = null; 

    for (int i = 1; i < numbers.Length; i++) 
    { 
     if (numbers[i - 1] != numbers[i]) 
     { 
      bool ascending2 = numbers[i - 1] < numbers[i]; 

      if (ascending == null) 
      { 
       ascending = ascending2; 
      } 
      else if (ascending.Value != ascending2) 
      { 
       return false; 
      } 
     } 
    } 

    return true; 
} 

Zauważ użycie zmiennej ascending zapisać "kierunek" tablicy. Został zainicjowany po raz pierwszy, gdy znaleziono dwa różne elementy.

Pamiętaj, że jeśli chcesz, możesz nawet zwrotu „kierunek” tablicy:

public static bool IsArraySorted(int[] numbers, out bool isAscending) 
{ 
    isAscending = true; 
    bool? ascending = null; 

i wewnątrz if (ascending == null)

if (ascending == null) 
{ 
    ascending = ascending2; 
    isAscending = ascending2; 
} 

Jest to ogólny wersja na podstawie IEnumerable<TSource>:

public static bool IsSorted<TSource>(IEnumerable<TSource> source, out bool isAscending, Comparer<TSource> comparer = null) 
{ 
    isAscending = true; 

    if (comparer == null) 
    { 
     comparer = Comparer<TSource>.Default; 
    } 

    bool first = true; 
    TSource previous = default(TSource); 

    bool? ascending = null; 

    foreach (TSource current in source) 
    { 
     if (!first) 
     { 
      int cmp = comparer.Compare(previous, current); 

      if (cmp != 0) 
      { 
       bool ascending2 = cmp < 0; 

       if (ascending == null) 
       { 
        ascending = ascending2; 
        isAscending = ascending2; 
       } 
       else if (ascending.Value != ascending2) 
       { 
        return false; 
       } 
      } 
     } 

     first = false; 
     previous = current; 
    } 

    return true; 
} 

Uwaga na użycie bool first/obsłużyć i - 1 (i fakt, że cykl for w stanie „przeskok” pierwszego elementu)

Answer 2

public static boolean checkSortedness(final int[] data) { 
    for(int i = 1; i < data.length; i++) { 
     if(data[i-1] > data[i]) { 
      return false; 
     } 
    } 
    return true; 
} 

Answer 3

LINQ -

public static bool IsArraySorted(int[] numbers) 
    { 
     var orderedAsc = numbers.OrderBy(a => a); 
     var orderedDes = numbers.OrderByDescending(a => a); 

     bool isSorted = numbers.SequenceEqual(orderedAsc) || 
         numbers.SequenceEqual(orderedDes); 
     return isSorted; 
    } 

Answer 4

ten wykorzystuje jedną pętlę badanie obu przypadkach:

public static bool IsSorted<T>(IEnumerable<T> items, Comparer<T> comparer = null) 
{ 
    if(items == null) throw new ArgumentNullException("items"); 
    if(!items.Skip(1).Any()) return true; // only one item 

    if (comparer == null) comparer = Comparer<T>.Default; 
    bool ascendingOrder = true; bool descendingOrder = true; 

    T last = items.First(); 
    foreach (T current in items.Skip(1)) 
    { 
     int diff = comparer.Compare(last, current); 
     if (diff > 0) 
     { 
      ascendingOrder = false; 
     } 
     if (diff < 0) 
     { 
      descendingOrder = false; 
     } 
     last = current; 
     if(!ascendingOrder && !descendingOrder) return false; 
    } 
    return (ascendingOrder || descendingOrder); 
} 

wykorzystanie:

int[] ints = { 1, 2, 3, 4, 5, 6 }; 
bool isOrderedAsc = IsSorted(ints); // true 
bool isOrderedDesc = IsSorted(ints.Reverse()); //true 

Jeśli mak e to metoda rozszerzenia, której można używać z dowolnym typem:

bool ordered = new[]{"A", "B", "C"}.IsSorted(); 

Answer 5

Gdzie jest moja odpowiedź? Napisałem go około godziny temu:

 public enum SortType 
     { 
      unsorted = 0, 
      ascending = 1, 
      descending = 2 
     } 

     public static SortType IsArraySorted(int[] numbers) 
     { 
      bool ascSorted = true; 
      bool descSorted = true; 

      List<int> asc = new List<int>(numbers);    

      asc.Sort(); 

      for (int i = 0; i < asc.Count; i++) 
      { 
       if (numbers[i] != asc[i]) ascSorted = false; 
       if (numbers[asc.Count - 1 - i] != asc[i]) descSorted = false; 
      } 

      return ascSorted ? SortType.ascending : (descSorted? SortType.descending : SortType.unsorted); 
     } 

Przykład: