关于通过从另一个数组排序对Swift数组进行排序和swift数组排序的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于arrays–通过从另一个数组中排序来对Swift数组进行排序、ios–
关于通过从另一个数组排序对Swift数组进行排序和swift 数组排序的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于arrays – 通过从另一个数组中排序来对Swift数组进行排序、ios – 如何在Swift / Xcode中对1个数组进行排序,并通过相同的键更改重新排序多个其他数组、java – 按字典顺序对int数组进行排序、Javascript - 基于另一个数组对数组进行排序等相关知识的信息别忘了在本站进行查找喔。
本文目录一览：- 通过从另一个数组排序对Swift数组进行排序（swift 数组排序）
- arrays – 通过从另一个数组中排序来对Swift数组进行排序
- ios – 如何在Swift / Xcode中对1个数组进行排序,并通过相同的键更改重新排序多个其他数组
- java – 按字典顺序对int数组进行排序
- Javascript - 基于另一个数组对数组进行排序
通过从另一个数组排序对Swift数组进行排序（swift 数组排序）
假设我有一个自定义类的数组[Player]，每个类都包含一个名为player.position
我还有一个任意值数组，称为positionOrders，如下所示：
let positionOrders = ["QB", "WR", "RB", "TE"]
我的目标是对[Player]所有QB 进行排序，然后再对所有WR，RB和TE 进行排序。
我当前的操作方式是遍历中的每个元素positionOrders，然后遍历所有播放器以附加到新数组。但是，我想不出一种更简单（更有效）的方法来做到这一点。非常感谢任何提示或指示。谢谢。
答案1
小编典典编辑： 我原来的方法是狗屎。这篇文章吸引了很多人的注意力，所以现在是应该给予更多关注和改进的时候了。
从根本上讲，问题很容易。我们有两个元素，还有一个数组（或任何orderedCollection），它们的相对顺序决定了它们的排序顺序。对于每个元素，我们在有序集合中找到其位置，然后比较两个索引以确定哪个“更大”。
但是，如果我们天真地进行线性搜索（例如Array.firstIndex(of:)），我们将获得非常糟糕的性能（O(array.count)），尤其是在固定排序非常大的情况下。为了解决这个问题，我们可以构造一个Dictionary，将元素映射到它们的索引。该词典提供快速O(1)查找，非常适合这项工作。
正是HardCodedOrdering这样。它根据元素的顺序预先计算出一个字典，并提供一个比较2个元素的接口。更好的是，可以将其配置为以未知顺序对遇到的元素做出不同的响应。它可以将它们放在其他所有事物之前，之后，或者完全崩溃（默认行为）之前。
HardCodedOrdering
public struct HardCodedOrdering<Element> where Element: Hashable { public enum UnspecifiedItemSortingPolicy { case first case last case assertAllItemsHaveDefinedSorting } private let ordering: [Element: Int] private let sortingPolicy: UnspecifiedItemSortingPolicy public init( ordering: Element..., sortUnspecifiedItems sortingPolicy: UnspecifiedItemSortingPolicy = .assertAllItemsHaveDefinedSorting ) { self.init(ordering: ordering, sortUnspecifiedItems: sortingPolicy) } public init<S: Sequence>( ordering: S, sortUnspecifiedItems sortingPolicy: UnspecifiedItemSortingPolicy = .assertAllItemsHaveDefinedSorting ) where S.Element == Element { self.ordering = Dictionary(uniqueKeysWithValues: zip(ordering, 1...)) self.sortingPolicy = sortingPolicy } private func sortKey(for element: Element) -> Int { if let definedSortKey = self.ordering[element] { return definedSortKey } switch sortingPolicy { case .first: return Int.min case .last: return Int.max case .assertAllItemsHaveDefinedSorting: fatalError("Found an element that does not have a defined ordering: \(element)") } } public func contains(_ element: Element) -> Bool { return self.ordering.keys.contains(element) } // For use in sorting a collection of `T`s by the value''s yielded by `keyDeriver`. // A throwing varient could be introduced, if necessary. public func areInIncreasingOrder<T>(by keyDeriver: @escaping (T) -> Element) -> (T, T) -> Bool { return { lhs, rhs in self.sortKey(for: keyDeriver(lhs)) < self.sortKey(for: keyDeriver(rhs)) } } // For use in sorting a collection of `Element`s public func areInIncreasingOrder(_ lhs: Element, rhs: Element) -> Bool { return sortKey(for: lhs) < sortKey(for: rhs) }}用法示例：
let rankOrdering = HardCodedOrdering(ordering: "Private", "Lieutenant", "Captain", "Admiral") // ideally, construct this once, cache it and share itlet someRanks = [ "Admiral", // Should be last (greatest) "Gallactic Overlord", // fake, should be removed "Private", // Should be first (least)]let realRanks = someRanks.lazy.filter(rankOrdering.contains)let sortedRealRanks = realRanks.sorted(by: rankOrdering.areInIncreasingOrder) // works with mutating varient, `sort(by:)`, too.print(sortedRealRanks) // => ["Private", "Admiral"]
arrays – 通过从另一个数组中排序来对Swift数组进行排序
我也有一个任意的值数组,称为positionorders,如下所示：
let positionorders = [“QB”,“WR”,“RB”,“TE”]
我的目标是将[Player]排序为首先拥有所有“QB”,然后是“WR”,最后是“TE”.
我正在做的当前方式循环遍历positionorders中的每个元素,然后在内部循环遍历所有玩家以附加到新数组.但是,我无法想出一种更简单(更有效)的方法.非常感谢任何提示或指示.谢谢.
let sorted = players.sorted{ positionorders.index(of: $0.position)! < positionorders.index(of: $1.position)! }
这是一个更复杂的解决方案,对于更大尺寸的positionorders来说会更快
let ordering = Dictionary(uniqueKeysWithValues: x.enumerated().map { ($1,$0) })
let sorted = players.sorted{ ordering[$0.position]! < ordering[$1.position]! }
这两种解决方案都假设所有可能的玩家位置都根据positionorders有一个定义的顺序,因此他们使用！为了简洁.如果不是这样,请告诉我.
ios – 如何在Swift / Xcode中对1个数组进行排序,并通过相同的键更改重新排序多个其他数组
bool array_multisort ( array &$array1 [,mixed $array1_sort_order = SORT_ASC [,mixed $array1_sort_flags = SORT_REGULAR [,mixed $... ]]] )
它允许您对1个数组进行排序,并根据原始数据中的键更改对其他多个数组进行重新排序.
在Swift / Xcode 7.2中是否有等效的命令？
我目前有一组数组：
名字
年龄
市
国家
活性
Active是用户在我的应用程序中处于活动状态的一系列时间(以秒为单位).我想命令降序或升序,其他数组改变以保持一致.
解决方法
var names = [ "Paul","John","David" ]
var ages = [ 35,42,27 ]
let newOrder = names.enumerate().sort({$0.1<$1.1}).map({$0.0})
names = newOrder.map({names[$0]})
ages = newOrder.map({ages[$0]})
[编辑]以下是对该技术的改进：
这是相同的方法,但只需一步完成排序和分配.
(可以重新分配给原始数组或单独的数组)
(firstNames,ages,cities,countries,actives) =
{(
$0.map{firstNames[$0]},$0.map{ages[$0]},$0.map{cities[$0]},$0.map{countries[$0]},$0.map{actives[$0]}
)}
(firstNames.enumerated().sorted{$0.1<$1.1}.map{$0.0})
[EDIT2]和一个数组扩展,以便在您进行排序时更容易使用：
extension Array where Element:Comparable
{
func ordering(by order:(Element,Element)->Bool) -> [Int]
{ return self.enumerated().sorted{order($0.1,$1.1)}.map{$0.0} }
}
extension Array
{
func reorder<T>(_ otherArray:inout [T]) -> [Element]
{
otherArray = self.map{otherArray[$0 as! Int]}
return self
}
}
firstNames.ordering(by: <)
.reorder(&firstNames)
.reorder(&ages)
.reorder(&cities)
.reorder(&countries)
.reorder(&actives)
结合前两个：
extension Array
{
func reordered<T>(_ otherArray:[T]) -> [T]
{
return self.map{otherArray[$0 as! Int]}
}
}
(firstNames,actives) =
{(
$0.reordered(firstNames),$0.reordered(ages),$0.reordered(cities),$0.reordered(countries),$0.reordered(actives)
)}
(firstNames.ordering(by:<))
java – 按字典顺序对int数组进行排序
WAP to sort prime numbers smaller than given N by digits. If N is 40,
the output should be 11,13,17,19,2,23,29,3,31,37,39,5,7.
Note: Limit memory use.
获得主要号码很容易.但我无法找出一种有效的整数数组排序方法.
public static void getPrimeNumbers(int limit) {
for (int i=2; i<=limit; i++) {
if(isPrime(i)) {
System.out.println(i);
}
}
}
public static boolean isPrime(int number) {
for(int j=2; j<number; j++) {
if(number%j==0) {
return false;
}
}
return true;
}
public static void lexographicSorting() {
int[] input = {2,7,11,19};
int[] output = {};
for (int i=0; i<input.length; i++) {
for(int j=0; j<input.length; j++) {
////Stuck at this part.
}
}
}
解决方法
这是一个可能更快的解决方案,并且根本不分配堆内存(尽管它具有递归,因此它可能具有一些堆栈效果 – 与Arrays.sort()大致相同).这解决了第一原理的问题,它没有为结果分配单独的数组,因此,与其他解决方案相比,它相对较长,但是,那些其他解决方案隐藏了该解决方案所没有的大量复杂性. .
// this compare works by converting both values to be in the same 'power of 10',// for example,comparing 5 and 20,it will convert 5 to 50,then compare 50 and 20
// numerically.
public static final int compareLexographicallyToLimit(final int limit,int a,int b) {
if (a == b) {
return 0;
}
if (a > limit || b > limit || a < 0 || b < 0) {
return a > b ? 1 : -1;
}
int max = Math.max(a,b);
int nextp10 = 1;
while (max > 10) {
max /= 10;
nextp10 *= 10;
}
while (a < nextp10) {
a *= 10;
}
while (b < nextp10) {
b *= 10;
}
return a > b ? 1 : -1;
}
private static void sortByRules(final int[] input,final int limit,final int from,final int to) {
if (from >= to) {
return;
}
int pivot = from;
int left = from + 1;
int right = to;
while (left <= right) {
while (left <= right && compareLexographicallyToLimit(limit,input[left],input[pivot]) <= 0) {
left++;
}
while (left <= right && compareLexographicallyToLimit(limit,input[pivot],input[right]) <= 0) {
right--;
}
if (left < right) {
int tmp = input[left];
input[left] = input[right];
input[right] = tmp;
left++;
right--;
}
}
int tmp = input[pivot];
input[pivot] = input[right];
input[right] = tmp;
sortByRules(input,limit,from,right-1);
sortByRules(input,right+1,to);
}
public static void main(String[] args) {
int[] input = {2,41,43,100};
sortByRules(input,40,input.length - 1);
System.out.println(Arrays.toString(input));
sortByRules(input,15,input.length - 1);
System.out.println(Arrays.toString(input));
}
Javascript - 基于另一个数组对数组进行排序
是否可以对如下所示的数组进行排序和重新排列：
itemsArray = [ [''Anne'', ''a''], [''Bob'', ''b''], [''Henry'', ''b''], [''Andrew'', ''d''], [''Jason'', ''c''], [''Thomas'', ''b'']]匹配这个数组的排列：
sortingArr = [ ''b'', ''c'', ''b'', ''b'', ''a'', ''d'' ]不幸的是，我没有任何 ID 可以跟踪。我需要优先考虑 items-array 以匹配 sortArr 尽可能接近。
更新：
这是我正在寻找的输出：
itemsArray = [ [''Bob'', ''b''], [''Jason'', ''c''], [''Henry'', ''b''], [''Thomas'', ''b''] [''Anne'', ''a''], [''Andrew'', ''d''],]知道如何做到这一点吗？
答案1
小编典典单行答案。
itemsArray.sort(function(a, b){ return sortingArr.indexOf(a) - sortingArr.indexOf(b);});甚至更短：
itemsArray.sort((a, b) => sortingArr.indexOf(a) - sortingArr.indexOf(b));今天关于通过从另一个数组排序对Swift数组进行排序和swift 数组排序的讲解已经结束，谢谢您的阅读，如果想了解更多关于arrays – 通过从另一个数组中排序来对Swift数组进行排序、ios – 如何在Swift / Xcode中对1个数组进行排序,并通过相同的键更改重新排序多个其他数组、java – 按字典顺序对int数组进行排序、Javascript - 基于另一个数组对数组进行排序的相关知识，请在本站搜索。
本文标签：
