排序算法复习 之 AS3

本文介绍了四种基本的排序算法:冒泡排序、插入排序、快速排序和选择排序,并提供了ActionScript3的具体实现。每种算法均附有详细的步骤说明及时间复杂度分析。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 

以前在论坛的贴子,保存之。

 

原链接: http://uh.9ria.com/link.php?url=http://bbs.9ria.com%2Fviewthread.php%3Ftid%3D32369

 

排序算法复习,要求用ActionScript 3 实现不允许用 Array的sort sorton 方法

 

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();//17786
            return 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.冒泡排序

http://zh.wikipedia.org/w/index.php?title=%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F&variant=zh-hans

 

/*        
        冒泡排序是这样实现的:
        
           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();//17786
            return result;
        }
 

 

2.插入排序

http://zh.wikipedia.org/wiki/%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F

 

/*        
        一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:

       1. 从第一个元素开始,该元素可以认为已经被排序
       2. 取出下一个元素,在已经排序的元素序列中从后向前扫描
       3. 如果该元素(已排序)大于新元素,将该元素移到下一位置
       4. 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
       5. 将新元素插入到该位置中
       6. 重复步骤2
*/

        public function getInsertionSortArr():Array {
            var result:Array = radomArr.concat();
            fucStart();
            
            var i:int = 1;
            var n:int = result.length;
            
            for(i=1;i<n;i++) {
                var temp:Number = result[i];
                var j:int = i - 1;
                
                while((j>=0) && (result[j] > temp)) {
                                 result[j+1] = result[j];        
                                 j--;
                         }
                         
                         result[j+1] = temp;
            }
            
            fucEnd();
            return result;
        }

 

 

       public function getInsertionSortArr():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<i;j++) {
                    if(result[j] > result[i]) {
                        var temp:Number = result[j];
                        result[j] = result[i];
                        result[i] = temp;
                    }
                }
            }
            
            fucEnd();
            return result;
        }

 

 

        public function getInsertionSortArr():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++) {
                var temp:Number = result[i];
                for(j=i;j>0 && temp<result[j-1];j--) {
                    result[j]=result[j-1];
                }
                result[j]=temp;
            }
            
            fucEnd();
            return result;
        }

 

 

3.快速排序

 

http://zh.wikipedia.org/wiki/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F

 

/*        
快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。

步骤为:

   1. 从数列中挑出一个元素,称为 "基准"(pivot),
   2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。
   3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个演算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。
*/
        
        public function getQuickSortArr():Array {
            var result:Array = radomArr.concat();
            fucStart();
            
            var n:int = result.length;
            quickSort(result,0,n-1);
            
            fucEnd();
            return result;
        }
        
        private function quickSort(arr:Array,low:int,high:int):void {
            var i:int;
            var j:int;
            var x:int;
            
            if (low < high) { //这个条件用来结束递归
                
                i = low;
                j = high;
                x = arr[i];
            
                while (i < j) {
                    while (i < j && arr[j] > x) {
                       j--; //从右向左找第一个小于x的数
                    }
                    if (i < j) {
                       arr[i] = arr[j];
                       i++;
                    }
                
                    while (i < j && arr[i] < x) {
                       i++; //从左向右找第一个大于x的数
                    }
                
                    if (i < j) {
                       arr[j] = arr[i];
                       j--;
                    }
                 }

                arr[i] = x;
                quickSort(arr, low, i - 1);
                quickSort(arr, i + 1, high);
            }
        }

 

 

4.选择排序

 

http://zh.wikipedia.org/wiki/%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F

 

 

/*
    选择排序是这样实现的:
        1.首先在未排序序列中找到最小元素,存放到排序序列的起始位置
        2.然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。
        3.以此类推,直到所有元素均排序完毕。
*/
        public function getSelectionSort():Array {
            var result:Array = radomArr.concat();
            
            fucStart();
            var i:int = 0;
            var j:int = 0;
            var n:int = result.length;
            
            for (i = 0; i < n - 1; i++) {
                var min:int = i;
                for (j = i+1; j < n; j++) {
                    if (result[j] < result[min]) {
                        min = j;
                    }
                }
                /* swap data[i] and data[min] */
                var temp:Number = result[i];
                result[i] = result[min];
                result[min] = temp;
            }

            fucEnd();//6214
            return result;
        }
 

 

### 关于STC15W408AS单片机期末考试复习资料 #### 一、题型分布分值比例 针对STC15W408AS单片机的期末考试,题目类型通常分为客观题和主观题两大类。具体来说: - **客观题**:包括填空、判断以及选择三种形式,主要考察对于知识的记忆程度;还有名词解释部分,则侧重检验学生对特定术语的理解水平[^1]。 - **主观题**:由简答题构成,旨在评估考生能否清晰阐述概念并运用所学理论解决实际问题的能力;而综合分析设计则更进一步,要求能够独立完成较为复杂的编程任务或硬件电路的设计工作。 各部分内容的大致占比为全面认知占总成绩的30%,理解简单应用占据40%的比例,剩下30%留给综合性的分析及设计方案评测。 #### 二、重章节复习建议 为了更好地准备这类考试,在复习过程中应当重关注以下几个方面: ##### (一)分支循环程序设计 此部分涉及常见的算法实现,比如数据搬运操作(即内存地址间的数据复制)、数值累加运算、查找数组中的极值元素(最大/最小),以及各种排序方法的学习。应仔细研读课本上的实例代码,并通过实践加深印象。 ```c // 数据搬运动态分配空间示例 void data_copy(unsigned char *src, unsigned char *dst, int length){ while(length--) { *dst++ = *src++; } } ``` ##### (二)GPIO接口配置及其应用场景 特别需要注意的是第六章有关通用输入输出端口(GPIO)的内容,尤其是外部中断处理机制(参见例子6-4),定时器触发的中断服务函数编写技巧(如案例6-7所示),以及其他几个典型的应用场景描述(从例子6-8到6-11)。 另外,当涉及到具体的外设连接时,例如使用该型号单片机控制发光二极管(LED)显示状态变化的情况,除了考虑其内部寄存器设置之外,还需要关注外部元件的选择&mdash;&mdash;像是否需要接入限流电阻来保护LED免受过电流损害等问题[^2]。 #### 三、其他注意事项 最后提醒各位同学,在日常学习之余也要多做练习题巩固记忆效果,特别是历年真题模拟测试可以帮助大家熟悉考场环境下的解题节奏。同时要善于总结归纳每一章节的核心要,形成自己的笔记体系以便随时查阅回顾。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值