sort的源码

❶ Sort code 是什么

sort code 意思是 (银行)识别代码

读法 英 [ˈsɔːt kəʊd] 美 [ˈsɔːrt koʊd]

双语例句：

1、For example, use a sort code and bank account number to access a customer?

例如，使用排序代码和银行账户号码访问客户的简介。

2、If the profile is not found, use the sort code to fetch defaults for this customer.

如果没有找到，使用排序代码取得该客户的默认信息。

3、Messages commonly contain information about the value of a transaction, where it originated ( which store or ATM), card account number, and bank sort code.

消息通常包含有关交易金额、交易的发起位置（商店或ATM）、卡帐号和银行代码的信息。

(1)sort的源码扩展阅读：

code 意思为代码

读法 英 [kəʊd] 美 [kod]

n. 代码，密码；编码；法典

vt. 编码；制成法典

vi. 指定遗传密码

n. (Code)人名；(英、法、西)科德

短语：

source code 源代码 ; 启动原始码 ; 原始码 ; 源码

object code 目标代码 ; 目的码 ; 目标码 ; 结果码

Code Lyoko 虚幻勇士 ; 至Net奇兵 ; 虚幻勇士专辑 ; 中文字幕版

bar code [自] 条形码 ; 商品条码 ; [自] 条码 ; 条形吗

Managed Code 托管代码 ; 受控代码 ; 管理代码

country code 国家代码 ; 国家代号 ; 国家码

HS CODE 海关编码 ; 商品编码 ; 海关商品编码 ; 税则号

Code Complete 代码大全 ; 代码完成 ; 程序员必看 ; 代码大全中文版

Code Red 红色代码 ; 红色警戒 ; 代号红色 ; 赤色代码

❷ 请问linux下的系统命令是不是开源的 比如sort，awk等等，如果是的话，在哪可以找到源代码

Linux是开源的，它自带的功能强大的命令也是开源的，也就是说，我们可以获得这些命令的源代码并研究它。那究竟如何获得系统的命令的源代码呢？
命令的源代码是一个软件包为单元的，放在一个软件包的源代码中，若要下载一个命令的源代码，就要把这个命令所属的软件包的源代码都下载下来。命令的源代码就在下载的源代码的相关目录内，通常是src目录，相应的主文件名为cmd.c，其中cmd为具体的命令，如ls命令的主程序文件为ls.c。可查阅“Linux命令大全”了解Linux命令。

❸ C++中sort() 是如何实现的

// 插入排序实现：
void SortInsert::insertSort(vector<int>::iterator begin, vector<int>::iterator end)
{
for (vector<int>::iterator i = begin + 1; i < end; ++i)
{
for(vector<int>::iterator j = i; *j < *(j - 1); --j )
{
std::iter_swap((j - 1), j);
}
}
}

// 冒泡排序实现：
#include <algorithm>

template<typename Iterator>
void bubbleSort(Iterator first, Iterator last)
{
Iterator i, j;
for (i = first; i != last; i++)
for (j = first; j < i; j++)
if (*i < *j)
std::iter_swap(i, j); // or std::swap(*i, *j);
}

template<typename Iterator, class StrictWeakOrdering>
void bubbleSort(Iterator first, Iterator last, StrictWeakOrdering compare)
{
Iterator i, j;
for (i = first; i != last; i++)
for (j = first; j < i; j++)
if (compare(*i, *j))
std::iter_swap(i, j);
}

// 选择
#include <algorithm> // for: std::iter_swap, std::min_element

template <typename Iterator>
void selection_sort(Iterator begin, Iterator end)
{
Iterator min;
while (begin != end)
{
min = std::min_element(begin, end);
std::iter_swap(begin, min);
++begin;
}
}

// 快速
#include <functional>
#include <algorithm>
#include <iterator>

template< typename BidirectionalIterator, typename Compare >
void quick_sort( BidirectionalIterator first, BidirectionalIterator last, Compare cmp ) {
if( first != last ) {
BidirectionalIterator left = first;
BidirectionalIterator right = last;
BidirectionalIterator pivot = left++;

while( left != right ) {
if( cmp( *left, *pivot ) ) {
++left;
} else {
while( (left != right) && cmp( *pivot, *right ) )
--right;
std::iter_swap( left, right );
}
}

--left;
std::iter_swap( pivot, left );

quick_sort( first, left, cmp );
quick_sort( right, last, cmp );
}
}

template< typename BidirectionalIterator >
inline void quick_sort( BidirectionalIterator first, BidirectionalIterator last ) {
quick_sort( first, last,
std::less_equal< typename std::iterator_traits< BidirectionalIterator >::value_type >()
);
}

===========算啦，你还是去这里（下面是链接）看看吧，共同学习哦！！
http://en.wikibooks.org/w/index.php?title=Special%3ASearch&redirs=1&search=sort&fulltext=Search&ns0=1&ns4=1&ns112=1

❹ 跪求C++sort函数源代码怎么写的

你可以直接看源码的。。。。。，API上面什么都有，学语言都要看API的

❺ 为何STL的sort排序效率那么高用的是什么算法

STL的sort在数据量不同的时候，他会自己选用不同的排序算法。比如插入，快排。这些。

下面是说对STL的sort的源码分析的，他有说到这些，你可以参考下
http://www.cnblogs.com/imAkaka/articles/2407877.html

❻ 编写一个sort函数，它用于对任何类型的数组进行排序

如下，为了简便，程序中使用了一些标准库函数，所以需要包含两个头文件，sort()函数利用选择排序算法对数组进行排序，调用时需要传入的参数和标准库函数qsort()一致

#include <stdlib.h>
#include <string.h>

