将混合的 String-Int 字符串按数字排序作为主要顺序，然后按字母顺序快速排序

Question

对于同时具有 String 和 Int 值（每个值之一）的字符串，是否可以进行简单排序，将按数字顺序排序的项目作为主要顺序，按字母顺序作为次要顺序

var nameArray = ["Dave7", "Bob8", "Cathy9", "Henry10", "Susan10", "Pat11", "Steve12", "Dan12", "Ken1", "Sean2", "Howard3", "Dixie3", "Newman5", "Billy6"]

var sortedNameArray = nameArray.sort { $0.compare($1, options: .NumericSearch) == .OrderedAscending }

print(sortedNameArray)  // gives the following:

不想要这个 -> ["Billy6", "Bob8", "Cathy9", "Dan12", "Dave7", "Dixie3", "Henry10", "Howard3", "Ken1", "Newman5", "Pat11", "Sean2", "Steve12", "Susan10"]

即使使用了.NumericSearch，结果也是按字母顺序排列的。

我能够使用自定义二叉树获得所需的结果。这给出了结果：

Ken1 Sean2 Dixie3 Howard3 Newman5 Billy6 Dave7 Bob8 Cathy9 Henry10 Susan10 Pat11 Dan12 Steve12

但是有更简单的解决方案吗？

extension String {

    var integerValue: Int? {
        return Int(self)
    }
}

func extractValueFromString(theString:String)->Int{

    var catNumber: [Character] = []

     //print("theString \(theString)")

    for character in theString.characters{

        var characterString = String(character)

        if var value = characterString.integerValue { //if we don't check program crashes


            //if numberSet.contains(Int(String(character))!) { //another way to check but redundant here

                catNumber.append(character)
               //print(catNumber)
           // }
        }
    }

    let numberString = String(catNumber)

    return Int(numberString)!
}




class Node{

    //nodes now only arrange strings
    var data = ""
    var value = Int()
    var left:Node?;
    var right:Node?;
    deinit {
        //print("deleting \(data)")
       // print("node  deleted")
    }


    init(data:String){
        self.data = data;

        //print(data)
    }

}


class binaryTreeSort{

    var root:Node?

    init(){

    }

    deinit {

        //print("tree  deleted")
    }

    func getRoot()->Node{

        return root!

    }



    func insertNewValue(data:String){

        let newNode = Node(data:data)

        var node:Node? = root

        if (node == nil){
            root = newNode

        }


        while (node != nil) {

            let currentValue = node?.data


            if currentValue == ""{

                node?.data = data
                return
            }

            if currentValue == data {
                //we don't want duplicates.
                return
            }
            if extractValueFromString(currentValue!) <  extractValueFromString(data) {

                if (node!.right != nil) {
                    node = node!.right
                    //print("Going Right at data \(node!.data)")

                }else{
                    node!.right = newNode
                    //print("Going New Right at data \(node!.data)")
                    return
                }
            }else if extractValueFromString(currentValue!) ==  extractValueFromString(data){

                if  currentValue < data {

                    if (node!.right != nil) {
                        node = node!.right
                        //print("Going Right at data \(node!.data)")

                    }else{
                        node!.right = newNode
                        //print("Going New Right at data \(node!.data)")
                        return
                    }



                }else{


                    if (node!.left != nil) {
                        //print("Going Left at data \(node!.data)")
                        node = node!.left
                    }else{
                        node!.left = newNode
                        //print("Going New Left at data \(node!.data)")
                        return
                    }


                }

            }
            else{
                if (node!.left != nil) {
                    //print("Going Left at data \(node!.data)")
                    node = node!.left
                }else{
                    node!.left = newNode
                    //print("Going New Left at data \(node!.data)")
                    return
                }
            }
        }


    }

    func inorderPrint(baseNode:Node){

        if(baseNode.left != nil)
        {
            inorderPrint(baseNode.left!);
            //print("  \(baseNode.data)")
        }




      print("\(baseNode.data)")


        if(baseNode.right != nil)
        {

            inorderPrint(baseNode.right!)
            //print("    \(baseNode.data)")
        }



    }




    func reverseOrderPrint(baseNode:Node){


        if(baseNode.right != nil)
        {

            reverseOrderPrint(baseNode.right!)
            //print("    \(baseNode.data)")
        }



              print("\(baseNode.data)")



        if(baseNode.left != nil)
        {
            reverseOrderPrint(baseNode.left!);
            //print("  \(baseNode.data)")
        }


    }

}

    var myBinaryTreeSort:binaryTreeSort? = binaryTreeSort()

for item in nameArray{
    //print(item)

    myBinaryTreeSort!.insertNewValue(item)
}

myBinaryTreeSort!.inorderPrint(myBinaryTreeSort!.getRoot())
print("---------------")

myBinaryTreeSort!.reverseOrderPrint(myBinaryTreeSort!.getRoot())

myBinaryTreeSort = nil //delete the tree

Answer 1

使用map将名字拆分成部分，sort按数字和名字排序，然后map还原成原来的样子：

func splitName(name:String) -> (String, Int) {
    if let range = name.rangeOfCharacterFromSet(NSCharacterSet.decimalDigitCharacterSet()) {
     return (name[name.startIndex..<range.startIndex], Int(name[range.startIndex..<name.endIndex])!)
   } else {
        return (name, 0)
    }
}

print(nameArray.map(splitName).sort({ lhs, rhs in
    if lhs.1 < rhs.1 {
        return true
    } else if lhs.1 > rhs.1 {
        return false
    } else {
        return lhs.0 < rhs.0
    }
}).map({ "\($0.0)\($0.1)" }))

可以做到的其他一些方法是将元组的元素 0 保持为全名（带数字），然后最终映射变为 map({ $0.0 }) 根据大小，这可能比拆分名称更优化每次比较。

Answer 2

如果你有一个数组，你可以使用自定义闭包进行排序。

例如：

  nameArray.sort({extractValueFromString($0) < extractValueFromString($1)})

会让你靠近。您只需要检查它们是否相等并返回$0 < $1。

Answer 3

这是我解决这个问题的方法，类似于@Lou-Franco 所暗示的：

func endInteger(word: String) -> Int {
    if let range = word.rangeOfCharacterFromSet(NSCharacterSet.decimalDigitCharacterSet()){
        let numberSubstring = word.substringFromIndex(range.startIndex)
        return Int(numberSubstring) ?? 0
    }
    return 0
}

let sortedArray = yourArray.sort{endInteger($1) > endInteger($0)}