将一个全是数字的数组按照数字大小从大到小或者从小到大重新排列，这类问题并不少见，在此，列举了一种数组排序的方法。

先var一个数组并写出排序的函数

 

var Arr = [10,2,0.6,51,133,125,1,0.05,555,0];

Array.prototype.paiXu = function(){
        var temp;
        for(var i=0; i<Arr.length;i++) {
            for(var j=i+1;j<Arr.length;j++) {
                if(Arr[i]<Arr[j]) {  //升序 >、降序 <
                    temp=Arr[i];
                    Arr[i]=Arr[j];
                    Arr[j]=temp;
                }
            }
        }
        return Arr
    };

原理：（降序为例）设置一个temp变量用于存储对比数，那么temp第一次循环的值等于Arr[0]，即temp = 10；

然后依次和数组其他元素做对比，循环过程中，当temp当前值小于某一值（假设X），则重新给temp赋值X；

依次循环下去，不停地给temp赋予新值，同时也在重组数组，最终得到的数组就是一个降序的数组。

调用：

Arr.paiXu()

可打印出来检测，结果亲测可用。

还有一种js自带的排序功能

var numArr = [3,6,2,4,1,5];
	console.log(numArr.sort());
	console.log(numArr.sort().reverse());
// 这种方式只适合个位数，一旦是多位数，就会达不到想要的效果，例如：


var arr1 = [1,12,11,2,21];
console.log(arr1 .sort());
// 结果是[1,11,12,2,21]

输出结果：[1, 2, 3, 4, 5, 6] 和 [6, 5, 4, 3, 2, 1]

 

Php 数组排序之多维数组排序
php 中最强大的类型非数组莫属！任何类型的数据都可以用数组来存储。
项目开发中对数组排序已是家常便饭，本文主要是总结一些经验和方法以及它们的区别，供大家学习参考。
一维数组排序 
sort 函数:
      本函数对数组值转换为整型并被从最低到最高重新安排，删除原有的键名。成功时返回 TRUE， 或者在失败时返回 FALSE.

rsort 函数:

      本函数对数组值转换为整型并被从最高到最低重新安排，删除原有的键名。成功时返回 TRUE， 或者在失败时返回 FALSE.
asort 函数:
      本函数对数组进行低到高排序，数组的索引保持和单元的关联。主要用于对那些单元顺序很重要的结合数组进行排序。
arsort 函数:

     对数组进行逆向排序(高到低)并保持索引关系

    本函数对数组进行排序，数组的索引保持和单元的关联。主要用于对那些单元顺序很重要的结合数组进行排序。
    成功时返回 TRUE， 或者在失败时返回 FALSE. 


多维数组排序
usort函数: bool 
usort ( array&$array ,callback$cmp_function
 )

    本函数将用用户自定义的比较函数对一个数组中的值进行排序。如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。
     比较函数必须在第一个参数被认为小于，等于或大于第二个参数时分别返回一个小于，等于或大于零的整数
    此函数为 array 中的元素赋与新的键名。这将删除原有的键名，而不是仅仅将键名重新排序。
    成功时返回 TRUE， 或者在失败时返回 FALSE.

uasort 函数:bool uasort (array&$array ,callback$cmp_function
 )
      uasort — 
使用用户自定义的比较函数对数组中的值进行排序并保持索引关联 

     本函数对数组排序并保持索引和单元之间的关联。主要用于对那些单元顺序很重要的结合数组进行排序。
     比较函数是用户自定义的。 
    成功时返回 TRUE， 或者在失败时返回 FALSE. 
uksort 函数:bool uksort (array&$array ,callback$cmp_function
 )
     本函数将使用用户提供的比较函数对数组中的键名进行排序。如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。
   cmp_function 函数应接受两个参数，该参数将被array 中的一对键名填充。
      比较函数在第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。 
      成功时返回 TRUE， 或者在失败时返回 FALSE(本排序方法和 uasort 非常类似). 
array_multisort函数: bool array_multisort (array$ar1 [,mixed$arg
 [,mixed$... [,array$...
 ]]] )
       可以用来一次对多个数组进行排序，或者根据某一维或多维对多维数组进行排序。
      关联（string）键名保持不变，但数字键名会被重新索引。
      本函数的参数结构有些不同寻常，但是非常灵活。
      第一个参数必须是一个数组。接下来的每个参数可以是数组或者是下面列出的排序标志。
      排序顺序标志： 
      ◾SORT_ASC - 按照上升顺序排序 
      ◾SORT_DESC - 按照下降顺序排序 
     排序类型标志： 
     ◾SORT_REGULAR - 将项目按照通常方法比较 
     ◾SORT_NUMERIC - 将项目按照数值比较 
     ◾SORT_STRING - 将项目按照字符串比较 每个数组之后不能指定两个同类的排序标志。
     每个数组后指定的排序标志仅对该数组有效 - 在此之前为默认值 SORT_ASC 和 SORT_REGULAR。


uasort 排序学习案例：
/* 多维数组排序 */
$arr_more = array(
         array(1,'age'=> 12,'name' => 'wzq'),
         array(2,'age'=> 42,'name' => 'eee'),
         array(9,'age'=> 82,'name' => '22'),
         array(4,'age'=> 162,'name' => 'ff'),
         array(6,'age'=> 2,'name' => 'jj'),
         array(17,'age'=> 52,'name' => 'nn')
);
uasort($arr_more,function($x,$y){
     //age从大到小 
     return $x['age'] < $y['age'];
});
var_dump($arr_more);


