javascript数据结构与算法--基本排序算法（冒泡、选择、排序）及效率比较

一、数组测试平台。

javascript数据结构与算法--基本排序（封装基本数组的操作），封装常规数组操作的函数，比如：插入新数据，显示数组数据，还有交换数组元素等操作来调用不同的排序算法

  1. function CArray(numElements) {
  2.     this.dataStore = [];
  3.     this.pos = 0;//是一个索引值，默认为0，从第一个开始
  4.     this.numElements = numElements;//是保存所有的数组元素
  5.     this.insert = insert;//向数组中插入一个元素的方法
  6.     this.toString = toString;//显示数组中所有元素
  7.     this.clear = clear;//清空数组数据
  8.     this.setData = setData;//生成了存储在数组中的随机数字
  9.     this.swap = swap;//交换数组中两个元素的位置
  10.     this.bubbleSort = bubbleSort;
  11.     /*将传入的数组，存储在datastore中*/
  12.     for (var i = 0; i < numElements.length; ++i) {
  13.         this.dataStore[i] = numElements[i];
  14.     }
  15. }
  16.  
  17. function setData() {
  18.     for (var i = 0; i < this.numElements; ++i) {
  19.         this.dataStore[i] = Math.floor(Math.random() *
  20.             (this.numElements+1));
  21.     }
  22. }
  23.  
  24. function clear() {
  25.     for (var i = 0; i < this.dataStore.length; ++i) {
  26.         this.dataStore[i] = 0;
  27.     }
  28. }
  29.  
  30. function insert(element) {
  31.     this.dataStore[this.pos++] = element;
  32. }
  33.  
  34. function toString() {
  35.     var retstr = "";
  36.     for (var i = 0; i < this.dataStore.length; ++i) {
  37.         retstr += this.dataStore[i] + " ";
  38.         if (i > 0 && i % 10 == 0) {
  39.             retstr += "\n";
  40.         }
  41.     }
  42.     return retstr;
  43. }
  44.  
  45. function swap(arr, index1, index2) {
  46.     var temp = arr[index1];
  47.     arr[index1] = arr[index2];
  48.     arr[index2] = temp;
  49. }
  50. //测试生成一组数组数据（随机数）
  51. var numElements = 100;
  52. var myNums = new CArray(numElements);
  53. myNums.setData();
  54. console.log(myNums.toString());
  1. 17 94 81 80 25 24 73 76 24 35 81
  2. 63 81 59 4 76 30 47 73 98 18
  3. 54 36 53 47 22 60 88 41 66 24
  4. 73 94 40 45 72 74 14 61 92 48
  5. 36 12 42 11 12 82 24 84 60 1
  6. 17 98 63 36 84 13 18 50 89 26
  7. 98 1 6 54 52 69 6 52 98 14
  8. 79 28 19 69 76 99 97 100 10 7
  9. 24 54 81 73 18 21 45 73 66 30
  10. 28 56 54 21 88 31 20 86 48

二、冒泡排序算法

我们先来了解一下冒泡排序算法，它是最慢的排序算法之一，但也是一种最容易实现的排序算法。
之所以叫冒泡排序是因为使用这种排序算法排序时，数据值会像气泡一样从数组的一端漂浮到另一端。
假设正在将一组数字按照升序排列，较大的值会浮动到数组的右侧，而较小的值则会浮动到数组的左侧。
之所以会产生这种现象是因为算法会多次在数组中移动，比较相邻的数据，当左侧值大于右侧值时将它们进行互换。

