sort() 方法用于对数组的元素进行排序,并返回数组。默认排序顺序是根据字符串Unicode码点。

如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
若 a 等于 b，则返回 0。

若 a 大于 b，则返回一个大于 0 的值。

		function up(a,b){
			if(a>b){
				return 1;
			}else if(a<b){
				return -1;
			}else{
				return 0;
			}
			// return a-b;
		}
		function drop(a,b){
			if(a>b){
				return -1;
			}else if(a<b){
				return 1;
			}else{
				return 0;
			}
			// return b-a;
		}

数据结构中的基础排序算法包括冒泡，选择和插入排序，它们的核心思想都是对一组数据按照一定的顺序重新排列，排列时用到的主要是一组嵌套的for循环，其中外循环遍历数组的每一项，内循环则用于比较元素。

1.冒泡排序

定义： 比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个 数据交换。
这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。

N=N-1，如果N不为0就重复前面二步，否则排序完成。

1思想：每一次对比相邻两个数据的大小，小的排在前面，如果前面的数据比后面的大就交换这两个数的位置
       要实现上述规则需要用到两层for循环，外层从第一个数到倒数第二个数，内层从外层的后面一个数到最后一个数

2特点：排序算法的基础。简单实用易于理解，缺点是比较次数多，效率较低。

3实现：

定义数组var arr=[10,8,66,2,11];

（1）.先将最大值排到最后[8,10,2,11,66]
i=0:8,10,66,2,11
i=1:8,10,66,2,11
i=2:8,10,2,66,11
i=3:8,10,2,11,66
（2）.
i=0:8,10,2,11
i=1:8,2,10,11
i=2:8,2,10,11
（3）.
i=0:2,8,10
i=1:2,8,10
（4）.
i=0:2,8

var arr=[10,8,66,2,11];
		for(var j=0;j<arr.length-1;j++){
			for(var i=0;i<arr.length-j-1;i++){
				if(arr[i]>arr[i+1]){
					var temp=arr[i];
					arr[i]=arr[i+1];
					arr[i+1]=temp;
				}
			}
		}

相当于

		for(var i=0;i<arr.length-1;i++){
			if(arr[i]>arr[i+1]){
				var temp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		for(var i=0;i<arr.length-2;i++){
			if(arr[i]>arr[i+1]){
				var temp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		for(var i=0;i<arr.length-3;i++){
			if(arr[i]>arr[i+1]){
				var temp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		for(var i=0;i<arr.length-4;i++){
			if(arr[i]>arr[i+1]){
				var temp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=temp;
			}
		}

2.插入排序

   原理：从数组第二个值开始，依次将后续的数值经过比较与前面排序后的序列比较后插入，如图：

（1）从第一个元素开始，该元素可以认为已经被排序；
（2）取出下一个元素，在已经排序的元素序列中从后向前扫描；

（3）如果该元素（已排序）大于新元素，将该元素移到下一位置； 

（4）重复步骤3，直到找到已排序的元素小于或者等于新元素的位置； 

（6）重复步骤2~5。

实现

function insertSort(arr){
  var temp;  //temp变量用于临时存储待插入元素
  for(var i=1; i<arr.length; i++){
     temp = arr[i];
      //从前往后查找插入位置
     for(var j=i; j>0&&arr[j-1]>temp; j--){
         arr[j]=arr[j-1]; //将大于temp的arr[j]元素后移
     }
      arr[j]=temp;
  }
}
  	 insertSort(testArr);
	 alert(testArr);
// 一样的思路
function sort(elements){
  //假设第0个元素是一个有序的数列，第1个以后的是无序的序列，
  //所以从第1个元素开始将无序数列的元素插入到有序数列中
  for(var i = 1; i < elements.length; i++){
    //升序
    if(elements[i] < elements[i-1]){
      //取出无序数列中的第i个作为被插入元素
      var guard = elements[i];
      //记住有序数列的最后一个位置，并且将有序数列位置扩大一个
      var j = i - 1;
      elements[i] = elements[j];    
      //比大小，找到被插入元素所在的位置
      while(j >= 0 && guard < elements[j]){
        elements[j+1] = elements[j];
        j--;
      }
      //插入
      elements[j+1] = guard;
    }
  }
}
var elements = [10, 9, 8, 7, 6, 5];
console.log('before: ' + elements);
sort(elements);
console.log(' after: ' + elements);

3.选择排序

原理：与冒泡排序类似，只不过选择排序不是通过相邻元素交换而将最小值“冒泡”到顶端，而是从数组第一个元素开始，与后面的的元素进行比较，如果后面的元素都比他大，则不需要交换，如果有比其小的，则两个值相互交换。

选择排序就是通过n-i次关键字间的比较，从n-i-1个记录中选出关键字最小的记录，并和第i个记录进行交换。选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

步骤如下：

1.从数组的开头起，将第一个元素和其他所有元素都进行一次比较，选择出最小的元素放在数组的第一个位置。

2.然后再从第二个元素开始，将第二个元素和除第一个之外的所有元素进行一次比较，选择出最小的元素放在数组的第二个位置。

3.对后面的第三，第四……的元素分别重复上面的步骤，直到所有的数据完成排序。

function selectSort(arr){
    var minIndex;//定义minIndex变量用于存储每一趟比较时的最小数的下标
    for(var i=0; i<arr.length; i++){
        minIndex = i;
        for(var j=i+1; j<arr.length; j++){
           if(arr[minIndex]>arr[j]){
               minIndex = j;
           }
        }
        //每轮比较后若arr[i]不是我们需要的最小那个数，则进行交换
        if(minIndex!=i){
           var temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}
 //测试
 var testArr = [35,22,1,88,56,25];
 selectSort(testArr);
 alert(testArr); //输出1,22,25,35,56,88