void sort(void *base,unsigned int n,unsigned int width,int (*comp)(void *a,void *b))
{
char *p=(char *)base;
char *te=(char *)malloc(width);
char *ptr;
char *pn=p+width;
const char *cp=p+(n-1)*width;

for (; p<cp; p+=width) {
ptr=p;
for (pn=p+width; pn<=cp; pn+=width)
if ((*comp)(ptr,pn)>0) ptr=pn;
if (ptr!=p) {
memcpy(te,p,width);
memmove(p,ptr,width);
memmove(ptr,te,width);
}
}

free(te);
}

❼ js中sort方法的源码，该怎么解决

unction ArraySort(comparefn) {
// In-place QuickSort algorithm.
// For short (length <= 22) arrays, insertion sort is used for efficiency.

var custom_compare = IS_FUNCTION(comparefn);

function Compare(x,y) {
// Assume the comparefn, if any, is a consistent comparison function.
// If it isn't, we are allowed arbitrary behavior by ECMA 15.4.4.11.
if (x === y) return 0;
if (custom_compare) {
// Don't call directly to avoid exposing the builtin's global object.
return comparefn.call(null, x, y);
}
if (%_IsSmi(x) && %_IsSmi(y)) {
return %SmiLexicographicCompare(x, y);
}
x = ToString(x);
y = ToString(y);
if (x == y) return 0;
else return x < y ? -1 : 1;
};

function InsertionSort(a, from, to) {
for (var i = from + 1; i < to; i++) {
var element = a[i];
// Pre-convert the element to a string for comparison if we know
// it will happen on each compare anyway.
var key =
(custom_compare || %_IsSmi(element)) ? element : ToString(element);
// place element in a[from..i[
// binary search
var min = from;
var max = i;
// The search interval is a[min..max[
while (min < max) {
var mid = min + ((max - min) >> 1);
var order = Compare(a[mid], key);
if (order == 0) {
min = max = mid;
break;
}
if (order < 0) {
min = mid + 1;
} else {
max = mid;
}
}
// place element at position min==max.
for (var j = i; j > min; j--) {
a[j] = a[j - 1];
}
a[min] = element;
}
}

function QuickSort(a, from, to) {
// Insertion sort is faster for short arrays.
if (to - from <= 22) {
InsertionSort(a, from, to);
return;
}
var pivot_index = $floor($random() * (to - from)) + from;
var pivot = a[pivot_index];
// Pre-convert the element to a string for comparison if we know
// it will happen on each compare anyway.
var pivot_key =
(custom_compare || %_IsSmi(pivot)) ? pivot : ToString(pivot);
// Issue 95: Keep the pivot element out of the comparisons to avoid
// infinite recursion if comparefn(pivot, pivot) != 0.
a[pivot_index] = a[from];
a[from] = pivot;
var low_end = from; // Upper bound of the elements lower than pivot.
var high_start = to; // Lower bound of the elements greater than pivot.
// From low_end to i are elements equal to pivot.
// From i to high_start are elements that haven't been compared yet.
for (var i = from + 1; i < high_start; ) {
var element = a[i];
var order = Compare(element, pivot_key);
if (order < 0) {
a[i] = a[low_end];
a[low_end] = element;
i++;
low_end++;
} else if (order > 0) {
high_start--;
a[i] = a[high_start];
a[high_start] = element;
} else { // order == 0
i++;
}
}
QuickSort(a, from, low_end);
QuickSort(a, high_start, to);
}

var old_length = ToUint32(this.length);
if (old_length < 2) return this;

%RemoveArrayHoles(this);

var length = ToUint32(this.length);

// Move undefined elements to the end of the array.
for (var i = 0; i < length; ) {
if (IS_UNDEFINED(this[i])) {
length--;
this[i] = this[length];
this[length] = void 0;
} else {
i++;
}
}

QuickSort(this, 0, length);

// We only changed the length of the this object (in
// RemoveArrayHoles) if it was an array. We are not allowed to set
// the length of the this object if it is not an array because this
// might introce a new length property.
if (IS_ARRAY(this)) {
this.length = old_length;
}

return this;
}

❽ 求C#里sort()函数封装的源代码

同意楼上说法，用reflector就可以，这是其中的一部分代码，建议去看reflector。

1.Sort（） ： Void
public void Sort()
{
this.Sort(0, this.Count, null);
}
2.Sort(IComparer<T>):Void
public void Sort(IComparer<T> comparer)
{
this.Sort(0, this.Count, comparer);
}
1和2的this.Sort：
public void Sort(int index, int count, IComparer<T> comparer)
{
if ((index < 0) || (count < 0))
{
ThrowHelper.((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
}
if ((this._size - index) < count)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
}
Array.Sort<T>(this._items, index, count, comparer);
this._version++;
}

3.Sort(Comparison<T>):Void
public void Sort(Comparison<T> comparison)
{
if (comparison == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
}
if (this._size > 0)
{
IComparer<T> comparer = new Array.FunctorComparer<T>(comparison);
Array.Sort<T>(this._items, 0, this._size, comparer);
}
}
最后一行的Sort：
[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
public static void Sort<T>(T[] array, int index, int length, IComparer<T> comparer)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
if ((index < 0) || (length < 0))
{
throw new ArgumentOutOfRangeException((length < 0) ? "length" : "index", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if ((array.Length - index) < length)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
}
if ((length > 1) && (((comparer != null) && (comparer != Comparer<T>.Default)) || !TrySZSort(array, null, index, (index + length) - 1)))
{
ArraySortHelper<T>.Default.Sort(array, index, length, comparer);
}
}

❾ 如何查看js的sort方法的源码

sort() 方法用于对数组的元素进行排序。 语法： arrayObject.sort(sortby)描述