AS3排序算法

2024-05-04 18:58
文章标签 算法 排序 as3

本文主要是介绍AS3排序算法，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

  1. package {   
  2.     import flash.display.Sprite;   
  3.     import flash.utils.getTimer;   
  4.   
  5.     public class ActionscriptSortTest extends Sprite {   
  6.         //要求将radomArr安从小到大排序   
  7.         public function ActionscriptSortTest() {   
  8.             initRadomArr();   
  9.                
  10.             getBubbleSortArr();   
  11.         }   
  12. /*          
  13.         冒泡排序是这样实现的：  
  14.            1. 首先将所有待排序的数字放入工作列表中。  
  15.            2. 从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。  
  16.            3. 重复2号步骤(倒数的数字加1。例如：第一次到倒数第二个数字，第二次到倒数第三个数字，依此类推...)，直至再也不能交换。  
  17.         冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法  
  18. */           
  19.         public function getBubbleSortArr():Array {   
  20.             var result:Array = radomArr.concat();   
  21.                
  22.             fucStart();   
  23.             var i:int = 1;   
  24.             var j:int = 0;   
  25.             var n:int = result.length;   
  26.             for(i=1;i<n;i++) {   
  27.                 for(j=0;j<n-i;j++) {   
  28.                     if(result[j] > result[j+1]) {   
  29.                         var temp:Number = result[j];   
  30.                         result[j] = result[j+1];   
  31.                         result[j+1] = temp;   
  32.                     }   
  33.                 }   
  34.             }   
  35.                
  36.             fucEnd();//17786   
  37.             return result;   
  38.         }   
  39.   
  40.         private var t:int;   
  41.         private function fucStart():void {   
  42.             t = getTimer();   
  43.         }   
  44.            
  45.         private function fucEnd():void {   
  46.             trace(getTimer() - t);   
  47.         }   
  48.            
  49.         private var radomArr:Array;   
  50.         private function initRadomArr():void {   
  51.             radomArr = [];   
  52.             for(var i:int=0;i<10000;i++) {   
  53.                 radomArr.push(int(Math.random()*0xFFF))   
  54.             }   
  55.         }   
  56.     }   
  57. }  