以上本文就是这些，知识点摘自 php学习手册。抛砖引玉，希望对大家有所帮助！

我们现在已知有这样一个数组：
let array = [51,4,95,32,-64,8,125];

接下来我们要对其进行排序，求最大值和最小值：

首先先来数组排序的方法：
1.数组的sort排序方法：

注意点：

数组的sort方法会改变原有数组

array.sort((a, b) => a - b;)	//升序
array.sort((a, b) => b - a;)	//降序

2.冒泡排序方法：

计算的逻辑：

比较相邻的元素。如果第一个比第二个大，就交换他们俩个位置。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

for(let i = 0; i < array.length - 1; i++){//控制比较轮数
   for(let j = 0; j < array.length-i-1; j++){//控制每轮比较的次数
        if(array[j] > array[j+1]){
            var tmp = array[j];
            array[j] = array[j+1];
            array[j+1]=tmp;
        }
    }
}

3.快速排序的方法：

计算的逻辑：

递归思想，俩边快速的排序，冒泡排序的改进

function quickSort(arr) {
 //如果数组长度小于等于1，则返回数组本身
    if(arr.length <= 1){
        return arr;
    }
    //定义中间值的索引
    let index = Math.floor(arr.length/2);
    //取到中间值
    let temp = arr.splice(index,1);
    //定义左右部分数组
    let left = [];
    let right = [];
    for(let i = 0; i < arr.length; i++){
        //如果元素比中间值小，那么放在左边，否则放在右边
        if(arr[i] < temp) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat(temp,quickSort(right));
}
array = quickSort(array);

3.插入排序

注意点：

此定义方法会改变原有数组

计算的逻辑：
从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到下一位置中
重复步骤2

function insertSort(arr) {
   //假设第0元素是有序序列，第1元素之后是无序的序列。从第1元素开始依次将无序的序列元素插入到有序的序列中
    for(let i = 1; i < arr.length; i++) {
        if(arr[i] < arr[i - 1]) {
            //取出无序序列中需要插入的第i个元素
            let temp = arr[i];
            //定义有序中的最后一个位置
            let j = i - 1;
            arr[i] = arr[j];
            //比较大小，找到插入的位置
            while(j >= 0 && temp < arr[j]) {
                arr[j + 1] = arr[j];
                j--;
            };
            //插入
            arr[j + 1] = temp;
        }
    }
}
insertSort(array);

4.选择排序

注意点：

此自定义方法会改变原有数组

计算的逻辑：
在未排序序列中找到最小（大）元素
并存放到排序序列的起始位置
然后，再把剩余未排序元素中继续寻找最小（大）元素
然后放到已排序序列的末尾
依此类推

function selectSort(arr) {
   for(let i = 0; i < arr.length; i++) {
        //设置当前范围最小值和索引
        let min = arr[i];
        let minIndex = i;
        //在该范围选出最小值
        for(let j = i + 1; j < arr.length; j++) {
            if(min > arr[j]) {
                min = arr[j];
                minIndex = j;
            }
        }
        //将最小值插入，并将原来位置的最小值删除
        arr.splice(i, 0, min);
        arr.splice(minIndex + 1, 1);
    }
}
selectSort(array);

接下来讲求数组最大值和最小值的方法：
1.排序法：

根据上面排序好的数组去查找就可以了

按升序排序好的数组[0] 就是当前数组的最小值

按升序排序好的数组[length - 1] 就是当前数组的最大值
2.假设法：

假设当前数组的第一个值是最大值或者最小值，然后拿这个值去和后面的逐一比较，如果假设不成立，那么就拿当前遍历到的值去替换当前值。
let max = array[0];	//求最大值
let min = array[0];	//求最小值
for (let i = 1; i < array.length; i++) {
	if (array[i] > max) {	//求最大值的假设
		max = array[i];
	}
	if (array[i] < min) {	//求最小值的假设
		min = array[i];
	}
}

3.Math的max和min方法
let max = Math.max.apply(null, array);
let min = Math.min.apply(null, array);

4.ES6中的拓展运算符
let max = Math.max(...array);
let min = Math.min(...array);

有时需要根据json对象的某个属性排序json数组，javascript端有sort这个函数，具体可以参考：http://www.w3school.com.cn/jsref/jsref_sort.asp
我们可以传入一个对比函数，我实现了两个：一个降序排列，一个升序排列
/**
 * json对象数组按照某个属性排序:降序排列
 * @param {Object} propertyName
 */
function compareDesc(propertyName) {
    return function(object1, object2) {
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];
        if(value2 < value1) {
            return -1;
        } else if(value2 > value1) {
            return 1;
        } else {
            return 0;
        }
    }
}

/**
 * json对象数组按照某个属性排序:升序排列
 * @param {Object} propertyName
 */
function compareAsc(propertyName) {
    return function(object1, object2) {
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];
        if(value2 < value1) {
            return 1;
        } else if(value2 > value1) {
            return -1;
        } else {
            return 0;
        }
    }
}


例子：
var students=[{name:"hhhh",age:16},{name:"ggggg",age:17},{name:"dsdsad",age:18}];
students.sort(conpareDesc("age"));   //按照年龄降序排列
students.sort(conpareAsc("age"));   //按照年龄升序排列