JS代码如下：

  1. function CArray(numElements) {
  2.     this.dataStore = [];
  3.     this.pos = 0;//是一个索引值，默认为0，从第一个开始
  4.     this.numElements = numElements;//是保存所有的数组元素
  5.     this.insert = insert;//向数组中插入一个元素的方法
  6.     this.toString = toString;//显示数组中所有元素
  7.     this.clear = clear;//清空数组数据
  8.     this.setData = setData;//生成了存储在数组中的随机数字
  9.     this.swap = swap;//交换数组中两个元素的位置
  10.     this.bubbleSort = bubbleSort;//冒泡算法
  11.     /*将传入的数组，存储在datastore中*/
  12.     for (var i = 0; i < numElements.length; ++i) {
  13.         this.dataStore[i] = numElements[i];
  14.     }
  15. }
  16.  
  17. function setData() {
  18.     for (var i = 0; i < this.numElements; ++i) {
  19.         this.dataStore[i] = Math.floor(Math.random() *
  20.             (this.numElements+1));
  21.     }
  22. }
  23.  
  24. function clear() {
  25.     for (var i = 0; i < this.dataStore.length; ++i) {
  26.         this.dataStore[i] = 0;
  27.     }
  28. }
  29.  
  30. function insert(element) {
  31.     this.dataStore[this.pos++] = element;
  32. }
  33.  
  34. function toString() {
  35.     var retstr = "";
  36.     for (var i = 0; i < this.dataStore.length; ++i) {
  37.         retstr += this.dataStore[i] + " ";
  38.         if (i > 0 && i % 10 == 0) {
  39.             retstr += "\n";
  40.         }
  41.     }
  42.     return retstr;
  43. }
  44.  
  45. function swap(arr, index1, index2) {
  46.     var temp = arr[index1];
  47.     arr[index1] = arr[index2];
  48.     arr[index2] = temp;
  49. }
  50.  
  51. function bubbleSort() {
  52.     var numElements = this.dataStore.length;
  53.     for (var outer = numElements; outer >= 2; --outer) {
  54.         for (var inner = 0; inner <= outer-1; ++inner) {
  55.             if (this.dataStore[inner] > this.dataStore[inner+1]) {
  56.                 swap(this.dataStore, inner, inner+1);
  57.             }
  58.         }
  59.         console.log("outer为" + outer + ": " +  this.toString());
  60.     }
  61. }
  62.  
  63. //测试冒泡排序算法
  64. var numElements = [2,4,1,3];
  65. var myNums = new CArray(numElements);
  66. console.log("原来的数组："+myNums.toString());
  67. myNums.bubbleSort();
  68. console.log("排序后的数组："+myNums.toString());
  1. 冒泡算法代码分析如下：
  2.  
  3. 原先数组为 [2,4,1,3];
  4.  
  5. 1. outer为4的时候
  6.     1. inner为0，值为2，inner+1为1，值为4，不符合，不交换。
  7.     2. inner为1，值为4，inner+1为2，值为1，交换，数组变为[2,1,4,3]
  8.     3. inner为2，值为4，inner+1为3，值为3，交换 数组变为[2,1,3,4]
  9.     4. inner为3，值为4，inner+1为4，不符合 不交换。 
  10.  
  11. 2. outer为3的时候
  12.     1. inner为0，值为2，inner+1为1，值为1,交换 数组变为[1,2,3,4]
  13.     2. inner为1, 值为2，inner+1为2，值为3 不符合 不交换。
  14.     3. inner为2, 值为3，inner+1为3，值为4，不符合 不交换。
  15.  
  16.  再下面继续循环都不符合条件，所以如上就是最后一步了。这就是冒泡排序。

三、选择排序算法

选择排序从数组的开头开始，将第一个元素和其他元素进行比较。
检查完所有元素后，最小的元素会被放到数组的第一个位置，然后算法会从第二个位置继续。
这个过程一直进行，当进行到数组的倒数第二个位置时，所有的数据便完成了排序。

选择排序会用到嵌套循环。
外循环从数组的第一个元素移动到倒数第二个元素；
内循环从第二个数组元素移动到最后一个元素，查找比当前外循环所指向的元素小的元素。
每次内循环迭代后，数组中最小的值都会被赋值到合适的位置。

