[AS3]使用黄金分割查找法来搜索数组的元素

需要FloatUtil.equals，请参照[AS3]判断两个浮点小数的数组是否相等。

Class : advancedflex.utils.FloatArrayUtil

/**
* 使用黄金分割查找法来搜索数组的元素。
*
* @param sortedArray 排成升序(从小到大)的数组。
* @param value 要查找的值。
* @param tol 浮点小数的计算误差。
* @return 元素的下标。如果没有，则返回 -1。
*/

public static function gsearch(sortedArray:Array, value:Number, tol:Number = 1e-12):int {
 if(!sortedArray) {
  throw new ArgumentError("Param: must not be null.");
 }
 return $gsearch(sortedArray, value, tol, 0, sortedArray.length);
}

/**
 * @private
 */
private static const $LEFT_RATIO:Number = 0.6180339887498949;

/**
 * @private
 */
private static const $RIGHT_RATIO:Number = 1 - $LEFT_RATIO;

 /**
 * @private
 * 使用黄金分割查找法来搜索数组的元素。
 * 
 * @param sortedArray 排成升序(从小到大)的数组。
 * @param value 要查找的值。
 * @param tol 浮点小数的计算误差。
 * @param left 查找的最左边。
 * @param right 查找的最右边。
 * @return 元素的下标。如果没有，则返回 -1。
 */
private static function $gsearch(
 sortedArray:Array, value:Number, tol:Number,
 left:int, right:int):int 
{
 if(right - left <= 1) {
  return FloatUtil.equals(sortedArray[left], value, tol) ? left :
   FloatUtil.equals(sortedArray[right], value, tol) ? left :
   -1;
 }
 var center:int = $RIGHT_RATIO*left + $LEFT_RATIO*right
 switch(FloatUtil.compare(sortedArray[center], value, tol)) {
  case 1 :
   return $gsearch(sortedArray, value, tol, left, center);
  case -1:
   return $gsearch(sortedArray, value, tol, center, right);
  default:
   return center;
 }
}

[AS3]使用二分法查找法来搜索数组的元素

需要FloatUtil.equals，请参照[AS3]判断两个浮点小数的数组是否相等

Class : advancedflex.utils.FloatArrayUtil

/**
* 使用二分查找法来搜索数组的元素。
*
* @param sortedArray 排成升序(从小到大)的数组。
* @param value 要查找的值。
* @param tol 浮点小数的计算误差。
* @return 元素的下标。如果没有，则返回 -1。
* @throws ArgumentError 如果 sortedArray 为 null。
*/


public static function bsearch(sortedArray:Array, value:Number, tol:Number = 1e-12):int {
 if(!sortedArray) {
  throw new ArgumentError("Param: must not be null.");
 }
 return $bsearch(sortedArray, value, tol, 0, sortedArray.length-1);
}
/**
 * @private
 * 使用二分查找法来搜索数组的元素。
 * 
 * @param sortedArray 排成升序(从小到大)的数组。
 * @param value 要查找的值。
 * @param tol 浮点小数的计算误差。
 * @param left 查找的最左边。
 * @param right 查找的最右边。
 * @return 元素的下标。如果没有，则返回 -1。
 */
private static function $bsearch(
 sortedArray:Array, value:Number, tol:Number,
 left:int, right:int):int 
{
 if(right - left <= 1) {
  return FloatUtil.equals(sortedArray[left], value, tol) ? left :
   FloatUtil.equals(sortedArray[right], value, tol) ? left :
   -1;
 }
 var center:int = (left+right)/2;
 switch(FloatUtil.compare(sortedArray[center], value, tol)) {
  case 1 :
   return $bsearch(sortedArray, value, tol, left, center);
  case -1:
   return $bsearch(sortedArray, value, tol, center, right);
  default:
   return center;
 }
}

[AS3]两个浮点小数的数组相加

/**
* 两个浮点小数的数组相加。
* @sample addArray([1,2], [3,4]); // -> [4,6]
*
* @param a 一个浮点小数的数组。
* @param b 另一个浮点小数的数组。
* @param result 返回结果的数组，如果为 null，将会创建新的数组返回。
* @return 结果。如果 result 不为 null，将会返回 result；否则将会创建新的数组返回。
*/

public static function addArray(a:Array, b:Array, result:Array = null):Array {
 var length:int = Math.max(a.length, b.length);
 result = result || new Array(length);
 for(var i:int = 0; i < length; i++) {
  result[i] = a[i] + b[i];
 }
 return result;
}

[AS3]得到 Array 指定的元素的个数。

/**
* 得到指定的元素的个数。
*
* @param array 数组。
* @param value 元素。
* @return 个数。
* @throws ArgumentError 当 array 为 null 时。
*/

public static function count(array:Array, value:*):int {
if(!array) {
 throw new ArgumentError("Param: must not be null.");
}
var found:int = 0;
var length:int = array.length;
for(var i:int = 0; i <>

[AS3]打乱数组的排列顺序

需要 swap 函数，请参见[AS3]交换数组中的两个下标的值。

/**
* 打乱数组的排列顺序。
*
* @param array 数组。
* @return 数组本身。
*/

public static function random(array:Array):Array {
 var length:int = array.length/2 + 1;
 var last:int = array.length;
 var idx:int;
 for(var i:int = 0; i < length; i++) {
  idx = i + int(Math.random()*last);
  last--;
  swap(array, i, idx);
 }
 return array;
}

[AS3]交换数组中的两个下标的值

/**
* 交换数组中的两个下标的值。
*
* @param array 数组。
* @param idx1 一个下标。
* @param idx2 另一个下标。
*/

public static function swap(array:Array, idx1:int, idx2:int):void {
 var tmp:* = array[idx1];
 array[idx1] = array[idx2];
 array[idx2] = tmp;
}

[AS3]删除数组中的重复的元素

/**
* 删除数组中的重复的元素。顺序为第一次出现的顺序。
*
* @sample unique([1,1,2,1,3,2,1,1]) // -> [1,2,3]
* @param array 数组。
* @return 删除给与数组中的重复的元素后的新数组。
*/

public static function unique(array:Array):Array {
 var result:Array = [];
 var valueSet:Dictionary = new Dictionary(false);
 var length:int = array.length;
 for(var i:int = 0; i < length; i++) {
  if(!valueSet[array[i]]) {
   result.push(array[i]);
   valueSet[array[i]] = true;
  }
 }
 return result;
}

[AS3]判断两个浮点小数的数组是否相等

需要 eqFloat 函数。请参见：[AS3]比较两个浮点小数

/**
* 在考虑计算误差的情况下，判断两个浮点小数的数组是否相等。
*
* @param a 一个浮点小数的数组。
* @param b 另一个浮点小数的数组。
* @param tol 允许的最大浮点小数的计算误差。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqFloatArray(a:Array, b:Array,
    tol:Number = 1e-12):Boolean
{
    if(a.length != b.length) {
        return false;
    }
    var l:int = a.length;
    for(var i:int = 0; i < l; i++) {
        if(!eqFloat(a[i], b[i], tol)) {
            return false;
        }
    }
    return true;
}