package {import flash.display.Sprite;import flash.utils.getTimer;public class ActionscriptSortTest extends Sprite {//要求将radomArr安从小到大排序public function ActionscriptSortTest() {initRadomArr();getBubbleSortArr();}
/*        冒泡排序是这样实现的：1. 首先将所有待排序的数字放入工作列表中。2. 从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。3. 重复2号步骤(倒数的数字加1。例如：第一次到倒数第二个数字，第二次到倒数第三个数字，依此类推...)，直至再也不能交换。冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法
*/        public function getBubbleSortArr():Array {var result:Array = radomArr.concat();fucStart();var i:int = 1;var j:int = 0;var n:int = result.length;for(i=1;i<n;i++) {for(j=0;j<n-i;j++) {if(result[j] > result[j+1]) {var temp:Number = result[j];result[j] = result[j+1];result[j+1] = temp;}}}fucEnd();//17786return result;}private var t:int;private function fucStart():void {t = getTimer();}private function fucEnd():void {trace(getTimer() - t);}private var radomArr:Array;private function initRadomArr():void {radomArr = [];for(var i:int=0;i<10000;i++) {radomArr.push(int(Math.random()*0xFFF))}}}
}

 

 

1.冒泡排序

  1. /*          
  2.         冒泡排序是这样实现的：  
  3.           
  4.            1. 首先将所有待排序的数字放入工作列表中。  
  5.            2. 从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。  
  6.            3. 重复2号步骤(倒数的数字加1。例如：第一次到倒数第二个数字，第二次到倒数第三个数字，依此类推...)，直至再也不能交换。  
  7.           
  8.         冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法  
  9.           
  10. */           
  11.         public function getBubbleSortArr():Array {   
  12.             var result:Array = radomArr.concat();   
  13.                
  14.             fucStart();   
  15.             var i:int = 1;   
  16.             var j:int = 0;   
  17.             var n:int = result.length;   
  18.             for(i=1;i<n;i++) {   
  19.                 for(j=0;j<n-i;j++) {   
  20.                     if(result[j] > result[j+1]) {   
  21.                         var temp:Number = result[j];   
  22.                         result[j] = result[j+1];   
  23.                         result[j+1] = temp;   
  24.                     }   
  25.                 }   
  26.             }   
  27.                
  28.             fucEnd();//17786   
  29.             return result;   
  30.         }  

 

 

2.插入排序

 

Java代码
  1. /*          
  2.         一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：  
  3.  
  4.        1. 从第一个元素开始，该元素可以认为已经被排序  
  5.        2. 取出下一个元素，在已经排序的元素序列中从后向前扫描  
  6.        3. 如果该元素（已排序）大于新元素，将该元素移到下一位置  
  7.        4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置  
  8.        5. 将新元素插入到该位置中  
  9.        6. 重复步骤2  
  10. */  
  11.   
  12.         public function getInsertionSortArr():Array {   
  13.             var result:Array = radomArr.concat();   
  14.             fucStart();   
  15.                
  16.             var i:int = 1;   
  17.             var n:int = result.length;   
  18.                
  19.             for(i=1;i<n;i++) {   
  20.                 var temp:Number = result[i];   
  21.                 var j:int = i - 1;   
  22.                    
  23.                 while((j>=0) && (result[j] > temp)) {   
  24.                                  result[j+1] = result[j];           
  25.                                  j--;   
  26.                          }   
  27.                             
  28.                          result[j+1] = temp;   
  29.             }   
  30.                
  31.             fucEnd();   
  32.             return result;   
  33.         } 

 

3.快速排序

Java代码
  1. /*          
  2. 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。  
  3.  
  4. 步骤为：  
  5.  
  6.    1. 从数列中挑出一个元素，称为 "基准"（pivot），  
  7.    2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。  
  8.    3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。  
  9.  
  10. 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个演算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。  
  11. */  
  12.            
  13.         public function getQuickSortArr():Array {   
  14.             var result:Array = radomArr.concat();   
  15.             fucStart();   
  16.                
  17.             var n:int = result.length;   
  18.             quickSort(result,0,n-1);   
  19.                
  20.             fucEnd();   
  21.             return result;   
  22.         }   
  23.            
  24.         private function quickSort(arr:Array,low:int,high:int):void {   
  25.             var i:int;   
  26.             var j:int;   
  27.             var x:int;   
  28.                
  29.             if (low < high) { //这个条件用来结束递归   
  30.                    
  31.                 i = low;   
  32.                 j = high;   
  33.                 x = arr[i];   
  34.                
  35.                 while (i < j) {   
  36.                     while (i < j && arr[j] > x) {   
  37.                        j--; //从右向左找第一个小于x的数   
  38.                     }   
  39.                     if (i < j) {   
  40.                        arr[i] = arr[j];   
  41.                        i++;   
  42.                     }   
  43.                    
  44.                     while (i < j && arr[i] < x) {   
  45.                        i++; //从左向右找第一个大于x的数   
  46.                     }   
  47.                    
  48.                     if (i < j) {   
  49.                        arr[j] = arr[i];   
  50.                        j--;   
  51.                     }   
  52.                  }   
  53.   
  54.                 arr[i] = x;   
  55.                 quickSort(arr, low, i - 1);   
  56.                 quickSort(arr, i + 1, high);   
  57.             }   
  58.         }  

 

4.选择排序

Java代码
  1. /*  
  2.     选择排序是这样实现的：  
  3.         1.首先在未排序序列中找到最小元素，存放到排序序列的起始位置  
  4.         2.然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。  
  5.         3.以此类推，直到所有元素均排序完毕。  
  6. */  
  7.         public function getSelectionSort():Array {   
  8.             var result:Array = radomArr.concat();   
  9.                
  10.             fucStart();   
  11.             var i:int = 0;   
  12.             var j:int = 0;   
  13.             var n:int = result.length;   
  14.                
  15.             for (i = 0; i < n - 1; i++) {   
  16.                 var min:int = i;   
  17.                 for (j = i+1; j < n; j++) {   
  18.                     if (result[j] < result[min]) {   
  19.                         min = j;   
  20.                     }   
  21.                 }   
  22.                 /* swap data[i] and data[min] */  
  23.                 var temp:Number = result[i];   
  24.                 result[i] = result[min];   
  25.                 result[min] = temp;   
  26.             }   
  27.   
  28.             fucEnd();//6214   
  29.             return result;   
  30.         }  

 5.鸡尾酒排序

 

Java代码
  1. /*          
  2.         鸡尾酒排序，也就是定向冒泡排序, 鸡尾酒搅拌排序, 搅拌排序 (也可以视作选择排序的一种变形), 涟漪排序, 来回排序 or 快乐小时排序,   
  3.         是冒泡排序的一种变形。此算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序。  
  4. */           
  5.         public function getCocktailSortArr():Array {   
  6.             var result:Array = radomArr.concat();   
  7.                
  8.             fucStart();   
  9.                
  10.             var i:int = 0;   
  11.             var n:int = result.length;   
  12.             var top:int = n - 1;   
  13.             var bottom:int = 0;   
  14.             var swapped:Boolean = true;    
  15.                
  16.             while(swapped) { // if no elements have been swapped, then the list is sorted   
  17.                 swapped = false;    
  18.                 var temp:Number;   
  19.                 for(i = bottom; i < top;i++) {   
  20.                     if(result[i] > result[i + 1]) {  // test whether the two elements are in the correct order   
  21.                         temp = result[i];// let the two elements change places   
  22.                         result[i] = result[i + 1];   
  23.                         result[i + 1] = temp;   
  24.                         swapped = true;   
  25.                     }   
  26.                 }   
  27.                 // decreases top the because the element with the largest value in the unsorted   
  28.                 // part of the list is now on the position top    
  29.                 top = top - 1;    
  30.                 for(i = top; i > bottom;i--) {   
  31.                     if(result[i] < result[i - 1]) {   
  32.                         temp = result[i];   
  33.                         result[i] = result[i - 1];   
  34.                         result[i - 1] = temp;   
  35.                         swapped = true;   
  36.                     }   
  37.                 }   
  38.                 // increases bottom because the element with the smallest value in the unsorted    
  39.                 // part of the list is now on the position bottom    
  40.                 bottom = bottom + 1;     
  41.             }   
  42.                
  43.             fucEnd();//6214   
  44.             return result;   
  45.         }  

这篇关于AS3排序算法的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/959886。

相关文章

openCV中KNN算法的实现

openCV中KNN算法的实现

《openCV中KNN算法的实现》KNN算法是一种简单且常用的分类算法,本文主要介绍了openCV中KNN算法的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的... 目录KNN算法流程使用OpenCV实现KNNOpenCV 是一个开源的跨平台计算机视觉库，它提供了各
阅读更多...
springboot+dubbo实现时间轮算法

springboot+dubbo实现时间轮算法

《springboot+dubbo实现时间轮算法》时间轮是一种高效利用线程资源进行批量化调度的算法,本文主要介绍了springboot+dubbo实现时间轮算法,文中通过示例代码介绍的非常详细,对大家... 目录前言一、参数说明二、具体实现1、HashedwheelTimer2、createWheel3、n
阅读更多...
Mybatis 传参与排序模糊查询功能实现

Mybatis 传参与排序模糊查询功能实现

《Mybatis传参与排序模糊查询功能实现》：本文主要介绍Mybatis传参与排序模糊查询功能实现,本文通过实例代码给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧... 目录一、#{ }和${ }传参的区别二、排序三、like查询四、数据库连接池五、mysql 开发企业规范一、#{ }和${ }传参的
阅读更多...
SpringBoot实现MD5加盐算法的示例代码

SpringBoot实现MD5加盐算法的示例代码

《SpringBoot实现MD5加盐算法的示例代码》加盐算法是一种用于增强密码安全性的技术,本文主要介绍了SpringBoot实现MD5加盐算法的示例代码,文中通过示例代码介绍的非常详细,对大家的学习... 目录一、什么是加盐算法二、如何实现加盐算法2.1 加盐算法代码实现2.2 注册页面中进行密码加盐2.
阅读更多...
Java时间轮调度算法的代码实现

Java时间轮调度算法的代码实现

《Java时间轮调度算法的代码实现》时间轮是一种高效的定时调度算法,主要用于管理延时任务或周期性任务,它通过一个环形数组（时间轮）和指针来实现,将大量定时任务分摊到固定的时间槽中,极大地降低了时间复杂... 目录1、简述2、时间轮的原理3. 时间轮的实现步骤3.1 定义时间槽3.2 定义时间轮3.3 使用时
阅读更多...
C++快速排序超详细讲解

C++快速排序超详细讲解

《C++快速排序超详细讲解》快速排序是一种高效的排序算法,通过分治法将数组划分为两部分,递归排序,直到整个数组有序,通过代码解析和示例,详细解释了快速排序的工作原理和实现过程,需要的朋友可以参考下... 目录一、快速排序原理二、快速排序标准代码三、代码解析四、使用while循环的快速排序1.代码代码1.由快
阅读更多...
如何通过Golang的container/list实现LRU缓存算法

如何通过Golang的container/list实现LRU缓存算法

《如何通过Golang的container/list实现LRU缓存算法》文章介绍了Go语言中container/list包实现的双向链表,并探讨了如何使用链表实现LRU缓存,LRU缓存通过维护一个双向... 目录力扣：146. LRU 缓存主要结构 List 和 Element常用方法1. 初始化链表2.
阅读更多...
golang字符串匹配算法解读

golang字符串匹配算法解读

《golang字符串匹配算法解读》文章介绍了字符串匹配算法的原理,特别是Knuth-Morris-Pratt（KMP）算法,该算法通过构建模式串的前缀表来减少匹配时的不必要的字符比较,从而提高效率,在... 目录简介KMP实现代码总结简介字符串匹配算法主要用于在一个较长的文本串中查找一个较短的字符串（称为
阅读更多...
通俗易懂的Java常见限流算法具体实现

通俗易懂的Java常见限流算法具体实现

《通俗易懂的Java常见限流算法具体实现》：本文主要介绍Java常见限流算法具体实现的相关资料,包括漏桶算法、令牌桶算法、Nginx限流和Redis+Lua限流的实现原理和具体步骤,并比较了它们的... 目录一、漏桶算法1.漏桶算法的思想和原理2.具体实现二、令牌桶算法1.令牌桶算法流程:2.具体实现2.1
阅读更多...
Spring排序机制之接口与注解的使用方法

Spring排序机制之接口与注解的使用方法

《Spring排序机制之接口与注解的使用方法》本文介绍了Spring中多种排序机制,包括Ordered接口、PriorityOrdered接口、@Order注解和@Priority注解,提供了详细示例... 目录一、Spring 排序的需求场景二、Spring 中的排序机制1、Ordered 接口2、Pri
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2