Sortieren war schon immer eine Schlüsseloperation, die für viele Anwendungen und auch als Unterproblem vieler Probleme durchgeführt wird. Viele Variationen und Techniken wurden besprochen und ihr Wissen kann beim Programmieren nützlich sein. In diesem Artikel wird die Sortierung von Listen beschrieben, die eine Liste enthalten. Lassen Sie uns bestimmte Möglichkeiten besprechen, wie dies durchgeführt werden kann.
Methode Nr. 1: Verwendung von sorted() + Listenverständnis
Bei dieser Methode verwenden wir lediglich die Abkürzung des anwendbaren langen Prozesses. Die Liste wird iteriert und die nachfolgende Unterliste wird mithilfe der Sortierfunktion sortiert, wobei auch die innere Liste sortiert wird.
Primzahl Java
Schritt-für-Schritt-Ansatz:
- Wir beginnen mit der Initialisierung einer verschachtelten Liste test_list, die zwei Unterlisten enthält, von denen jede eine unterschiedliche Anzahl von Listen enthält, von denen jede zwei ganze Zahlen enthält.
- Anschließend drucken wir die ursprüngliche Liste mit der Funktion print() und der Funktion str() aus, um die Liste für Druckzwecke in einen String umzuwandeln.
- Wir verwenden ein Listenverständnis mit der Funktion sorted(), um jede Unterliste innerhalb der test_list basierend auf den Elementen in jeder Unterliste zu sortieren.
- Die resultierende sortierte Liste von Listen weisen wir der Variablen res zu.
- Schließlich drucken wir die resultierende sortierte Liste res aus, indem wir die Funktion print() und die Funktion str() verwenden, um die Liste für Druckzwecke in einen String umzuwandeln.
Python3
# Python3 code to demonstrate> # Sorting list of lists with similar list elements> # using list comprehension + sorted()> # initializing list> test_list>=> [[[>4>,>4>], [>1>,>1>]], [[>3>,>3>], [>2>,>2>], [>5>,>5>]]]> # printing original list> print>(>'The original list : '> +> str>(test_list))> # using list comprehension + sorted()> # Sorting list of lists with similar list elements> res>=> [>sorted>(idx)>for> idx>in> test_list]> # print result> print>(>'The list after performing sort operation : '> +> str>(res))> |
>
>Ausgabe :
Die ursprüngliche Liste: [[[4, 4], [1, 1]], [[3, 3], [2, 2], [5, 5]]] Die Liste nach der Sortieroperation: [[[1 , 1], [4, 4]], [[2, 2], [3, 3], [5, 5]]]
Zeitkomplexität: O(nlogn)
Hilfsraum: O(1)
Methode Nr. 2: Verwenden von map() + sorted()
Die Kombination der oben genannten Funktionen führt ebenfalls eine ähnliche Aufgabe aus wie die obige Methode, mit dem Unterschied, dass die Kartenfunktion verwendet wird, um die Sortierlogik auf die gesamten Unterlisten zu erweitern.
Python3
Rakhi Sawant
# Python3 code to demonstrate> # Sorting list of lists with similar list elements> # using map() + sorted()> # initializing list> test_list>=> [[[>4>,>4>], [>1>,>1>]], [[>3>,>3>], [>2>,>2>], [>5>,>5>]]]> # printing original list> print>(>'The original list : '> +> str>(test_list))> # using map() + sorted()> # Sorting list of lists with similar list elements> res>=> list>(>map>(>sorted>, test_list))> # print result> print>(>'The list after performing sort operation : '> +> str>(res))> |
>
>Ausgabe :
Die ursprüngliche Liste: [[[4, 4], [1, 1]], [[3, 3], [2, 2], [5, 5]]] Die Liste nach der Sortieroperation: [[[1 , 1], [4, 4]], [[2, 2], [3, 3], [5, 5]]]
Zeitkomplexität: O(n*nlogn), wobei n die Anzahl der Elemente in der Liste test_list ist.
Hilfsraum: O(n), wobei n die Anzahl der Elemente in der Liste test_list ist.
Methode 3: Verwendung der Lambda-Funktion mit der Methode sort().
Ansatz:
- Initialisieren Sie die Liste test_list mit Beispieldaten.
- Drucken Sie die Originalliste mit der Funktion print().
- Verwenden Sie die Methode sort(), um die Liste der Listen zu sortieren. Der Schlüsselparameter ist auf eine Lambda-Funktion festgelegt, die jedes Listenelement sortiert.
- Drucken Sie die sortierte Liste mit der Funktion print().
Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:
Python3
# Python3 code to demonstrate> # Sorting list of lists with similar list elements> # using lambda function and sort()> # initializing list> test_list>=> [[[>4>,>4>], [>1>,>1>]], [[>3>,>3>], [>2>,>2>], [>5>,>5>]]]> # printing original list> print>(>'The original list : '> +> str>(test_list))> # using lambda function and sort()> # Sorting list of lists with similar list elements> test_list.sort(key>=>lambda> x:>sorted>(x))> # print result> print>(>'The list after performing sort operation : '> +> str>(test_list))> |
>
>Ausgabe
The original list : [[[4, 4], [1, 1]], [[3, 3], [2, 2], [5, 5]]] The list after performing sort operation : [[[4, 4], [1, 1]], [[3, 3], [2, 2], [5, 5]]]>
Zeitkomplexität: O(n log n), wobei n die Anzahl der Elemente in der Liste ist.
Nebenraum: O(1), da es außer der Eingabeliste keinen zusätzlichen Platz beansprucht.
Methode Nr. 4: Verwendung von functools.cmp_to_key()
- Importieren Sie das Functools-Modul.
- Definieren Sie eine Vergleichsfunktion, die zwei Unterlisten als Argumente verwendet und abhängig von ihrer relativen Reihenfolge -1, 0 oder 1 zurückgibt.
- Verwenden Sie die Funktion sorted() und die Funktion cmp_to_key() von functools, um die Originalliste mithilfe der Vergleichsfunktion zu sortieren.
Python3
Java for-Schleife
# Python3 code to demonstrate> # Sorting list of lists with similar list elements> # using functools.cmp_to_key()> # import functools module> import> functools> # initializing list> test_list>=> [[[>4>,>4>], [>1>,>1>]], [[>3>,>3>], [>2>,>2>], [>5>,>5>]]]> # printing original list> print>(>'The original list : '> +> str>(test_list))> # define comparison function> def> compare_lists(list1, list2):> >if> sorted>(list1) <>sorted>(list2):> >return> ->1> >elif> sorted>(list1)>>sorted>(list2):> >return> 1> >else>:> >return> 0> # using functools.cmp_to_key() and sorted()> # Sorting list of lists with similar list elements> test_list.sort(key>=>functools.cmp_to_key(compare_lists))> # print result> print>(>'The list after performing sort operation : '> +> str>(test_list))> |
>
>Ausgabe
The original list : [[[4, 4], [1, 1]], [[3, 3], [2, 2], [5, 5]]] The list after performing sort operation : [[[4, 4], [1, 1]], [[3, 3], [2, 2], [5, 5]]]>
Zeitkomplexität: O(N * M * log(M)), Dabei ist N die Anzahl der Unterlisten und M die Länge der längsten Unterliste.
Hilfsraum: O(M) , wobei M die Länge der längsten Unterliste für den Sortiervorgang ist.