数组.rar资源-CSDN文库

共20个文件

html：10个

js：7个

md：3个

需积分: 10 24 浏览量 2022-04-14 08:11:47 上传评论收藏 22KB RAR 举报

数组是计算机科学中基本且重要的数据结构之一，它在编程中扮演着不可或缺的角色。数组可以被看作是存储相同类型元素的固定大小的线性集合。这个“.”rar”文件很可能是包含了一些关于数组的详细讲解、示例代码或者练习题，尽管没有具体的标签来指导我们，但我们可以从数组的基本概念出发，深入探讨其重要特性、操作以及在不同编程语言中的应用。 1. **数组定义**：数组是一组具有相同数据类型的元素集合，它们在内存中连续存储，通过一个唯一的索引来访问每个元素。索引通常从0开始，使得第一个元素的索引为0，最后一个元素的索引为数组长度减1。 2. **数组类型**：在编程中，数组有多种类型，包括一维数组、二维数组（矩阵）、多维数组以及动态数组。一维数组类似于一条直线，二维数组则类似于表格，多维数组可以扩展到三维甚至更高维度。 3. **数组操作**： - **初始化**：创建数组时，可以预设所有元素的值或仅指定部分。 - **访问元素**：通过索引访问数组中的特定元素，如`arr[index]`。 - **修改元素**：同样通过索引对元素进行修改，如`arr[index] = newValue`。 - **遍历数组**：循环遍历数组，常用for循环或foreach循环实现。 - **数组长度**：获取数组的长度，通常用`length`属性。 4. **数组的优缺点**：优点：快速访问（通过索引），高效，占用连续内存空间利于缓存优化。缺点：大小固定，插入和删除元素效率低，因为可能需要移动大量元素。 5. **动态数组**：某些编程语言（如C++的`std::vector`，Java的`ArrayList`，Python的`list`）提供了动态数组，允许在运行时改变数组的大小。它们内部使用了动态内存分配，可以在需要时自动扩展。 6. **数组在不同编程语言中的实现**： - **C/C++**：使用`int arr[10]`声明固定大小的数组，`malloc`或`calloc`动态分配内存。 - **Java**：`int[] arr = new int[10]`创建数组，`ArrayList`提供动态数组功能。 - **Python**：`arr = [1, 2, 3]`创建列表，相当于动态数组。 - **JavaScript**：`let arr = [1, 2, 3]`创建数组，支持多种方法如`push`、`pop`等操作。 7. **数组的高级话题**： - **数组排序**：常见的排序算法如冒泡排序、选择排序、插入排序、快速排序、归并排序等。 - **数组的查找**：线性查找、二分查找等。 - **数组在数据结构与算法中的应用**：栈、队列、哈希表、图、树等复杂数据结构的基础。在学习数组时，理解这些基本概念和操作是至关重要的，同时，通过实践编写代码和解决实际问题，可以更好地掌握数组的使用。如果"数组.rar"文件包含了练习题，那么解决这些问题将有助于巩固理论知识，并提高编程技能。

展开

资源详情

资源评论

资源推荐

收起资源包目录

数组.rar （20个子文件）

数组

逻辑题1.html 1KB

玩转数组2.js 574B

玩转数组4.js 405B

玩转数组6.js 457B

逻辑题2.html 1KB

玩转数组5.js 459B

promise.html 1KB

hh.html 2KB

promise.js 5KB

数组扁平化.html 5KB

数据太多，出现卡顿解决方法.html 0B

树形结构扁平化.html 0B

js基础讲义.md 20KB

Git(1).md 2KB

字节.html 1KB

Git.md 2KB

玩转数组1.js 594B

测试.html 5KB

玩转数组3.js 371B

打印.html 2KB

      <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
         
			let colors = [{
					id: 1,
					colorName: 'red'
				},
				{
					id: 1,
					colorName: "orange"
				},
				{
					id: 2,
					colorName: "yellow"
				},
				{
					id: 3,
					colorName: "green"
				},
				{
					id: 1,
					colorName: "blue"
				},
				{
					id: 2,
					colorName: "purple"
				},
			];

            let obj = {};
			colors = colors.reduce((cur, next) => {
				obj[next.id] ? "" : cur.push(next);
                //obj对象里面存不存在遍历的元素或者是元素的id？如果存在，当前的元素就为空，
                // 如果不存在，当前的元素或者元素的值赋值为true,添加到数组看里面,下个相同元素的值的判断为true，走""，
                
				return cur;
			}, []) //设置cur默认类型为数组，并且初始值为空的数组
			console.log(colors)
            

      

