精华内容
下载资源
问答
  • 代码动画编写

    千次阅读 2015-04-14 16:19:41
    android开发中代码动画编写,和添加。

     

    private void startCodeAnim(){
    		AnimationSet animationSet = new AnimationSet(true);
    //		AlphaAnimation alphaAnimation = new AlphaAnimation(0, 1);
    //		alphaAnimation.setDuration(1000);
    //		alphaAnimation.setStartOffset(10000);
    		//scale缩放比从2倍到1(原始大小)
    		ScaleAnimation scale = new ScaleAnimation(2.0f, 1.0f, 2.0f, 1.0f,Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
    		scale.setDuration(1000);//动画播放间隔
    		animationSet.addAnimation(scale);
    		//rotate反方向旋转20度
    		RotateAnimation rotate =new RotateAnimation(0f,-20f,Animation.RELATIVE_TO_SELF, 0.5f,Animation.RELATIVE_TO_SELF,0.5f); 
    		rotate.setDuration(1000);
    		animationSet.addAnimation(rotate);
    		//translate从原始位置向x和y的正方向移动原始图片大小的10%距离
    		TranslateAnimation translate = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0f, Animation.RELATIVE_TO_SELF, 0.1f, Animation.RELATIVE_TO_SELF, 0f, Animation.RELATIVE_TO_SELF, 0.1f);
    		translate.setDuration(1300);
    		animationSet.addAnimation(translate);
    		//animationSet.setStartOffset(10000);
    //		animationSet.setFillBefore(false);
    		//设置不动画播放完后不回到原始位置
    		animationSet.setFillAfter(true);
    		//添加并播放动画
    		iv1.startAnimation(animationSet);
    	}


     

    展开全文
  • 1:每个动画状态,比如进入状态,离开状态, 等都有可能需要代码来参与和处理,比如,进入这个动画单元后做哪些事情,来开这个动画单元后做哪些事情,为了解决这个问题,unity允许每个动画单元来绑定一个脚本代码,这个...

    对于多量的、复杂的、有规律的控制器使用代码生成

     

     

    动画状态代码控制

    1:每个动画状态,比如进入状态,离开状态, 等都有可能需要代码来参与和处理,比如,进入这个动画单元后做哪些事情,来开这个动画单元后做哪些事情,为了解决这个问题,unity允许每个动画单元来绑定一个脚本代码,这个脚本代码必须继承于StateMachineBehaviour;
    2: 可以在动画状态的Add Behaviour上添加挂载一个脚本到动画状态;
    3: StateMachineBehaviour主要接口:
      (1)OnStateEnter: 当动画开始播放的时候被调用;
      (2)OnStateExit: 当动画结束播放的时候被调用;
      (3)OnStateMove: 当动画被移动的时候调用;
      (4)OnStateIK: 当动画触发逆向运动学时调用此方法;
      (5)OnStateUpdate: 每帧都会被调用;

     


    动画状态代码控制案例

    1.创建Unity工程和文件目录

    2.导入资源文件包body_anim.unitypackage(第58)

    3.打开Models文件夹,点击模型Boy,设置Rig---->Animation Tyoe---->Humanoid(人形动画)

    4.配置Avatar

    5.把模型Boy拖进场景中,会自己挂载一个Animator的组件

    6.在res文件夹下创建一个动画控制器Create---->Animator Controller,叫做anim_ctrl,双击打开,可以用鼠标中键按下拖动背景

    7.把Assets\Animations\AnisForFight的Boy@ForwardKick.FBX直接拖进Animator视图中的状态机中,设置为默认,再连接一条线到Exit

    8.把anim_ctrl关联到Boy模型的Animator组件的Controller

    9.运行,角色会不停地踢腿,现在我们要给它加一个代码控制

    10点击状态机里面的ForwardKick,右边属性面板下有一个Add Behaviour,点击创建一个新的脚本叫anim_test。

    11.这时候anim_test脚本文件在文件目录的外面,我们可以把它拖进scripts文件夹

    打开脚本anim_test

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class anim_test : StateMachineBehaviour {
    
        //layerIndex就是动画所在的层,Base Layer层的layerIndex是0
        //要获得其他节点的组件都可以像MonoBehaviour那样做
         // OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
        override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
            Debug.Log("OnStateEnter");
        }
    
        //每一帧都执行
        // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
        override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
            Debug.Log("OnStateUpdate");
        }
    
        // OnStateExit is called when a transition ends and the state machine finishes evaluating this state
        override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
            Debug.Log("OnStateExit");
        }
    
        //下面两个用的不多
        // OnStateMove is called right after Animator.OnAnimatorMove(). Code that processes and affects root motion should be implemented here
        //override public void OnStateMove(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
        //
        //}
    
        // OnStateIK is called right after Animator.OnAnimatorIK(). Code that sets up animation IK (inverse kinematics) should be implemented here.
        //override public void OnStateIK(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
        //
        //}
    }

     

     

    代码生成动画控制器

    1:10个状态,每2个状态之间需要建立两两的联系,那么这个动画控制器就会有100个过渡条件,那么这个时候最好的方式是代码自动的生成动画控制器;
    2: 扩展编辑器,来动态生成这个动画控制器,不用手动的去修改;
    3: 扩展编辑器的相关的API:
      (1)创建一个动画控制器:createAnimationControllerAtPath(“path”);
      (2)获取动画状态机: AnimatorStateMachine controller.layers[index].stateMachine;
      (3)设置默认的动画状态: stateMachine.defaultState
      (4)加载AnimationClip: AssertDatabase.LoaderAssetAtPath(“path”, typeof(AnimationClip))
          As AnimationClip;
      (5)为每个状态指定动画:state.motion = animclip;
      (6)AnimController.AddParameter(名字, AnimationParamsType);
      (7)添加一个过渡: AddTransition(dst_state, false);
      (8)过渡添加一个条件: trans.AddCondition();
      (9)最后一个添加exit state: AddExitTransition(); 制定输出动画;

     

     

    代码生成动画控制器案例

    1.先导入动画资源包anims.unitypackage(第58)到Assets\Animations目录下,里面有十个动画

    2.扩展编辑器,新建一个Editor文件夹,在Editor目录下创建一个脚本叫CreateAnimCtrl

    打开CreateAnimCtrl

    using UnityEngine;
    using System.Collections;
    using UnityEditor;
    using UnityEditor.Animations;
    
    public class CreateAnimCtrl : MonoBehaviour {
        [MenuItem("Assets/Create/CreateAnimCtrl")]//添加了一个菜单栏,可以在最上面菜单栏点击Assets/Create发现多了一个CreateAnimCtrl
        // 执行函数,点击Assets/Create/CreateAnimCtrl会执行的函数
        static void Run() {
            Debug.Log("Run called");
            // Step1: 生成我们的动画控制文件;这个操作等于右键Create---->Animator Controller到Assets/res目录下,名字叫code_anim.controller
            AnimatorController ctrl = AnimatorController.CreateAnimatorControllerAtPath("Assets/res/code_anim.controller");
            // Step2 获取我们的动画状态机;
            AnimatorStateMachine state_machine = ctrl.layers[0].stateMachine;
    
            // 创建我们的动画状态;先创建一个数组,里面可以放10个动画状态
            AnimatorState[] state = new AnimatorState[10] ;
            for (int i = 0; i < 10; i++) {
                state[i] = state_machine.AddState("state" + i);//状态机添加动画状态
                // 这个语句相当于把Assets\Animations\AnisWithNum目录下的一个一个的可执行动画文件关联到对应的动画状态的Motion属性
                // as 强转类型过去,是C#的语法
                AnimationClip anim = AssetDatabase.LoadAssetAtPath("Assets/Animations/AnisWithNum/Ani" + i + ".FBX", typeof(AnimationClip)) as AnimationClip;
                state[i].motion = anim;
            }
    
            // 两两添加过渡;
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 10; j++) {  // i --> j 的transform
                    // 创建每个动画过渡的控制变量,等于在Animator面板的Parameters面板下的参数添加条件变量,是开关类型的变量,这个变量就是只要选中就会执行
                    ctrl.AddParameter(i + "switch" + j, AnimatorControllerParameterType.Trigger);
                    // end 
                    //两两动画状态之间添加过渡,等于在状态机那个图里面选择一个动画状态然后右键Make Transition
                    AnimatorStateTransition trans = state[i].AddTransition(state[j], false);
    
                    //给每个过渡添加条件,等于在过渡的属性面板下面的Condition属性点击+号,默认是0,就是关闭的状态
                    trans.AddCondition(AnimatorConditionMode.If, 0, i + "switch" + j);
                }
            }
                // end 
            // 设置一个默认动画状态,把第0个动画状态设置为默认动画状态;
            state_machine.defaultState = state[0];
    
        }
    }

    3.点击Assets/Create/CreateAnimCtrl,自动生成动画控制器且配置好了。最后把code_anim.controller关联到Boy模型的Animator组件的Controller属性中。

     

    展开全文
  • android基本动画代码构建动画

    千次阅读 2015-01-04 10:09:47
    使用代码构建android基本动画,基本动画有以下: AlphaAnimation:渐变透明度动画 RotateAnimation:旋转动画 ScaleAnimation:伸缩动画 TranslateAnimation:平移动画 可以定义出一些常用的动画效果,也可以...

    使用代码构建android基本动画,基本动画有以下:

    AlphaAnimation:渐变透明度动画

    RotateAnimation:旋转动画

    ScaleAnimation:伸缩动画

    TranslateAnimation:平移动画

     

    可以定义出一些常用的动画效果,也可以自定义一些动画,把参数预留出来。

    可以定义一些组合动画效果,例如:从里到外的效果。对于组合的动画效果,使用基本的动画效果构建起来。

    使用AnimationSet添加到此集合中,让其里面的动画一起起效果,可以看到意想不到的效果。

    代码工具类

     

    /**
     * 使用代码设计的动画
     * 
     */
    public class AnimationCodeUtils {
    	private static Animation anim;
    
    	/**
    	 * 默认的是: 1.透明度从1.0~0, 2.动画时间3000毫秒 3.不停在动画结束状态
    	 * 
    	 * @return 渐变透明度动画
    	 */
    	public static AlphaAnimation alphaAnimation1To0() {
    		AlphaAnimation alpha = new AlphaAnimation(1.0f, 0.0f);
    		alpha.setDuration(3000);
    		return alpha;
    	}
    
    	/**
    	 * 默认的是: 1.透明度从0.0~1, 2.动画时间3000毫秒 3.不停在动画结束状态
    	 * 
    	 * @return 渐变透明度动画
    	 */
    	public static AlphaAnimation alphaAnimation0To1() {
    		AlphaAnimation alpha = new AlphaAnimation(0.0f, 1.0f);
    		alpha.setDuration(3000);
    		return alpha;
    	}
    
    	/**
    	 * @param fromAlpha
    	 *            开始透明度(0~1.0)
    	 * @param toAlpha
    	 *            结束透明度(0~1.0)
    	 * @param durationMillis
    	 *            动画执行时间
    	 * @param fillAfter
    	 *            是否停留在动画结束状态
    	 * @return
    	 */
    	public static AlphaAnimation alphaAnimationCustom(float fromAlpha,
    			float toAlpha, long durationMillis, boolean fillAfter) {
    		AlphaAnimation alpha = new AlphaAnimation(fromAlpha, toAlpha);
    		alpha.setDuration(durationMillis);
    		alpha.setFillAfter(fillAfter);
    		return alpha;
    	}
    
    	/**
    	 * 旋转动画,顺时针360 默认:1.旋转角度:0~360 2.相对于自己的中心位置 3.旋转时间为30004.不停留在动画结束状态
    	 * 
    	 * @return
    	 */
    	public static RotateAnimation rotateAnimation0to360() {
    		RotateAnimation rotate = new RotateAnimation(0f, 360f,
    				RotateAnimation.RELATIVE_TO_SELF, 0.5f,
    				RotateAnimation.RELATIVE_TO_SELF, 0.5f);
    		rotate.setDuration(3000);
    		rotate.setFillAfter(false);
    		return rotate;
    	}
    
    	/**
    	 * 旋转动画,逆时针360 默认:1.旋转角度:360-0 2.相对于自己的中心位置 3.旋转时间为30004.不停留在动画结束状态
    	 * 
    	 * @return
    	 */
    	public static RotateAnimation rotateAnimation360to0() {
    		RotateAnimation rotate = new RotateAnimation(360f, 0f,
    				RotateAnimation.RELATIVE_TO_SELF, 0.5f,
    				RotateAnimation.RELATIVE_TO_SELF, 0.5f);
    		rotate.setDuration(3000);
    		rotate.setFillAfter(false);
    		return rotate;
    	}
    
    	/**
    	 * 
    	 * 旋转动画,自定义
    	 * 
    	 * @return
    	 */
    	/**
    	 * @param fromDegrees
    	 *            开始旋转的角度
    	 * @param toDegrees
    	 *            结束的角度
    	 * @param pivotXType
    	 *            X方向相对位置类型
    	 * @param pivotXValue
    	 *            X方向相对位置的值
    	 * @param pivotYType
    	 *            Y方向相对位置类型
    	 * @param pivotYValue
    	 *            Y方向相对位置的值
    	 * @param durationMillis
    	 *            动画执行时间
    	 * @param fillAfter
    	 *            是否停留在动画结束时间
    	 * @return
    	 */
    	public static RotateAnimation rotateAnimationCustom(float fromDegrees,
    			float toDegrees, int pivotXType, float pivotXValue, int pivotYType,
    			float pivotYValue, long durationMillis, boolean fillAfter) {
    		RotateAnimation rotate = new RotateAnimation(fromDegrees, toDegrees,
    				pivotXType, pivotXValue, pivotYType, pivotYValue);
    		rotate.setDuration(durationMillis);
    		rotate.setFillAfter(fillAfter);
    		return rotate;
    	}
    
    	/**
    	 * 伸缩动画 默认:相对于自己,向左上角缩小,从有到无,动画时间3000,不停留在动画结束状态
    	 */
    	public static ScaleAnimation scaleAnimation1to0() {
    		ScaleAnimation scale = new ScaleAnimation(1.0f, 0.0f, 1.0f, 0.0f,
    				ScaleAnimation.RELATIVE_TO_SELF, 0f,
    				ScaleAnimation.RELATIVE_TO_SELF, 0f);
    		scale.setDuration(3000);
    		scale.setFillAfter(false);
    		return scale;
    	}
    
    	/**
    	 * 伸缩动画 默认:相对于自己,向左上角放大,从无到有,动画时间3000,不停留在动画结束状态
    	 */
    	public static ScaleAnimation scaleAnimation0to1() {
    		ScaleAnimation scale = new ScaleAnimation(0.0f, 1.0f, 0.0f, 1.0f,
    				ScaleAnimation.RELATIVE_TO_SELF, 0f,
    				ScaleAnimation.RELATIVE_TO_SELF, 0f);
    		scale.setDuration(3000);
    		scale.setFillAfter(false);
    		return scale;
    	}
    
    	/**
    	 * 伸缩动画
    	 */
    	/**
    	 * @param fromX
    	 *            X方向开始缩放的角度(0-1) 0是不显示,1是全部显示
    	 * @param toX
    	 *            X方向结束缩放的角度(0-1) 0是不显示,1是全部显示
    	 * @param fromY
    	 *            Y方向开始缩放的角度(0-1) 0是不显示,1是全部显示
    	 * @param toY
    	 *            Y方向结束缩放的角度(0-1) 0是不显示,1是全部显示
    	 * @param pivotXType
    	 *            X方向相对类型
    	 * @param pivotXValue
    	 *            X方向相对于的值
    	 * @param pivotYType
    	 *            Y方向相对类型
    	 * @param pivotYValue
    	 *            Y方向相对于的值
    	 * @param durationMillis
    	 *            动画执行时间
    	 * @param fillAfter
    	 *            是否停留在动画结束的状态
    	 * @return
    	 */
    	public static ScaleAnimation scaleAnimationCustom(float fromX, float toX,
    			float fromY, float toY, int pivotXType, float pivotXValue,
    			int pivotYType, float pivotYValue, long durationMillis,
    			boolean fillAfter) {
    		ScaleAnimation scale = new ScaleAnimation(fromX, toX, fromY, toY,
    				pivotXType, pivotXValue, pivotYType, pivotYValue);
    		scale.setDuration(durationMillis);
    		scale.setFillAfter(fillAfter);
    		return scale;
    	}
    
    	/**
    	 * 平移动画:从左向右 平移
    	 * 
    	 * @return
    	 */
    	public static TranslateAnimation translateAnimationLeftToRight() {
    		TranslateAnimation translate = new TranslateAnimation(
    				TranslateAnimation.RELATIVE_TO_SELF, 0.0f,
    				TranslateAnimation.RELATIVE_TO_SELF, 1.0f,
    				TranslateAnimation.RELATIVE_TO_SELF, 0.0f,
    				TranslateAnimation.RELATIVE_TO_SELF, 0.0f);
    		translate.setDuration(3000);
    		translate.setFillAfter(false);
    		return translate;
    	}
    
    	/**
    	 * 平移动画:从右向左 平移
    	 * 
    	 * @return
    	 */
    	public static TranslateAnimation translateAnimationRightToLeft() {
    		TranslateAnimation translate = new TranslateAnimation(
    				TranslateAnimation.RELATIVE_TO_SELF, 1.0f,
    				TranslateAnimation.RELATIVE_TO_SELF, 0.0f,
    				TranslateAnimation.RELATIVE_TO_SELF, 0.0f,
    				TranslateAnimation.RELATIVE_TO_SELF, 0.0f);
    		translate.setDuration(3000);
    		translate.setFillAfter(false);
    		return translate;
    	}
    
    	/**
    	 * 平移动画:自定义
    	 * 
    	 * @return
    	 */
    	/**
    	 * @param fromXType
    	 *            X方向开始平移相对类型
    	 * @param fromXValue
    	 *            X方向开始平移相对值
    	 * @param toXType
    	 *            X方向结束平移相对类型
    	 * @param toXValue
    	 *            X方向结束平移相对值
    	 * @param fromYType
    	 *            Y方向开始平移相对类型
    	 * @param fromYValue
    	 *            Y方向开始平移相对值
    	 * @param toYType
    	 *            Y方向结束平移相对类型
    	 * @param toYValue
    	 *            Y方向结束平移相对值
    	 * @param durationMillis
    	 *            动画执行时间
    	 * @param fillAfter
    	 *            是否停留在动画结束状态
    	 * @return
    	 */
    	public static TranslateAnimation translateAnimationCustom(int fromXType,
    			float fromXValue, int toXType, float toXValue, int fromYType,
    			float fromYValue, int toYType, float toYValue, long durationMillis,
    			boolean fillAfter) {
    		TranslateAnimation translate = new TranslateAnimation(fromXType,
    				fromXValue, toXType, toXValue, fromYType, fromYValue, toYType,
    				toYValue);
    		translate.setDuration(durationMillis);
    		translate.setFillAfter(fillAfter);
    		return translate;
    	}
    
    	/**
    	 * 动画集合:渐变-缩放-旋转;效果,从里向外旋转放大
    	 * 
    	 * @return
    	 */
    	public static Animation animationSet() {
    		AnimationSet aniset = new AnimationSet(true);// true表示一起起作用
    		aniset.addAnimation(alphaAnimation0To1());
    		aniset.addAnimation(AnimationCodeUtils.scaleAnimationCustom(0f, 1f, 0f,
    				1f, ScaleAnimation.RELATIVE_TO_SELF, 0.5f,
    				ScaleAnimation.RELATIVE_TO_SELF, 0.5f, 3000, false));
    		aniset.addAnimation(rotateAnimation0to360());
    		return aniset;
    	}
    }
    

     

     

    源码下载:http://download.csdn.net/detail/forwardyzk/8317823
    动画效果图:

    展开全文
  • 1// Java 代码实现 2public class BubbleSort implements IArraySort { 3 4 @Override 5 public int[] sort(int[] sourceArray) throws Exception { 6 // 对 arr 进行拷贝,不改变参数内容...

     

    排序算法是《数据结构与算法》中最基本的算法之一。

    排序算法可以分为内部排序外部排序

    内部排序是数据记录在内存中进行排序。

    而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。

    常见的内部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

    用一张图概括:

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

    时间复杂度与空间复杂度

    关于时间复杂度:

    1. 平方阶 (O(n2)) 排序 各类简单排序:直接插入、直接选择和冒泡排序。

    2. 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序;

    3. O(n1+§)) 排序,§ 是介于 0 和 1 之间的常数。 希尔排序

    4. 线性阶 (O(n)) 排序 基数排序,此外还有桶、箱排序。

    关于稳定性:

    1. 稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序。

    2. 不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序。

    1. 冒泡排序

    1.1 算法步骤

    • 比较相邻的元素。如果第一个比第二个大,就交换他们两个。

    • 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

    • 针对所有的元素重复以上的步骤,除了最后一个。

    • 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

    1.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

     

    冒泡排序动画演示

    1.3 参考代码

     1// Java 代码实现
     2public class BubbleSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        // 对 arr 进行拷贝,不改变参数内容
     7        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     8
     9        for (int i = 1; i < arr.length; i++) {
    10            // 设定一个标记,若为true,则表示此次循环没有进行交换,也就是待排序列已经有序,排序已经完成。
    11            boolean flag = true;
    12
    13            for (int j = 0; j < arr.length - i; j++) {
    14                if (arr[j] > arr[j + 1]) {
    15                    int tmp = arr[j];
    16                    arr[j] = arr[j + 1];
    17                    arr[j + 1] = tmp;
    18
    19                    flag = false;
    20                }
    21            }
    22
    23            if (flag) {
    24                break;
    25            }
    26        }
    27        return arr;
    28    }
    29}
    

    2. 选择排序

    2.1 算法步骤

    • 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置

    • 再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

    • 重复第二步,直到所有元素均排序完毕。

    2.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

     

    选择排序动画演示

    2.3 参考代码

     1//Java 代码实现
     2public class SelectionSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     7
     8        // 总共要经过 N-1 轮比较
     9        for (int i = 0; i < arr.length - 1; i++) {
    10            int min = i;
    11
    12            // 每轮需要比较的次数 N-i
    13            for (int j = i + 1; j < arr.length; j++) {
    14                if (arr[j] < arr[min]) {
    15                    // 记录目前能找到的最小值元素的下标
    16                    min = j;
    17                }
    18            }
    19
    20            // 将找到的最小值和i位置所在的值进行交换
    21            if (i != min) {
    22                int tmp = arr[i];
    23                arr[i] = arr[min];
    24                arr[min] = tmp;
    25            }
    26
    27        }
    28        return arr;
    29    }
    30}
    

    3. 插入排序

    3.1 算法步骤

    • 将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。

    • 从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)

    3.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

     

    插入排序动画演示

    3.3 参考代码

     1//Java 代码实现
     2public class InsertSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        // 对 arr 进行拷贝,不改变参数内容
     7        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     8
     9        // 从下标为1的元素开始选择合适的位置插入,因为下标为0的只有一个元素,默认是有序的
    10        for (int i = 1; i < arr.length; i++) {
    11
    12            // 记录要插入的数据
    13            int tmp = arr[i];
    14
    15            // 从已经排序的序列最右边的开始比较,找到比其小的数
    16            int j = i;
    17            while (j > 0 && tmp < arr[j - 1]) {
    18                arr[j] = arr[j - 1];
    19                j--;
    20            }
    21
    22            // 存在比其小的数,插入
    23            if (j != i) {
    24                arr[j] = tmp;
    25            }
    26
    27        }
    28        return arr;
    29    }
    30}
    

    4. 希尔排序

    4.1 算法步骤

    • 选择一个增量序列 t1,t2,……,tk,其中 ti > tj, tk = 1;

    • 按增量序列个数 k,对序列进行 k 趟排序;

    • 每趟排序,根据对应的增量 ti,将待排序列分割成若干长度为 m 的子序列,分别对各子表进行直接插入排序。仅增量因子为 1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。

    4.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

     

    希尔排序动画演示

    4.3 参考代码

     1//Java 代码实现
     2public class ShellSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        // 对 arr 进行拷贝,不改变参数内容
     7        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     8
     9        int gap = 1;
    10        while (gap < arr.length) {
    11            gap = gap * 3 + 1;
    12        }
    13
    14        while (gap > 0) {
    15            for (int i = gap; i < arr.length; i++) {
    16                int tmp = arr[i];
    17                int j = i - gap;
    18                while (j >= 0 && arr[j] > tmp) {
    19                    arr[j + gap] = arr[j];
    20                    j -= gap;
    21                }
    22                arr[j + gap] = tmp;
    23            }
    24            gap = (int) Math.floor(gap / 3);
    25        }
    26
    27        return arr;
    28    }
    29}
    

    5. 归并排序

    5.1 算法步骤

    • 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;

    • 设定两个指针,最初位置分别为两个已经排序序列的起始位置;

    • 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;

    • 重复步骤 3 直到某一指针达到序列尾;

    • 将另一序列剩下的所有元素直接复制到合并序列尾。

    5.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

     

    归并排序动画演示

    5.3 参考代码

     1//Java 代码实现
         public class MergeSort implements IArraySort {
     2
     3    @Override
     4    public int[] sort(int[] sourceArray) throws Exception {
     5        // 对 arr 进行拷贝,不改变参数内容
     6        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     7
     8        if (arr.length < 2) {
     9            return arr;
    10        }
    11        int middle = (int) Math.floor(arr.length / 2);
    12
    13        int[] left = Arrays.copyOfRange(arr, 0, middle);
    14        int[] right = Arrays.copyOfRange(arr, middle, arr.length);
    15
    16        return merge(sort(left), sort(right));
    17    }
    18
    19    protected int[] merge(int[] left, int[] right) {
    20        int[] result = new int[left.length + right.length];
    21        int i = 0;
    22        while (left.length > 0 && right.length > 0) {
    23            if (left[0] <= right[0]) {
    24                result[i++] = left[0];
    25                left = Arrays.copyOfRange(left, 1, left.length);
    26            } else {
    27                result[i++] = right[0];
    28                right = Arrays.copyOfRange(right, 1, right.length);
    29            }
    30        }
    31
    32        while (left.length > 0) {
    33            result[i++] = left[0];
    34            left = Arrays.copyOfRange(left, 1, left.length);
    35        }
    36
    37        while (right.length > 0) {
    38            result[i++] = right[0];
    39            right = Arrays.copyOfRange(right, 1, right.length);
    40        }
    41
    42        return result;
    43    }
    44
    45}
    

    6. 快速排序

    6.1 算法步骤

    • 从数列中挑出一个元素,称为 “基准”(pivot);

    • 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;

    • 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;

    6.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

     

    快速排序动画演示

    6.3 参考代码

     1//Java 代码实现
     2public class QuickSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        // 对 arr 进行拷贝,不改变参数内容
     7        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     8
     9        return quickSort(arr, 0, arr.length - 1);
    10    }
    11
    12    private int[] quickSort(int[] arr, int left, int right) {
    13        if (left < right) {
    14            int partitionIndex = partition(arr, left, right);
    15            quickSort(arr, left, partitionIndex - 1);
    16            quickSort(arr, partitionIndex + 1, right);
    17        }
    18        return arr;
    19    }
    20
    21    private int partition(int[] arr, int left, int right) {
    22        // 设定基准值(pivot)
    23        int pivot = left;
    24        int index = pivot + 1;
    25        for (int i = index; i <= right; i++) {
    26            if (arr[i] < arr[pivot]) {
    27                swap(arr, i, index);
    28                index++;
    29            }
    30        }
    31        swap(arr, pivot, index - 1);
    32        return index - 1;
    33    }
    34
    35    private void swap(int[] arr, int i, int j) {
    36        int temp = arr[i];
    37        arr[i] = arr[j];
    38        arr[j] = temp;
    39    }
    40
    41}
    

    7. 堆排序

    7.1 算法步骤

    • 创建一个堆 H[0……n-1];

    • 把堆首(最大值)和堆尾互换;

    • 把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置;

    • 重复步骤 2,直到堆的尺寸为 1。

    7.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

                                                                         堆排序动画演示

    7.3 参考代码

     1//Java 代码实现
     2public class HeapSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        // 对 arr 进行拷贝,不改变参数内容
     7        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     8
     9        int len = arr.length;
    10
    11        buildMaxHeap(arr, len);
    12
    13        for (int i = len - 1; i > 0; i--) {
    14            swap(arr, 0, i);
    15            len--;
    16            heapify(arr, 0, len);
    17        }
    18        return arr;
    19    }
    20
    21    private void buildMaxHeap(int[] arr, int len) {
    22        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
    23            heapify(arr, i, len);
    24        }
    25    }
    26
    27    private void heapify(int[] arr, int i, int len) {
    28        int left = 2 * i + 1;
    29        int right = 2 * i + 2;
    30        int largest = i;
    31
    32        if (left < len && arr[left] > arr[largest]) {
    33            largest = left;
    34        }
    35
    36        if (right < len && arr[right] > arr[largest]) {
    37            largest = right;
    38        }
    39
    40        if (largest != i) {
    41            swap(arr, i, largest);
    42            heapify(arr, largest, len);
    43        }
    44    }
    45
    46    private void swap(int[] arr, int i, int j) {
    47        int temp = arr[i];
    48        arr[i] = arr[j];
    49        arr[j] = temp;
    50    }
    51
    52}
    

    8. 计数排序

    8.1 算法步骤

    • 花O(n)的时间扫描一下整个序列 A,获取最小值 min 和最大值 max

    • 开辟一块新的空间创建新的数组 B,长度为 ( max - min + 1)

    • 数组 B 中 index 的元素记录的值是 A 中某元素出现的次数

    • 最后输出目标整数序列,具体的逻辑是遍历数组 B,输出相应元素以及对应的个数

    8.2 动画演示

    十大经典排序算法动画与解析,看我就够了!(配代码完全版)

     

    计数排序动画演示

    8.3 参考代码

     1//Java 代码实现
     2public class CountingSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        // 对 arr 进行拷贝,不改变参数内容
     7        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     8
     9        int maxValue = getMaxValue(arr);
    10
    11        return countingSort(arr, maxValue);
    12    }
    13
    14    private int[] countingSort(int[] arr, int maxValue) {
    15        int bucketLen = maxValue + 1;
    16        int[] bucket = new int[bucketLen];
    17
    18        for (int value : arr) {
    19            bucket[value]++;
    20        }
    21
    22        int sortedIndex = 0;
    23        for (int j = 0; j < bucketLen; j++) {
    24            while (bucket[j] > 0) {
    25                arr[sortedIndex++] = j;
    26                bucket[j]--;
    27            }
    28        }
    29        return arr;
    30    }
    31
    32    private int getMaxValue(int[] arr) {
    33        int maxValue = arr[0];
    34        for (int value : arr) {
    35            if (maxValue < value) {
    36                maxValue = value;
    37            }
    38        }
    39        return maxValue;
    40    }
    41
    42}
    

    9. 桶排序

    9.1 算法步骤

    • 设置固定数量的空桶。

    • 把数据放到对应的桶中。

    • 对每个不为空的桶中数据进行排序。

    • 拼接不为空的桶中数据,得到结果

    9.2 动画演示

     

                                                                             桶排序动画演示

    9.3 参考代码

     1//Java 代码实现
     2public class BucketSort implements IArraySort {
     3
     4    private static final InsertSort insertSort = new InsertSort();
     5
     6    @Override
     7    public int[] sort(int[] sourceArray) throws Exception {
     8        // 对 arr 进行拷贝,不改变参数内容
     9        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
    10
    11        return bucketSort(arr, 5);
    12    }
    13
    14    private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
    15        if (arr.length == 0) {
    16            return arr;
    17        }
    18
    19        int minValue = arr[0];
    20        int maxValue = arr[0];
    21        for (int value : arr) {
    22            if (value < minValue) {
    23                minValue = value;
    24            } else if (value > maxValue) {
    25                maxValue = value;
    26            }
    27        }
    28
    29        int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
    30        int[][] buckets = new int[bucketCount][0];
    31
    32        // 利用映射函数将数据分配到各个桶中
    33        for (int i = 0; i < arr.length; i++) {
    34            int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
    35            buckets[index] = arrAppend(buckets[index], arr[i]);
    36        }
    37
    38        int arrIndex = 0;
    39        for (int[] bucket : buckets) {
    40            if (bucket.length <= 0) {
    41                continue;
    42            }
    43            // 对每个桶进行排序,这里使用了插入排序
    44            bucket = insertSort.sort(bucket);
    45            for (int value : bucket) {
    46                arr[arrIndex++] = value;
    47            }
    48        }
    49
    50        return arr;
    51    }
    52
    53    /**
    54     * 自动扩容,并保存数据
    55     *
    56     * @param arr
    57     * @param value
    58     */
    59    private int[] arrAppend(int[] arr, int value) {
    60        arr = Arrays.copyOf(arr, arr.length + 1);
    61        arr[arr.length - 1] = value;
    62        return arr;
    63    }
    64
    65}
    

    10. 基数排序

    10.1 算法步骤

    • 将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零

    • 从最低位开始,依次进行一次排序

    • 从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列

    10.2 动画演示

     

                                                                            基数排序动画演示

    10.3 参考代码

     1//Java 代码实现
     2public class RadixSort implements IArraySort {
     3
     4    @Override
     5    public int[] sort(int[] sourceArray) throws Exception {
     6        // 对 arr 进行拷贝,不改变参数内容
     7        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
     8
     9        int maxDigit = getMaxDigit(arr);
    10        return radixSort(arr, maxDigit);
    11    }
    12
    13    /**
    14     * 获取最高位数
    15     */
    16    private int getMaxDigit(int[] arr) {
    17        int maxValue = getMaxValue(arr);
    18        return getNumLenght(maxValue);
    19    }
    20
    21    private int getMaxValue(int[] arr) {
    22        int maxValue = arr[0];
    23        for (int value : arr) {
    24            if (maxValue < value) {
    25                maxValue = value;
    26            }
    27        }
    28        return maxValue;
    29    }
    30
    31    protected int getNumLenght(long num) {
    32        if (num == 0) {
    33            return 1;
    34        }
    35        int lenght = 0;
    36        for (long temp = num; temp != 0; temp /= 10) {
    37            lenght++;
    38        }
    39        return lenght;
    40    }
    41
    42    private int[] radixSort(int[] arr, int maxDigit) {
    43        int mod = 10;
    44        int dev = 1;
    45
    46        for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
    47            // 考虑负数的情况,这里扩展一倍队列数,其中 [0-9]对应负数,[10-19]对应正数 (bucket + 10)
    48            int[][] counter = new int[mod * 2][0];
    49
    50            for (int j = 0; j < arr.length; j++) {
    51                int bucket = ((arr[j] % mod) / dev) + mod;
    52                counter[bucket] = arrayAppend(counter[bucket], arr[j]);
    53            }
    54
    55            int pos = 0;
    56            for (int[] bucket : counter) {
    57                for (int value : bucket) {
    58                    arr[pos++] = value;
    59                }
    60            }
    61        }
    62
    63        return arr;
    64    }
    65    private int[] arrayAppend(int[] arr, int value) {
    66        arr = Arrays.copyOf(arr, arr.length + 1);
    67        arr[arr.length - 1] = value;
    68        return arr;
    69    }
    70}
    

     

    ❤️ 看完三件事:

    如果你觉得这篇内容对你挺有启发,我想邀请你帮我三个忙:

    1. 点赞,让更多的人也能看到这篇内容(收藏不点赞,都是耍流氓 -_-)

    2. 关注我和专栏,让我们成为长期关系

    3. 关注公众号「五分钟学算法」,第一时间阅读最新的算法文章,公众号后台回复 1024 送你 50 本 算法编程书籍。

    展开全文
  • 这个图片是动态的,可以把代码复制下来看效果: ... /* 上面的旋转动画代码 */  /* 定义动画动画名:animat_rotate,可以取任意名字 */  /* 使用方式:animation: run 6s linear; */  
  • Unity动画 代码加载动画,可复用

    千次阅读 2016-12-09 17:39:49
    所以我准备自己写一篇代码加载动画方案。这个是解决帧动画的,因为u3d没有播放gif的功能,有了这个神器,传入图片和总时间,就ok了。 首先我们准备一个图集,里面是播放动画的小图片。 然后创建一个sprite,放入...
  • 这里介绍用代码动态生成动画及插值器 标签对应类: scale —— ScaleAnimation alpha —— AlphaAnimation rotate —— RotateAnimation translate —— TranslateAnimation set —— AnimationSet 2. Animat...
  • css动画旋转代码

    千次阅读 2018-02-08 21:21:58
    有很多朋友都说字体 图片以及一些简单动画 要做旋转效果 都说要用js或者jq 才能去做这个特效。。今天我们用css 就直接做旋转特效。话不多说 直接上代码 css样式 div{ width:120px; height:120px; line-height:...
  • QuartzCode快速开发动画代码工具 QuartzCode一款快速,轻量,强大的动画工具,可快速得到原生的ObjC/Siwft代码 我可以用QuartzCode做什么? 应用程序演练动画 动画菜单或场景 自定义动画UI 应用样机 可视化您的...
  • 摘要:通过上一篇咱们知道了播放动画需要使用Animator,那么如何用代码控制动画呢? 洪流学堂,让你快人几步。你好,我是跟着大智学Unity的萌新,我叫小新,这几周一起来复(yu)习(xi)动画系统。 “智哥,我...
  • android纯代码圆周动画

    千次阅读 2015-09-19 16:24:48
    看到支付宝启动界面,很清新,比较绚,于是做了个简单界面,只是完成了动画效果,并集成到一个控件上去,使用起来非常方便,本人较懒,完成这些效果后,就没再走下去了 不多说,上代码 package com.example.test; ...
  • 1、效果图跟上一遍博客一样,请参考...接下来直接java代码实现如何实现动画: 定义private Animation animation_alpha,animation_scale,animation_translate,animation_rotate; private AnimationSet animationSet;分
  • QML简单动画Behavior代替复杂代码

    千次阅读 2016-09-22 16:33:08
    事先要先熟悉Behavior,就不会陷入复杂困境。 今天做Demo有缩短代码的方法,如下: 原动画代码: 采用Behavior后: Behavior在处理简单动画的速率上显然要快很多~ ...
  • 安卓动画代码实现

    千次阅读 2015-05-21 21:00:28
    在设计中为了实现各种各样的效果,会经常使用到安卓的效果动画,今天把这些知识梳理汇总了一下,分享给大家
  • Html5动画代码

    千次阅读 2017-11-29 13:01:21
    .div1{ width: 60px; height: 60px; border: 1px solid red; background-color: aqua; } .div1:hover{ transform: scale(2) rotate(30deg);; } .div2{ width: 60px;...border: 1px solid
  • CSS动画实现比JS简单很多,但是对于新手来说还是很多代码的,而且还要不停的刷新来计算动画效果,不过没关系,今天小编为大家分享一个可以在线生成CSS动画的工具:AniCollection,而且他们的动画数量很多,能满足...
  • android游戏开场动画代码

    热门讨论 2009-10-12 13:51:00
    Android平台很经典的游戏Abduction(奶牛跳高)开场动画代码
  • 程序员前端动画表白代码

    千次阅读 多人点赞 2019-06-18 21:57:48
    代码如下 <!doctype html> <html> <head> <meta charset="utf-8"> <title>canvas 心</title> <style> html, body { height: 100%; padding: 0; margin: 0; ...
  • Unity代码添加Animator动画回调事件

    千次阅读 2020-01-17 11:29:54
    手动添加动画回调事件 ...代码添加动画回调事件 需要用到的类 Animator、 AnimatorOverrideController 用于覆盖控制器中的动画剪辑,以针对给定的头像专门化动画,不会重置状态机的当前状态、 Animat...
  • java代码实现的帧动画

    千次阅读 2017-12-12 19:56:24
    2、帧动画的简要代码 private ImageView bgAnimView; private AnimationDrawable mAnimationDrawable; //初始化 mAnimationDrawable = new AnimationDrawable(); bgAnimView = new ImageV
  • 我想要实现这样的效果: 一个物体绕自己的y轴旋转...(2)全部用代码实现动画效果。这样会在后续的开发中出现其他问题。 是否可以用AnimationEvent实现呢?本人刚刚接触unity没多久,尝试了很久还是没弄出来,求赐教!
  • 在利用安卓studio做放网易云音乐过程中,发现网易云音乐的播放界面很有特色,就是指针与打碟的旋转与暂停,所以就在网上搜索了一下,并在老师的指导下做出了效果,因此再次整理一下动画效果的代码运用。 1.要求 ...
  • Android代码实现删除抛掷动画

    千次阅读 2013-09-29 14:56:55
    对于android动画的使用,我由衷于通过代码调用Animation相关类来实现,下面讲讲我是如何通过代码实现删除抛掷动画的。  如下图所示就是我所说的删除抛掷功能,对视图A启动该动画效果,动画完成后视图A到达B地,在...
  • Unity代码修改模型动画属性

    千次阅读 2019-11-01 17:22:27
    如下图示属性,需要批量通过代码修改 ModelImporter modelImporter = AssetImporter.GetAtPath(assetPath) as ModelImporter; ModelImporterClipAnimation tempClip = modelImporter.defaultCli...
  • 在UGUI中用代码创建Spine 动画

    千次阅读 2018-09-27 15:55:50
    在UGUI中用代码创建Spine 动画 // An highlighted block using UnityEngine; using Spine.Unity; public class SpineTest : MonoBehaviour { void Start () { CreateCharacter(); } private void ...
  • 简单来说,就是可以直接利用 AE 导出的 JSON 动画文件,将其解析为原生代码,并跨平台运行在设备上。 根据身边朋友的试用,通过 Canvas 绘制动画非常非常流畅,并且在 AE 动画没有遮罩的前提下内存控制得也...
  • 代码中设置补间动画

    千次阅读 2013-07-08 17:56:05
    随时随地阅读更多技术实战干货,获取项目源码、学习资料,请关注源代码社区公众号(ydmsq666)、博主微信(guyun297890152)、QQ技术交流群(183198395)。...下面用一个简单实例来演示在代码中设置补间动画代码...
  • using UnityEngine; using System.Collections; public class AnimationManager : ... /// 创建动画动画控制委托,后面创建播放动画方法,然后就调用就可以直接用委托的对象来调用 /// 例:animationHandler = x...
  • Android PopupWindow动画效果代码

    千次阅读 2012-07-29 13:39:49
    通过SetAnimationSyle()添加动画效果;代码如下:   @anim/fade_in @anim/fade_out 其中的两个文件如下: fade_in.xml a

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,316
精华内容 17,326
关键字:

代码动画