## Sorting and Merging

Sorting and Merging

The functions `SORT` and `STABLE-SORT` provide two ways of sorting a sequence. They both take a sequence and a two-argument predicate and return a sorted version of the sequence.

`(sort (vector "foo" "bar" "baz") #'string<) ==> #("bar" "baz" "foo")`

The difference is that `STABLE-SORT` is guaranteed to not reorder any elements considered equivalent by the predicate while `SORT` guarantees only that the result is sorted and may reorder equivalent elements.

Both these functions are examples of what are called destructive functions. Destructive functions are allowed—typically for reasons of efficiency—to modify their arguments in more or less arbitrary ways. This has two implications: one, you should always do something with the return value of these functions (such as assign it to a variable or pass it to another function), and, two, unless you're done with the object you're passing to the destructive function, you should pass a copy instead. I'll say more about destructive functions in the next chapter.

Typically you won't care about the unsorted version of a sequence after you've sorted it, so it makes sense to allow `SORT` and `STABLE-SORT` to destroy the sequence in the course of sorting it. But it does mean you need to remember to write the following:[128]

`(setf my-sequence (sort my-sequence #'string<))`

rather than just this:

`(sort my-sequence #'string<)`

Both these functions also take a keyword argument, `:key`, which, like the `:key` argument in other sequence functions, should be a function and will be used to extract the values to be passed to the sorting predicate in the place of the actual elements. The extracted keys are used only to determine the ordering of elements; the sequence returned will contain the actual elements of the argument sequence.

The `MERGE` function takes two sequences and a predicate and returns a sequence produced by merging the two sequences, according to the predicate. It's related to the two sorting functions in that if each sequence is already sorted by the same predicate, then the sequence returned by `MERGE` will also be sorted. Like the sorting functions, `MERGE` takes a `:key` argument. Like `CONCATENATE`, and for the same reason, the first argument to `MERGE` must be a type descriptor specifying the type of sequence to produce.

```(merge 'vector #(1 3 5) #(2 4 6) #'<) ==> #(1 2 3 4 5 6) (merge 'list #(1 3 5) #(2 4 6) #'<) ==> (1 2 3 4 5 6)```

Оглавление книги

Генерация: 1.116. Запросов К БД/Cache: 3 / 1
поделиться
Вверх Вниз