JS代码如下：

  1. function CArray(numElements) {
  2.     this.dataStore = [];
  3.     this.pos = 0;//是一个索引值，默认为0，从第一个开始
  4.     this.numElements = numElements;//是保存所有的数组元素
  5.     this.insert = insert;//向数组中插入一个元素的方法
  6.     this.toString = toString;//显示数组中所有元素
  7.     this.clear = clear;//清空数组数据
  8.     this.setData = setData;//生成了存储在数组中的随机数字
  9.     this.swap = swap;//交换数组中两个元素的位置
  10.     this.selectionSort = selectionSort;//选择排序算法
  11.     /*将传入的数组，存储在datastore中*/
  12.     for (var i = 0; i < numElements.length; ++i) {
  13.         this.dataStore[i] = numElements[i];
  14.     }
  15. }
  16.  
  17. function setData() {
  18.     for (var i = 0; i < this.numElements; ++i) {
  19.         this.dataStore[i] = Math.floor(Math.random() *
  20.             (this.numElements+1));
  21.     }
  22. }
  23.  
  24. function clear() {
  25.     for (var i = 0; i < this.dataStore.length; ++i) {
  26.         this.dataStore[i] = 0;
  27.     }
  28. }
  29.  
  30. function insert(element) {
  31.     this.dataStore[this.pos++] = element;
  32. }
  33.  
  34. function toString() {
  35.     var retstr = "";
  36.     for (var i = 0; i < this.dataStore.length; ++i) {
  37.         retstr += this.dataStore[i] + " ";
  38.         if (i > 0 && i % 10 == 0) {
  39.             retstr += "\n";
  40.         }
  41.     }
  42.     return retstr;
  43. }
  44.  
  45. function swap(arr, index1, index2) {
  46.     var temp = arr[index1];
  47.     arr[index1] = arr[index2];
  48.     arr[index2] = temp;
  49. }
  50.  
  51. function selectionSort() {
  52.     var min, temp;
  53.     for (var outer = 0; outer <= this.dataStore.length-2; ++outer) {
  54.         min = outer;
  55.         for (var inner = outer + 1;inner <= this.dataStore.length-1; ++inner) {
  56.             if (this.dataStore[inner] < this.dataStore[min]) {
  57.                 min = inner;
  58.             }
  59.         }
  60.         swap(this.dataStore, outer, min);
  61.         console.log("第"+outer +"次："+myNums.toString());
  62.     }
  63. }
  64.  
  65. //测试排序算法
  66. var numElements = [2,4,1,3];
  67. var myNums = new CArray(numElements);
  68. console.log("原来的数组："+myNums.toString());
  69. myNums.selectionSort();
  70. console.log("排序后的数组："+myNums.toString());
  1. 原来的数组： 4 1 3
  2. 第0次：1  2 3
  3. 第1次：1 2  3
  4. 第2次：1 2 3 4
  5. 排序后的数组：1 2 3 4

四、插入排序算法

