标签分类
当前位置:首页 > 程序设计电子书 > 程序设计电子书网盘下载
挑战程序设计竞赛 挑战程序设计竞赛
cztqwan

cztqwan 提供上传

资源
34
粉丝
46
喜欢
8
评论
14

    挑战程序设计竞赛 PDF 完整第2版

    程序设计电子书
    • 发布时间:

    给大家带来的一篇关于程序设计相关的电子书资源,介绍了关于挑战程序设计竞赛、算法、数据结构方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小55.5 MB,秋叶拓哉编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.5,更多相关的学习资源可以参阅 程序设计电子书、等栏目。

  • 挑战程序设计竞赛 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1caa-rRq00WJ4kxUrHDW9SQ
  • 分享码:3mp3
  • 挑战程序设计竞赛

    内容介绍

    挑战程序设计竞赛2:算法和数据结构》分成提前准备篇、基本篇和运用篇三绝大多数,依靠免费在线测评系统软件Aizu Online Judge及其很多练习题,详尽解读了算法与算法复杂度、初等和高等学校排列、检索、递归和分治法、动态规划法、二叉搜索树、堆、图、测算几何学、数论等与程序设计竞赛有关的算法和数据结构,既能够做为挑战程序设计竞赛的教材,还可以用于正确引导新手系统软件学习培训算法和数据结构的基本知识。这书合适全部程序设计工作人员、程序设计竞赛发烧友及其高等院校软件工程专业老师学生阅读文章。

    目录

    • 第1部分 [准备篇]攻克程序设计竞赛的学习方法 1
    • 第1章 有效运用在线评测系统 3
    • 1.1 攻克程序设计竞赛的学习方法 3
    • 1.2 什么是在线评测 7
    • 1.3 用户注册 9
    • 1.4 浏览问题 10
    • 1.5 解答问题 12
    • 1.6 个人页面 18
    • 1.7 如何运用本书 19
    • 第2部分 [基础篇]为程序设计竞赛做准备的算法与数据结构 21
    • 第2章 算法与复杂度 23
    • 2.1 算法是什么 23
    • 2.2 问题与算法示例 23
    • 2.3 伪代码 25
    • 2.4 算法的效率 26
    • 2.5 入门问题 28
    • 第3章 初等排序 33
    • 3.1 挑战问题之前——排序 33
    • 3.2 插入排序法 35
    • 3.3 冒泡排序法 40
    • 3.4 选择排序法 44
    • 3.5 稳定排序 48
    • 3.6 希尔排序法 52
    • 第4章 数据结构 57
    • 4.1 挑战问题之前——什么是数据结构 57
    • 4.2 栈 59
    • 4.3 队列 64
    • 4.4 链表 70
    • 4.5 标准库的数据结构 77
    • 4.6 数据结构的应用——计算面积 86
    • 第5章 搜索 89
    • 5.1 挑战问题之前——搜索 89
    • 5.2 线性搜索 91
    • 5.3 二分搜索 94
    • 5.4 散列法 98
    • 5.5 借助标准库搜索 102
    • 5.6 搜索的应用——计算最优解 106
    • 第6章 递归和分治法 109
    • 6.1 挑战问题之前——递归与分治 109
    • 6.2 穷举搜索 111
    • 6.3 科赫曲线 114
    • 第7章 高等排序 119
    • 7.1 归并排序 120
    • 7.2 分割 125
    • 7.3 快速排序 129
    • 7.4 计数排序 133
    • 7.5 利用标准库排序 137
    • 7.6 逆序数 139
    • 7.7 最小成本排序 143
    • 第8章 树 147
    • 8.1 挑战问题之前——树结构 148
    • 8.2 有根树的表达 150
    • 8.3 二叉树的表达 154
    • 8.4 树的遍历 159
    • 8.5 树遍历的应用——树的重建 163
    • 第9章 二叉搜索树 167
    • 9.1 挑战问题之前——二叉搜索树 168
    • 9.2 二叉搜索树——插入 169
    • 9.3 二叉搜索树——搜索 174
    • 9.4 二叉搜索树——删除 177
    • 9.5 通过标准库管理集合 182
    • 第10章 堆 189
    • 10.1 挑战问题之前——堆 190
    • 10.2 完全二叉树 191
    • 10.3 最大/最小堆 193
    • 10.4 优先级队列 197
    • 10.5 通过标准库实现优先级队列 201
    • 第11章 动态规划法 203
    • 11.1 挑战问题之前——动态规划法的概念 203
    • 11.2 斐波那契数列 204
    • 11.3 最长公共子序列 208
    • 11.4 矩阵链乘法 211
    • 第12章 图 217
    • 12.1 挑战问题之前——图 218
    • 12.2 图的表示 221
    • 12.3 深度优先搜索 224
    • 12.4 广度优先搜索 232
    • 12.5 连通分量 237
    • 第13章 加权图 241
    • 13.1 挑战问题之前——加权图 242
    • 13.2 最小生成树 244
    • 13.3 单源最短路径 249
    • 第3部分 [应用篇]程序设计竞赛的必备程序库 261
    • 第14章 高等数据结构 263
    • 14.1 互质的集合 264
    • 14.2 范围搜索 269
    • 14.3 其他问题 278
    • 第15章 高等图算法 279
    • 15.1 所有点对间最短路径 280
    • 15.2 拓扑排序 284
    • 15.3 关节点 290
    • 15.4 树的直径 295
    • 15.5 最小生成树 299
    • 15.6 其他问题 303
    • 第16章 计算几何学 305
    • 16.1 几何对象的基本元素与表现 306
    • 16.2 直线的正交/平行判定 312
    • 16.3 投影 314
    • 16.4 映象 316
    • 16.5 距离 317
    • 16.6 逆时针方向 321
    • 16.7 判断线段相交 324
    • 16.8 线段的交点 326
    • 16.9 圆与直线的交点 328
    • 16.10 圆与圆的交点 331
    • 16.11 点的内包 333
    • 16.12 凸包 335
    • 16.13 线段相交问题 339
    • 16.14 其他问题 343
    • 第17章 动态规划法 345
    • 17.1 硬币问题 346
    • 17.2 背包问题 349
    • 17.3 最长递增子序列 353
    • 17.4 最大正方形 357
    • 17.5 最大长方形 360
    • 17.6 其他问题 364
    • 第18章 数论 367
    • 18.1 质数检验 368
    • 18.2 最大公约数 372
    • 18.3 幂乘 376
    • 18.4 其他问题 378
    • 第19章 启发式搜索 381
    • 19.1 八皇后问题 382
    • 19.2 九宫格拼图 386
    • 19.3 十六格拼图 391
    • 附录 399
    • 通过本书可以获得的技能 400
    • 挑战以往的程序设计竞赛真题! 402
    • 参考文献 404

    读书笔记

    JS面向对象的程序设计相关知识小结

    面向对象的语言有一个标志,即拥有类的概念,抽象实例对象的公共属性与方法,基于类可以创建任意多个实例对象,一般具有封装、继承、多态的特性!但JS中对象与纯面向对象语言中的对象是不同的,ECMA标准定义JS中对象:无序属性的集合,其属性可以包含基本值、对象或者函数。可以简单理解为JS的对象是一组无序的值,其中的属性或方法都有一个名字,根据这个名字可以访问相映射的值(值可以是基本值/对象/方法)。

    一、理解对象:

    第一种:基于Object对象

    var person = new Object();
    person.name = 'My Name';
    person.age = 18;
    person.getName = function(){
      return this.name;
    }

    第二种:对象字面量方式(比较清楚的查找对象包含的属性及方法)

    var person = {
      name : 'My name',
      age : 18,
      getName : function(){
        return this.name;
      }
    }

    JS的对象可以使用‘.'操作符动态的扩展其属性,可以使用'delete'操作符或将属性值设置为'undefined'来删除属性。如下:

    person.newAtt='new Attr';//添加属性
    alert(person.newAtt);//new Attr
    delete person.age;
    alert(person.age);//undefined(删除属性后值为undefined);

    二、对象属性类型

    ECMA-262第5版定义了JS对象属性中特征(用于JS引擎,外部无法直接访问)。ECMAScript中有两种属性:数据属性和访问器属性

    1、数据属性:

    数据属性指包含一个数据值的位置,可在该位置读取或写入值,该属性有4个供述其行为的特性:

    [[configurable]]:表示能否使用delete操作符删除从而重新定义,或能否修改为访问器属性。默认为true;

    [[Enumberable]]:表示是否可通过for-in循环返回属性。默认true;

    [[Writable]]:表示是否可修改属性的值。默认true;

    [[Value]]:包含该属性的数据值。读取/写入都是该值。默认为undefined;如上面实例对象person中定义了name属性,其值为'My name',对该值的修改都反正在这个位置

    要修改对象属性的默认特征(默认都为true),可调用Object.defineProperty()方法,它接收三个参数:属性所在对象,属性名和一个描述符对象(必须是:configurable、enumberable、writable和value,可设置一个或多个值)。

    如下:(浏览器支持:IE9+、Firefox 4+、Chrome、Safari5+)

    var person = {};
    Object.defineProperty(person, 'name', {
      configurable: false,
      writable: false,
      value: 'Jack'
    });
    alert(person.name);//Jack
    delete person.name;
    person.name = 'lily';
    alert(person.name);//Jack

    可以看出,delete及重置person.name的值都没有生效,这就是因为调用defineProperty函数修改了对象属性的特征;值得注意的是一旦将configurable设置为false,则无法再使用defineProperty将其修改为true(执行会报错:can't redefine non-configurable property);

    2、访问器属性:

    它主要包括一对getter和setter函数,在读取访问器属性时,会调用getter返回有效值;写入访问器属性时,调用setter,写入新值;该属性有以下4个特征:

    [[Configurable]]:是否可通过delete操作符删除重新定义属性;

    [[Numberable]]:是否可通过for-in循环查找该属性;

    [[Get]]:读取属性时调用,默认:undefined;

    [[Set]]:写入属性时调用,默认:undefined;

    访问器属性不能直接定义,必须使用defineProperty()来定义,如下:

    var person = {
      _age: 18
    };
    Object.defineProperty(person, 'isAdult', {
      get: function () {
        if (this._age >= 18) {
          return true;
        } else {
          return false;
        }
      }
    });
    alert(person.isAdult?'成年':'未成年');//成年

    从上面可知,定义访问器属性时getter与setter函数不是必须的,并且,在定义getter与setter时不能指定属性的configurable及writable特性;

    此外,ECMA-262(5)还提供了一个Object.defineProperties()方法,可以用来一次性定义多个属性的特性:

    var person = {};
    Object.defineProperties(person,{
      _age:{
        value:19
      },
      isAdult:{
        get: function () {
          if (this._age >= 18) {
            return true;
          } else {
            return false;
          }
        }
      }
    });
    alert(person.isAdult?'成年':'未成年');//成年

    上述代码使用Object.defineProperties()方法同时定义了_age及isAudlt两个属性的特性

    此外,使用Object.getOwnPropertyDescriptor()方法可以取得给定属性的特性:

    var descriptor = Object.getOwnPropertyDescriptor(person,'_age');
    alert(descriptor.value);//19

    对于数据属性,可以取得:configurable,enumberable,writable和value;

    对于访问器属性,可以取得:configurable,enumberable,get和set

    三、创建对象

    使用Object构造函数或对象字面量都可以创建对象,但缺点是创建多个对象时,会产生大量的重复代码,因此下面介绍可解决这个问题的创建对象的方法

    1、工厂模式

    function createPerson(name, age, job) {
      var o = new Object();
      o.name = name;
      o.age = age;
      o.job = job;
      o.getName = function () {
        return this.name;
      }
      return o;//使用return返回生成的对象实例
    }
    var person = createPerson('Jack', 19, 'SoftWare Engineer');

    创建对象交给一个工厂方法来实现,可以传递参数,但主要缺点是无法识别对象类型,因为创建对象都是使用Object的原生构造函数来完成的。

    2、构造函数模式

    function Person(name,age,job){
      this.name = name;
      this.age = age;
      this.job = job;
      this.getName = function () {
        return this.name;
      }
    }
    var person1 = new Person('Jack', 19, 'SoftWare Engineer');
    
    var person2 = new Person('Liye', 23, 'Mechanical Engineer');

    使用自定义的构造函数(与普通函数一样,只是用它来创建对象),定义对象类型(如:Person)的属性和方法。它与工厂方法区别在于:

    • 没有显式地创建对象
    • 直接将属性和方法赋值给this对象;
    • 没有return语句;

    此外,要创建Person的实例,必须使用new关键字,以Person函数为构造函数,传递参数完成对象创建;实际创建经过以下4个过程:

    1. 创建一个对象
    2. 将函数的作用域赋给新对象(因此this指向这个新对象,如:person1)
    3. 执行构造函数的代码
    4. 返回该对象

    上述由Person构造函数生成的两个对象person1与person2都是Person的实例,因此可以使用instanceof判断,并且因为所有对象都继承Object,因此person1 instanceof Object也返回真:

    alert(person1 instanceof Person);//true;
    alert(person2 instanceof Person);//true;
    alert(person1 instanceof Object);//true;
    alert(person1.constructor === person2.constructor);//ture;

    虽然构造函数方式比较不错,但也存在缺点,那就是在创建对象时,特别针对对象的属性指向函数时,会重复的创建函数实例,以上述代码为基础,可以改写为:

    function Person(name,age,job){
      this.name = name;
      this.age = age;
      this.job = job;
      this.getName = new Function () {//改写后效果与原代码相同,不过是为了方便理解
        return this.name;
      }
    }

    上述代码,创建多个实例时,会重复调用new Function();创建多个函数实例,这些函数实例还不是一个作用域中,当然这一般不会有错,但这会造成内存浪费。当然,可以在函数中定义一个getName = getName的引用,而getName函数在Person外定义,这样可以解决重复创建函数实例问题,但在效果上并没有起到封装的效果,如下所示:

    function Person(name,age,job){
      this.name = name;
      this.age = age;
      this.job = job;
      this.getName = getName;
    }
    function getName() {//到处是代码,看着乱!!
        return this.name;
    }

    3、原型模式

    JS每个函数都有一个prototype(原型)属性,这个属性是一个指针,指向一个对象,它是所有通过new操作符使用函数创建的实例的原型对象。原型对象最大特点是,所有对象实例共享它所包含的属性和方法,也就是说,所有在原型对象中创建的属性或方法都直接被所有对象实例共享。

    function Person(){
    }
    Person.prototype.name = 'Jack';//使用原型来添加属性
    Person.prototype.age = 29;
    Person.prototype.getName = function(){
      return this.name;
    }
    var person1 = new Person();
    alert(person1.getName());//Jack
    var person2 = new Person();
    alert(person1.getName === person2.getName);//true;共享一个原型对象的方法

    原型是指向原型对象的,这个原型对象与构造函数没有太大关系,唯一的关系是函数的prototype是指向这个原型对象!而基于构造函数创建的对象实例也包含一个内部指针为:[[prototype]]指向原型对象。

    实例属性或方法的访问过程是一次搜索过程:

    • 首先从对象实例本身开始,如果找到属性就直接返回该属性值;
    • 如果实例本身不存在要查找属性,就继续搜索指针指向的原型对象,在其中查找给定名字的属性,如果有就返回;

    基于以上分析,原型模式创建的对象实例,其属性是共享原型对象的;但也可以自己实例中再进行定义,在查找时,就不从原型对象获取,而是根据搜索原则,得到本实例的返回;简单来说,就是实例中属性会屏蔽原型对象中的属性;

    原型与in操作符

    一句话:无论原型中属性,还是对象实例的属性,都可以使用in操作符访问到;要想判断是否是实例本身的属性可以使用object.hasOwnProperty(‘attr')来判断;

    原生对象中原型
    原生对象中原型与普通对象的原型一样,可以添加/修改属性或方法,如以下代码为所有字符串对象添加去左右空白原型方法:

    String.prototype.trim = function(){
      return this.replace(/^\s+/,'').replace(/\s+$/,'');
    }
    var str = '  word space  ';
    alert('!'+str.trim()+'!');//!word space!

    原型模式的缺点,它省略了为构造函数传递初始化参数,这在一定程序带来不便;另外,最主要是当对象的属性是引用类型时,它的值是不变的,总是引用同一个外部对象,所有实例对该对象的操作都会其它实例:

    function Person() {
    }
    Person.prototype.name = 'Jack';
    Person.prototype.lessons = ['Math','Physics'];
    var person1 = new Person();
    person1.lessons.push('Biology');
    var person2 = new Person();
    alert(person2.lessons);//Math,Physics,Biology,person1修改影响了person2

     4、组合构造函数及原型模式
    目前最为常用的定义类型方式,是组合构造函数模式与原型模式。构造函数模式用于定义实例的属性,而原型模式用于定义方法和共享的属性。结果,每个实例都会有自己的一份实例属性的副本,但同时又共享着对方方法的引用,最大限度的节约内存。此外,组合模式还支持向构造函数传递参数,可谓是集两家之所长。

    function Person(name, age, job) {
      this.name = name;
      this.age = age;
      this.job = job;
      this.lessons = ['Math', 'Physics'];
    }
    Person.prototype = {
      constructor: Person,//原型字面量方式会将对象的constructor变为Object,此外强制指回Person
      getName: function () {
        return this.name;
      }
    }
    var person1 = new Person('Jack', 19, 'SoftWare Engneer');
    person1.lessons.push('Biology');
    var person2 = new Person('Lily', 39, 'Mechanical Engneer');
    alert(person1.lessons);//Math,Physics,Biology
    alert(person2.lessons);//Math,Physics
    alert(person1.getName === person2.getName);//true,//共享原型中定义方法

    在所接触的JS库中,jQuery类型的封装就是使用组合模式来实例的!!!

    5、动态原型模式
    组合模式中实例属性与共享方法(由原型定义)是分离的,这与纯面向对象语言不太一致;动态原型模式将所有构造信息都封装在构造函数中,又保持了组合的优点。其原理就是通过判断构造函数的原型中是否已经定义了共享的方法或属性,如果没有则定义,否则不再执行定义过程。该方式只原型上方法或属性只定义一次,且将所有构造过程都封装在构造函数中,对原型所做的修改能立即体现所有实例中:

    function Person(name, age, job) {
      this.name = name;
      this.age = age;
      this.job = job;
      this.lessons = ['Math', 'Physics'];
    }
    if (typeof this.getName != 'function') {//通过判断实例封装
      Person.prototype = {
        constructor: Person,//原型字面量方式会将对象的constructor变为Object,此外强制指回Person
        getName: function () {
          return this.name;
        }
      }
    }
    var person1 = new Person('Jack', 19, 'SoftWare Engneer');
    person1.lessons.push('Biology');
    var person2 = new Person('Lily', 39, 'Mechanical Engneer');
    alert(person1.lessons);//Math,Physics,Biology
    alert(person2.lessons);//Math,Physics
    alert(person1.getName === person2.getName);//true,//共享原型中定义方法

    注:以上内容参考《JavaScript 高级程序设计》第3版

    上一篇:C++数据抽象和问题求解  下一篇:HTML5 APP开发从入门到精通

    展开 +

    收起 -

    程序设计相关电子书
    学习笔记
    网友NO.552993

    Python面向对象程序设计OOP深入分析【构造函数,组合类,工具类等】

    本文深入分析了Python面向对象程序设计OOP。分享给大家供大家参考,具体如下: 下面是一个关于OOP的实例,模块文件为person.py # File person.py(start)class Person: def __init__(self, name, job=None, pay=0): self.name = name self.job = job self.pay = pay def last_name(self): return self.name.split()[-1] def give_raise(self, percent): self.pay = int(self.pay * (1+percent)) print('total percent:%f' % percent) def __str__(self): return '[Person: %s, %s]' % (self.name, self.pay)class Manager(Person): # 这是一种不太好的方法重载的方法,实际应用中我们采用下面的方法 def give_raise(self, percent, bonus=.1): self.pay = int(self.pay * (1+percent+bonus)) # 这个方法利用了这样的一个事实:类方法总是可以在一个实例中调用。 # 其实常规的实例调用,也是转换为类的调用 # instance.method(args...) 由Python自动地转换为 class.method(instance,args...) # 所以要记得直接通过类进行调用时,必须手动传递实例,这里就是self参数 # 而且不能写成self.give_raise,这样会导致循环调用 # # 那么为什么采用这种形式呢?因为它对未来的代码的维护意义重大,因为give_raise现在 # 只在一个地方,即Person的方法,将来需要修改的时候,我们只需要修改一个版本 def give_raise(self, percent, bonus=.1): Person.give_raise(self, percent+bonus)if __name__ == '__main__': # self-test code bob = Person('Bob Smith'……

    网友NO.409649

    Python面向对象程序设计多继承和多态用法示例

    本文实例讲述了Python面向对象程序设计多继承和多态用法。分享给大家供大家参考,具体如下: 多继承 就是一个子类继承多个父类: 多继承的例子,如下: # -*- coding:utf-8 -*-#! python3class Base(object): def test(self): print("------base")class A(Base): def test1(self): print("-----test1")class B(Base): def test2(self): print("----test2")class C(A,B): passc=C()c.test1()c.test2()c.test() 运行结果: -----test1 ----test2 ------base C也能继承Base 注:多继承中,每个父类都有相同的方法,子类继承时,会有一个继承顺序 想要查看该顺序的调用流程可以使用以下方法: 最后调用的是object方法,如果object方法也不存在,说明类中没有这个方法 print(子类类名.__mro__) # -*- coding:utf-8 -*-#! python3class Base(object): def test(self): print("-----Base")class A(Base): def test(self): print("----A")class B(Base): def test(self): print("----B")class C(A,B): def test(self): print("-----C")c=C()c.test() 运行结果: -----C 多态 什么是多态: 定义时的类型和运行时的类型不一样,也就是定义时并不确定要调用的是哪个方法,只有运行的时候才能确定调用的是哪个 # -*- coding:utf-8 -*-#! python3class Dog(object): def print_self(self): print("父类")class Xiaotq(Dog): def print_self(self): print("子类")def introduce(temp): temp.print_self()dog1=Dog()dog2=Xiaotq()introduce(dog1)introduce(dog2) 运行结果: 父……

    网友NO.433709

    Python面向对象程序设计类的封装与继承用法示例

    本文实例讲述了Python面向对象程序设计类的封装与继承用法。分享给大家供大家参考,具体如下: 访问限制(封装) 1、概念 面向对象语言的三大特征:封装, 继承, 多态。 广义的封装: 类和函数的定义本身就是封装的体现。 狭义的封装 :一个类的某些属性,不希望外界直接访问,而是把这个属性私有化[只有当前类持有],然后暴露给外界一个访问的方法。 封装的本质:就是属性私有化的过程。 封装的好处:提供了数据的复用性,保证了数据的安全性。 举例:插排 2、使用 class Person(object): def __init__(self, name, age, height, weight, money): self.name = name self.__age__ = age self.weight = weight self.__money = money self.__height = height def run(self): print(self.__money) def eat(self): print("eat") # 通过内部方法,去修改、获取私有属性 # 通过自定义的方法实现对私有属性的赋值与取值 # set方法:setxxx def setMoney(self, money): # 数据的过滤 if money 0: money = 0 self.__money = money # get方法:getXXX def getMoney(self): return self.__moneyper = Person("hanmeimei", 20, 170, 55, 10000)# 1.属性被私有化之后的访问# 如果要让内部属性不被外部直接访问,在属性前加两个下划线(__),# 在python中如果在属性前面加两个下划线,name这个属性就变成了私有属性[private]# 私有属性的含义:在外界不能像以前那么直接访问# print(per.__money) #无法……

    网友NO.754537

    小程序click-scroll组件设计

    一. 背景 有些业务需求,要求前端展示的内容多时可以通过scroll的形式拖拉查看,但是太多的滚动条又造成页面太乱,于是封装了这个click-scroll 组件。在组件上设定好展示的位置和空间大小,在组件内部放置实际要展示的内容,实际展示的内容宽度或长或短都由此组件来控制。 二. 功能 组件内的内容宽度超过组件宽度时,组件两侧会自动出现『左右移动』交互。 当内部展示的内容超过组件的可见区域时,可以在组件的可见区域单击拖动查看内容 三. 背景知识,元素大小的测量 1.偏移量(offset dimension): 元素在屏幕上占用的可见的所有空间,元素的可见大小由其高度、宽度决定,包括所有内边距、滚动条和边框大小。由四个值决定:offsetHeight、offsetWidth、offsetLeft和offsetRight。 offsetHeight:元素在垂直方向上占用的空间大小,以像素计。包括元素的高度、(可见)水平滚动条的高度、上边框高度和下边框高度。 offsetWidth:元素在水平方向上占用的空间大小,以像素计。包括元素的宽度、(可见)垂直滚动条的宽度、左边框宽度和右边框宽度。 offsetLeft:元素的左外边框至包含元素的左内边框之间的像素距离。 d. offsetTop:元素的上外边框至包含元素的上内边框之间的像素距离。 2.客户区大小(client dimension) 元素内容及其内边……

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明