//               class Person {
//                 constructor(name, age) {
//                     this.name = name;
//                     this.age = age;
//                 }
//                 study() {
//                     console.log(this);
//                 }
//             }
//             const p1 = new Person();
//             p1.study();
//             const x = p1.study;
//             x();
    

 

    // let NewArr2= arr.map((item,index1,Arry)=>{
        
    //     return   Arry.filter((item2,index2,Arry)=>item.id===item2.pid)
    //      })
  
    // **6. 如何把数组转成树形化结构**

// js
// 把pid等于id的数组项,放入id的children里
// const data = [{
//   name: 'xiaoba',
//   id: 0
// }, {
//     name: 'zhangsan',
//     id: 1,
//     pid: 0
// },{
//     name: 'lisi',
//     id: 2,
//     pid: 1
// },{
//     name: 'wangwu',
//     pid: 2,
//     id: 3
// },{
//     name: 'zhaoliu',
//     pid: 0,
//     id: 4
// },{
//     name: 'chenqi',
//     pid: 3,
//     id: 5
// }];
//  方案1
// function arrToTree(data) {
//   // 遍历两次数组,第一次遍历是拿到每一项itemp,
//   return data.filter(itemp => {
//     // 第二次遍历是为了找到itemp的children
//     itemp.chilren = data.filter(itemc => {
//       return itemp.id === itemc.pid;
//     });
//     return itemp.id ;
//   });
// }
// console.log(arrToTree(data))
// 方案2
// function arrToTree(data) {
//   const res = [],
//         map = new Map();
//   data.forEach(item => {
//     // 第一次遍历是为了让id和item对应
//     map.set(item.id, item);
//   });
//   data.forEach(item => {
//     // 第二次遍历,如果item.pid在map中有值,则证明找到了这个item的parent
//     const parent = map.get(item.pid);
//     if (parent) {
//       (parent.children || (parent.children = [])).push(item);
//       return;
//     }
//     // 没有找到这个item的parent,则证明这个item是最顶级
//     res.push(item);
//   });
//   return res;
// }

// // 方案3
// function arrToTree(data) {
//   // 找到最顶级parent
//   const parent = data.filter(item => item.id === 0);
//   const children = data.filter(item => item.id !== 0);
//   function toTree(parent, children) {
//     parent.forEach(itemp => {
//       children.forEach((itemc, i) => {
//         if (itemp.id === itemc.pid) {
//           (itemp.children || (itemp.children = [])).push(itemc);
//         }
//         const copyChildren = JSON.parse(JSON.stringify(children));
//         // 去除children的这项
//         copyChildren.splice(i, 1);
//         // 再递归遍历children
//         toTree([itemc], copyChildren);
//       });
//     })
//     return parent;
//   }
//   return toTree(parent, children);
// }

// function arrToTree(data) {
//   const res = [],
//         map = new Map();
//   data.forEach(item => {
//     // 第一次遍历是为了让id和item对应
//     map.set(item.id, item);
//   });
//   data.forEach(item => {
//     // 第二次遍历,如果item.pid在map中有值,则证明找到了这个item的parent
//     const parent = map.get(item.pid);
//     if (parent) {
//       (parent.children || (parent.children = [])).push(item);
  

 


// console.log(NewArr2)
// console.log(arr)
    //   arr = [
    //     { id: 0, pid: '' },
    //     {
    //       id: 1,
    //       pid: '',
    //       children: [
    //         {
    //           id: 3,
    //           pid: 1,
    //           children: [
    //             { id: 6, pid: 3 },
    //             { id: 7, pid: 3 }
    //           ]
    //         },
    //         { id: 4, pid: 1 },
    //         { id: 5, pid: 1 }
    //       ]
    //     },
    //     { id: 2, pid: '' }
    //   ]
    </script>
</body>
</html>