插入排序有两个循环。
外循环将数组元素挨个移动，而内循环则对外循环中选中的元素及它前面的那个元素进行比较。
如果外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置

  1. function CArray(numElements) {
  2.     this.dataStore = [];
  3.     this.pos = 0;//是一个索引值，默认为0，从第一个开始
  4.     this.numElements = numElements;//是保存所有的数组元素
  5.     this.insert = insert;//向数组中插入一个元素的方法
  6.     this.toString = toString;//显示数组中所有元素
  7.     this.clear = clear;//清空数组数据
  8.     this.setData = setData;//生成了存储在数组中的随机数字
  9.     this.swap = swap;//交换数组中两个元素的位置
  10.     this.insertionSort = insertionSort;//插入排序算法
  11.     /*将传入的数组，存储在datastore中*/
  12.     for (var i = 0; i < numElements.length; ++i) {
  13.         this.dataStore[i] = numElements[i];
  14.     }
  15. }
  16.  
  17. function setData() {
  18.     for (var i = 0; i < this.numElements; ++i) {
  19.         this.dataStore[i] = Math.floor(Math.random() *
  20.             (this.numElements+1));
  21.     }
  22. }
  23.  
  24. function clear() {
  25.     for (var i = 0; i < this.dataStore.length; ++i) {
  26.         this.dataStore[i] = 0;
  27.     }
  28. }
  29.  
  30. function insert(element) {
  31.     this.dataStore[this.pos++] = element;
  32. }
  33.  
  34. function toString() {
  35.     var retstr = "";
  36.     for (var i = 0; i < this.dataStore.length; ++i) {
  37.         retstr += this.dataStore[i] + " ";
  38.         if (i > 0 && i % 10 == 0) {
  39.             retstr += "\n";
  40.         }
  41.     }
  42.     return retstr;
  43. }
  44.  
  45. function swap(arr, index1, index2) {
  46.     var temp = arr[index1];
  47.     arr[index1] = arr[index2];
  48.     arr[index2] = temp;
  49. }
  50.  
  51. function insertionSort() {
  52.     var temp, inner;
  53.     //外循环将数组元素挨个移动
  54.     for (var outer = 1; outer <= this.dataStore.length-1; ++outer) {
  55.         temp = this.dataStore[outer];//外循环选中的元素temp
  56.         inner = outer;
  57.         //内循环对外循环中选中的元素temp与temp前面的元素一个个进行比较。
  58.         //如果外循环中选中的元素temp比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置
  59.         while (inner > 0 && (this.dataStore[inner-1] >= temp)) {
  60.             this.dataStore[inner] = this.dataStore[inner-1];
  61.             --inner;
  62.         }
  63.         this.dataStore[inner] = temp;
  64.         console.log("第"+outer+"次："+myNums.toString());
  65.     }
  66. }
  67.  
  68. //测试排序算法
  69. var numElements = [9,1,8,6,2,3,5,4];
  70. var myNums = new CArray(numElements);
  71. console.log("原来的数组："+myNums.toString());
  72. myNums.insertionSort();
  73. console.log("排序后的数组："+myNums.toString());
  1.   原来的数组：9  8 6 2 3 5 4 //先用1和1前面的对比，9比1大，所以9向右移动一个位置，给1腾位置
  2.       第1次：1 9  6 2 3 5 4 //用8与8前面的对比，9比8大，所以9向右移动一个位置，给8腾位置
  3.       第2次：1 8 9  2 3 5 4 //用6与6前面的对比,8，9比6大，所以8、9向右移动一个位置，给6腾位置
  4.       第3次：1 6 8 9  3 5 4
  5.       第4次：1 2 6 8 9  5 4
  6.       第5次：1 2 3 6 8 9  4
  7.       第6次：1 2 3 5 6 8 9
  8.       第7次：1 2 3 4 5 6 8 9 
    排序后的数组：1 2 3 4 5 6 8 9

五、基本排序算法的效率比较

  1. function CArray(numElements) {
  2.     this.dataStore = [];
  3.     this.pos = 0;//是一个索引值，默认为0，从第一个开始
  4.     this.numElements = numElements;//是保存所有的数组元素
  5.     this.insert = insert;//向数组中插入一个元素的方法
  6.     this.toString = toString;//显示数组中所有元素
  7.     this.clear = clear;//清空数组数据
  8.     this.setData = setData;//生成了存储在数组中的随机数字
  9.     this.swap = swap;//交换数组中两个元素的位置
  10.     this.bubbleSort = bubbleSort;//冒泡排序算法
  11.     this.selectionSort = selectionSort;//选择排序算法
  12.     this.insertionSort = insertionSort;//插入排序算法
  13.     /*将传入的数组，存储在datastore中*/
  14.     for (var i = 0; i < numElements.length; ++i) {
  15.         this.dataStore[i] = numElements[i];
  16.     }
  17. }
  18.  
  19. function setData() {
  20.     for (var i = 0; i < this.numElements; ++i) {
  21.         this.dataStore[i] = Math.floor(Math.random() *
  22.             (this.numElements+1));
  23.     }
  24. }
  25.  
  26. function clear() {
  27.     for (var i = 0; i < this.dataStore.length; ++i) {
  28.         this.dataStore[i] = 0;
  29.     }
  30. }
  31.  
  32. function insert(element) {
  33.     this.dataStore[this.pos++] = element;
  34. }
  35.  
  36. function toString() {
  37.     var retstr = "";
  38.     for (var i = 0; i < this.dataStore.length; ++i) {
  39.         retstr += this.dataStore[i] + " ";
  40.         if (i > 0 && i % 10 == 0) {
  41.             retstr += "\n";
  42.         }
  43.     }
  44.     return retstr;
  45. }
  46.  
  47. function swap(arr, index1, index2) {
  48.     var temp = arr[index1];
  49.     arr[index1] = arr[index2];
  50.     arr[index2] = temp;
  51. }
  52.  
  53. function bubbleSort() {
  54.     var numElements = this.dataStore.length;
  55.     for (var outer = numElements; outer >= 2; --outer) {
  56.         for (var inner = 0; inner <= outer-1; ++inner) {
  57.             if (this.dataStore[inner] > this.dataStore[inner+1]) {
  58.                 swap(this.dataStore, inner, inner+1);
  59.             }
  60.         }
  61. //        console.log("outer为" + outer + ": " +  this.toString());
  62.     }
  63. }
  64.  
  65. function selectionSort() {
  66.     var min, temp;
  67.     for (var outer = 0; outer <= this.dataStore.length-2; ++outer) {
  68.         min = outer;
  69.         for (var inner = outer + 1;inner <= this.dataStore.length-1; ++inner) {
  70.             if (this.dataStore[inner] < this.dataStore[min]) {
  71.                 min = inner;
  72.             }
  73.         }
  74.         swap(this.dataStore, outer, min);
  75. //        console.log("第"+outer +"次："+this.toString());
  76.     }
  77. }
  78.  
  79. function insertionSort() {
  80.     var temp, inner;
  81.     //外循环将数组元素挨个移动
  82.     for (var outer = 1; outer <= this.dataStore.length-1; ++outer) {
  83.         temp = this.dataStore[outer];//外循环选中的元素
  84.         inner = outer;
  85.         //内循环则对外循环中选中的元素与它前面的那个元素进行比较。
  86.         //如果外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置
  87.         while (inner > 0 && (this.dataStore[inner-1] >= temp)) {
  88.             this.dataStore[inner] = this.dataStore[inner-1];
  89.             --inner;
  90.         }
  91.         this.dataStore[inner] = temp;
  92. //        console.log("第"+outer+"次："+this.toString());
  93.     }
  94. }
  95.  
  96. /*测试冒泡、选择、插入算法的效率*/
  97. var numElements = 10000;
  98. var nums = new CArray(numElements);
  99. nums.setData();
  100. var start = new Date().getTime();
  101. nums.bubbleSort();
  102. var stop = new Date().getTime();
  103. var elapsed = stop - start;
  104. console.log("用冒泡算法，排序 " + numElements + " 个元素耗时 : " + elapsed + " milliseconds.");
  105.  
  106. start = new Date().getTime();
  107. nums.selectionSort();
  108. stop = new Date().getTime();
  109. elapsed = stop - start;
  110. console.log("用选择算法，排序 " + numElements + " 个元素耗时: " +  elapsed + " milliseconds.");
  111.  
  112. start = new Date().getTime();
  113. nums.insertionSort();
  114. stop = new Date().getTime();
  115. elapsed = stop - start;
  116. console.log("用插入算法，排序 " + numElements + " 个元素耗时: " + elapsed + " milliseconds.");

运行结果：

选择排序和插入排序要比冒泡排序快，插入排序是这三种算法中最快的。

 

javascript数据结构与算法--基本排序算法（冒泡、选择、排序）及效率比较的更多相关文章

  1. 《算法4》2.1 - 选择排序算法(Selection Sort), Python实现

    选择排序算法(Selection Sort)是排序算法的一种初级算法.虽然比较简单,但是基础,理解了有助于后面学习更高深算法,勿以勿小而不为. 排序算法的语言描述: 给定一组物体,根据他们的某种可量化 ...

  2. C语言排序算法之简单交换法排序，直接选择排序，冒泡排序

    C语言排序算法之简单交换法排序,直接选择排序,冒泡排序,最近考试要用到,网上也有很多例子,我觉得还是自己写的看得懂一些. 简单交换法排序 /*简单交换法排序 根据序列中两个记录键值的比较结果来对换这两 ...

  3. [Swift]八大排序算法（三）：选择排序 和 简单选择排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  4. 程序员必知的8大排序(二)-------简单选择排序，堆排序（java实现）

    程序员必知的8大排序(一)-------直接插入排序,希尔排序(java实现) 程序员必知的8大排序(二)-------简单选择排序,堆排序(java实现) 程序员必知的8大排序(三)-------冒 ...

  5. 归并排序 & 计数排序 & 基数排序 & 冒泡排序 & 选择排序 ----> 内部排序性能比较

    2.3 归并排序 接口定义: int merge(void* data, int esize, int lpos, int dpos, int rpos, int (*compare)(const v ...

  6. 牛客网Java刷题知识点之插入排序（直接插入排序和希尔排序）、选择排序（直接选择排序和堆排序）、冒泡排序、快速排序、归并排序和基数排序（博主推荐）

    不多说,直接上干货! 插入排序包括直接插入排序.希尔排序. 1.直接插入排序: 如何写成代码: 首先设定插入次数,即循环次数,for(int i=1;i<length;i++),1个数的那次不用 ...

  7. 基本的排序算法C++实现(插入排序，选择排序，冒泡排序，归并排序，快速排序，最大堆排序，希尔排序)

    博主欢迎转载,但请给出本文链接,我尊重你,你尊重我,谢谢~http://www.cnblogs.com/chenxiwenruo/p/8529525.html特别不喜欢那些随便转载别人的原创文章又不给 ...

  8. 【算法拾遗（java描写叙述）】--- 选择排序（直接选择排序、堆排序）

    选择排序的基本思想 每一趟从待排序的记录中选出关键字最小的记录,顺序放在已排好序的子文件的最后,知道所有记录排序完毕.主要有两种选择排序方法:直接选择排序(或称简单选择排序)和堆排序. 直接选择排序 ...

  9. java算法（一） 直接选择排序

    一.基本概念 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置(注:要把最大最小的元素和起始的元素交换), 然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾.以 ...

  10. 排序算法总结（三）选择排序【Select Sort】

    一.原理 选择排序的原理非常简单,就是选出最小(大)的数放在第一位,在剩下的数中,选出最小(大)的数,放在第二位......重复上述步骤,直到最后一个数. 二.过程 原始数据 第一次排序,选出最小的数 ...

随机推荐

  1. 20145226夏艺华 《Java程序设计》第8周学习总结

    教材学习内容总结 学习目标 了解NIO 会使用Channel.Buffer与NIO2 会使用日志API.国际化 会使用正则表达式 了解JDK8增强功能 第14章 NIO与NIO2 14.1 认识NIO ...

  2. 2018.10.16 NOIP模拟 长者（主席树+hash）

    传送门 考试的时候开始sb的以为需要可持久化trietrietrie树,发现建树时空都是O(n2)O(n^2)O(n2)的. 然后发现由于每次只从原来的字符串改一个字符. 因此直接主席树维护区间has ...

  3. 2018.09.17 bzoj1260: [CQOI2007]涂色paint（区间dp）

    传送门 区间dp简单题啊. 很显然用f[l][r]f[l][r]f[l][r]表示把区间[l,r][l,r][l,r]按要求染好的代价. 这样可以O(n)O(n)O(n)枚举断点转移了啊. 显然如果断 ...

  4. java常用设计模式一：单例模式

     1.饿汉式 package singleton.demo; /** * @author Administrator * @date 2019/01/07 */ public class Single ...

  5. git分支删除

    1.列出本地分支: git branch 2.删除本地分支: git branch -D BranchName 其中-D也可以是--delete,如: git branch --delete Bran ...

  6. 用Java操作数据库Datetime数据

    Date.Calendar.Timestamp的区别.相互转换与使用 1 Java.util.Date 包含年.月.日.时.分.秒信息. // String转换为Date String dateStr ...

  7. python 爬取网页内容

    #encoding:UTF-8 import urllib import urllib.request import bs4 from bs4 import BeautifulSoup as bs d ...

  8. MATLAB实现最优低通滤波器的函数

    MATLAB实现最优低通滤波器的函数 % Fs     --Data rate % Fpass  --pass band % Fstop  --Cutoff frequencies % Apass  ...

  9. python编码（五）

    说说区位码.GB2312.内码和代码页 目前Windows的内核已经采用Unicode编码,这样在内核上可以支持全世界所有的语言文字.但是由于现有的大量程序和文档都采用了某种特定语言的编码,例如GBK ...

  10. 自己动手绘制ToolBar

    VC MFC工具栏(CToolBar)控件 工具栏 工具栏控件在控件面板里没有对应的选项(图标),但有一个工具栏控件类CToolBar,所以我们如果要创建一个工具栏控件并显示在窗口里的话,只能用代码来 ...