算法基础之数组理论

最新推荐文章于 2022-07-18 14:55:28 发布
最新推荐文章于 2022-07-18 14:55:28 发布
阅读量171 收藏 1
点赞数
分类专栏： 算法基础 文章标签： 数据结构 算法 python 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Buluchacha/article/details/120015156
版权

算法基础之数组理论

1.前言

这是第一次写技术博客，打算是总结一遍数据结构与算法，并尽量结合Leetcode来提升自己，希望各位朋友多提意见！第一轮是基础总结，涵盖的数据结构和相关算法有数组、栈与队列、链表、递归、二叉树、二叉搜索树、堆、排序算法。

2.数组基础定义

官方定义：将元素顺序地存放在一块连续的存储区里，元素之间的顺序关系由它们的存储顺序自然表示。
一句话总结：将数据码成一排进行存放。
索引可以有语义，也可以没有语义
优点：快速查询 —> 最好应用于“索引有语义”的情况
注意：并不是所有有语义的索引都适用，比如身份证号（如13131413415153），不太适合开辟从0到这么大的数的空间，浪费！
Anyway，这里我们主要处理索引没语义的情况下数组的使用。

正式开始前，会先提前列出数组的特点如下：

  1. 占用一段连续的内存空间，支持随机（索引）访问，且时间复杂度为O(1)

  2. 添加元素时间复杂度：O(n)

  3. 删除元素时间复杂度：O(n)

3.数组增删改查

3.1基本功能

这里我们为了构造一个动态数组，定义了一个数组类（即Class Array），并根据不同需求构造不同功能。
这里值得注意的是capacity指的是数组最大容量，而size是数组有效元素的数目。

class Arr:
    def __init__(self, capacity=10):
        """
        构造函数
        :param capacity: 数组最大容量，不指定的话默认为10
        """
        self._capacity = capacity
        self._size = 0                                  # 数组有效元素的数目，初始化为0
        self._data = [None] * self._capacity    # 由于python的list是动态扩展的，而我们要实现底层具有固定容量、占用一段连续的内存空间的数组，所以用None来作为无效元素的标识
 
    def __getitem__(self, item):
        """让Arr类支持索引操作"""
        return self._data[item]
 
    def getSize(self):
        """返回数组有效元素的个数"""
        return self._size
 
    def getCapacity(self):
        """返回当前数组的容量"""
        return self._capacity
 
    def isEmpty(self):
        """判断当前数组是否为空"""
        return self._size == 0

3.2添加元素

一开始想怎么往数组最后加一个元素，实现如下：

def addLast(self, elem):
	if self._size == self._capacity:
	            raise Exception('illegal argument, failed array is already full')
	        self._data[self._size] = e
	        self._size += 1

但是能不能有一个add方法可以往数组中随意位置添加一个元素呢？思路：向数组中添加一个元素，注意数组占用的是一段连续的内存空间，所以在添加元素后，数组还是要保证这个特点的，因此需要将后面的元素都向后挪一个位置，而且要注意要先从尾部开始挪，防止元素之间的覆盖。

def add(self, index, elem):
        """
        时间复杂度：O(n)
        :param index:   添加的元素所在的索引
        :param elem:    所要添加的元素
        """
        if index < 0 or index > self._size:     # 插入的位置无效
            raise Exception('Add Filed. Require 0 <= index <= self._size')
        if self._size == self._capacity:        # 满了
            raise Exception('illegal argument, failed array is already full')
        for i in range(self._size - 1, index - 1, -1):  # 从尾部开始挪动元素，在index处腾出一个空间
                                                        # 一定要注意在步长为负数的情况下，区间是左开右闭区间，即(index, self._size - 1]，所以是index-1，与正常的左闭右开区间是相反的！
            self._data[i + 1] = self._data[i]
        self._data[index] = elem        # 将该位置赋值为elem
        self._size += 1                 # 数组有效元素数加1

接下来，addLast和addFirst方法就可以直接调用add方法了。

def addLast(self, elem):
        """
        向数组尾部添加元素
        时间复杂度：O(1)
        :param elem: 所要添加的元素
        """
        self.add(self._size, elem) # 直接调用add方法，注意不用再次判定合法性了，因为add函数中已经判断过了
def addFirst(self, elem):
        """
        想数组头部添加元素
        时间复杂度：O(n)
        :param elem: 所要添加的元素
        """
        self.add(0, elem)   # 同理直接调用add方法

3.3查询和修改元素

def get(self, index):
        """
        获得索引index处的元素
        时间复杂度：O(1)
        :param index: 数组索引
        :return:      数组索引处的值
        """
        if index < 0 or index >= self._size:        # 判断index的合法性
            raise Exception('Get failed. Index is illegal.')
        return self._data[index]
 
    def getFirst(self):
        """
        获得数组首位置元素的值
        :return: 首位置元素的值
        """
        return self.get(0)      # 直接调用get函数，安全可靠
 
    def getLast(self):
        """
        获得数组末尾元素的值
        :return: 末尾元素的值
        """
        return self.get(self._size - 1)  # 直接调用get函数，安全可靠
 
    def set(self, index, elem):
        """
        将索引为index的元素的值设为elem
        时间复杂度：O(1)
        :param index:  索引
        :param elem:   新的值
        """
        if index < 0 or index >= self._size:        # 判断index的合法性
            raise Exception('Sat failed. Index is illegal.')
        self._data[index] = elem

3.4包含、搜索和删除元素

这里讲一下删除的思路：删除索引为index的元素。index后面的元素都要向前移动一个位置

def contains(self, elem):
        """
        查看数组中是否存在元素elem，最好不要传入一个浮点数，你懂得。。
        时间复杂度：O(n)
        :param elem: 目标元素
        :return:     bool值，存在为真
        """
        for i in range(self._size):        # 遍历
            if self._data[i] == elem:
                return True                # 找到了就返回True
        return False                       # 遍历完了还没找到，就返回False
 
    def find(self, elem):
        """
        在数组中查找元素，并返回元素所在的索引。（如果数组中存在多个elem，只返回最左边elem的索引）
        时间复杂度：O(n)
        :param elem: 目标元素
        :return:     元素所在的索引，没找到则返回-1（无效值）
        """
        for i in range(self._size):         # 遍历数组
            if self._data[i] == elem:
                return i                    # 找到就返回索引
        return -1                           # 没找到返回-1
 
    def findAll(self, elem):
        """
        找到值为elem全部元素的索引
        :param elem: 目标元素
        :return:     一个列表，值为全部elem的索引
        """
        ret_list = Arr()                # 建立一个新的数组用于存储索引值
        for i in range(self._size):     # 遍历数组
            if self._data[i] == elem:
                ret_list.addLast(i)     # 找到就将索引添加进ret_list
        return ret_list
 
    def remove(self, index):
        """
        删除索引为index的元素。index后面的元素都要向前移动一个位置
        时间复杂度：O(n)
        :param index: 目标索引
        :return:      位于该索引的元素的值
        """
        if index < 0 or index >= self._size:    # index合法性检查
            raise Exception('Remove failed.Require 0 <= index < self._size')
        ret = self._data[index]                 # 拷贝一下index处的元素，便于返回
        for i in range(index + 1, self._size):  # index后面的元素都向前挪一个位置
            self._data[i - 1] = self._data[i]
        self._size -= 1         # 维护self._size
       
        return ret
 
    def removeFirst(self):
        """
        删除数组首位置的元素
        时间复杂度：O(n)
        :return: 数组首位置的元素
        """
        return self.remove(0)   # 调用remove函数
 
    def removeLast(self):
        """
        删除数组末尾的元素
        时间复杂度:O(1)
        :return: 数组末尾的元素
        """
        return self.remove(self._size - 1)      # 调用remove函数
 
    def removeElement(self, elem):
        """
        删除数组中为elem的元素，如果数组中不存在elem，那么什么都不做。如果存在多个相同的elem，只删除最左边的那个
        时间复杂度：O(n)
        :param elem: 要删除的目标元素
        """
        index = self.find(elem)         # 尝试找到目标元素（最左边的）的索引
        if index != -1:                 # elem在数组中就删除，否则什么都不做
            self.remove(index)          # 调用remove函数
 
    def removeAllElement(self, elem):
        """
        删除数组内所有值为elem的元素，可以用递归来写，这里用的迭代的方法。elem不存在就什么都不做
        :param elem: 要删除的目标元素
        """
        while True:
            index = self.find(elem)     # 循环来找elem，如果elem不存在就什么都不做，存在就继续删除
            if index != -1:             # 若存在
                self.remove(index)
            else:
                break

3.5其他

def get_Max_index(self):
        """
        获取数组中的最大元素的索引，返回最大元素的索引值，如果有多个最大值，默认返回最左边那个的索引
        时间复杂度：O(n)
        :return: 最大元素的索引
        """
        if self.isEmpty():
            raise Exception('Error, array is Empty!')
        max_elem_index = 0    # 记录最大值的索引，初始化为0 
        for i in range(1, self.getSize()):   # 从索引1开始遍历，一直到数组尾部
            if self._data[i] > self._data[max_elem_index]:   # 如果当前索引的值大于最大值索引处元素的值
                max_elem_index = i     # 更新max_elem_index，这样它还是当前最大值的索引
        return max_elem_index     # 遍历完后，将数组的最大值的索引返回
 
    def removeMax(self):
        """
        删除数组中的最大元素，返回最大元素的值，如果有多个最大值，默认值删除最左边那个
        时间复杂度：O(n)
        :return: 最大元素
        """
        return self.remove(self.get_Max_index())   # 直接调用remove函数删除最大值
 
    def get_Min_index(self):
        """
        获取数组中的最小元素的索引，返回最小元素的索引值，如果有多个最小值，默认返回最左边那个的索引
        时间复杂度：O(n)
        :return: 最小元素的索引
        """
        if self.isEmpty():
            raise Exception('Error, array is Empty!')
        min_elem_index = 0    # 记录最小值的索引，初始化为0 
        for i in range(1, self.getSize()):   # 从索引1开始遍历，一直到数组尾部
            if self._data[i] < self._data[min_elem_index]:   # 如果当前索引的值小于最小值索引处元素的值
                min_elem_index = i     # 更新min_elem_index，这样它还是当前最小值的索引
        return min_elem_index     # 遍历完后，将数组的最小值的索引返回
 
    def removeMin(self):
        """
        删除数组中的最小元素，返回最小元素的值，如果有多个最小值，默认值删除最左边那个
        时间复杂度：O(2n)，可以看成是O(n)的
        :return: 最小元素
        """
        return self.remove(self.get_Min_index())
 
    def swap(self, index1, index2):
        """
        交换分别位于索引index1和索引index2处的元素
        :param index1: 索引1
        :param index2: 索引2
        """ 
        if index1 < 0 or index2 < 0 or index1 >= self._size or index2 >= self._size:        # 合法性检查
            raise Exception('Index is illegal')
        self._data[index1], self._data[index2] = self._data[index2], self._data[index1]     # 交换元素
 
    def printArr(self):
        """对数组元素进行打印"""
        for i in range(self._size):
            print(self._data[i], end='  ')
        print('\nSize: %d-----Capacity: %d' % (self.getSize(), self.getCapacity()))

3.6检验

让我们写一段代码来试试我们的方法o不ok。

import numpy as np
np.random.seed(7)
test = Arr()
print(test.getSize())
print(test.getCapacity())
print(test.isEmpty())
for i in range(8):
    test.add(0, np.random.randint(5))
test.printArr()
test.addLast(2)
test.printArr()
print(test.get(3))
test.set(3, 10)
test.printArr()
print(test.contains(10))
print(test.find(4))
test.findAll(1).printArr()
test.remove(3)
test.printArr()
test.removeFirst()
test.removeLast()
test.printArr()
test.removeElement(4)
test.printArr()
test.removeAllElement(3)
test.printArr()
for i in range(30):
    test.addLast(np.random.randint(10))
test.printArr()
print(test[3])
test.swap(0, 1)
test.printArr()

结果如下：

0
10
True
1  0  1  4  3  3  1  4  
Size: 8-----Capacity: 10
1  0  1  4  3  3  1  4  2  
Size: 9-----Capacity: 10
4
1  0  1  10  3  3  1  4  2  
Size: 9-----Capacity: 10
True
7
0  2  6  
Size: 3-----Capacity: 10
1  0  1  3  3  1  4  2  
Size: 8-----Capacity: 10
0  1  3  3  1  4  
Size: 6-----Capacity: 10
0  1  3  3  1  
Size: 5-----Capacity: 10
0  1  1  
Size: 3-----Capacity: 10
0  1  1  8  7  6  4  0  7  0  7  6  3  5  8  8  7  5  0  0  2  8  9  6  4  9  7  3  3  8  3  0  1  
Size: 33-----Capacity: 40
8
1  0  1  8  7  6  4  0  7  0  7  6  3  5  8  8  7  5  0  0  2  8  9  6  4  9  7  3  3  8  3  0  1  
Size: 33-----Capacity: 40

应该是OK了吧。

4.动态数组及其时间复杂度

4.1动态数组的实现

如果已有的数组已经装满了，根据已有的方法，是会抛出异常的，所以我们的思路是：开辟一个两倍容量的数组（这样能保证扩容后的空间跟原来保持一个数量级，性能方面有好处），依次把原数组的数据复制到新数组（capacity加倍，size不变）。
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

# private
    def _resize(self, new_capacity):
        """
        数组容量放缩至new_capacity，私有成员函数
        :param new_capacity: 新的容量
        """
        new_arr = Arr(new_capacity)         # 建立一个新的数组new_arr，容量为new_capacity
        for i in range(self._size):
            new_arr.addLast(self._data[i])  # 将当前数组的元素按当前顺序全部移动到new_arr中
        self._capacity = new_capacity       # 数组容量变为new_capacity
        self._data = new_arr._data          # 将new_arr._data赋值给self._data，从而完成数组的容量放缩操作

那么接下来，我们可以回过头改写原来的add方法。

def add(self, index, elem):
        """
        向数组中添加一个元素，注意数组占用的是一段连续的内存空间，所以在添加元素后，数组还是要保证这个特点的，因此需要将后面的元素都向后挪一个位置，而且要注意要先从
        尾部开始挪，防止元素之间的覆盖
        时间复杂度：O(n)
        :param index:   添加的元素所在的索引
        :param elem:    所要添加的元素
        """
        if index < 0 or index > self._size:     # 插入的位置无效
            raise Exception('Add Filed. Require 0 <= index <= self._size')
        if self._size == self._capacity:        # 满了
            self._resize(self._capacity * 2)    # 默认扩容当前容量的二倍。容量翻倍要比容量加上一个固定值要好，这样做均摊复杂度为O(1)。具体请百度
 
        for i in range(self._size - 1, index - 1, -1):  # 从尾部开始挪动元素，在index处腾出一个空间
                                                        # 一定要注意在步长为负数的情况下，区间是左开右闭区间，即(index, self._size - 1]，所以是index-1，与正常的左闭右开区间是相反的！
            self._data[i + 1] = self._data[i]
        self._data[index] = elem        # 将该位置赋值为elem
        self._size += 1                 # 数组有效元素数加1

同理，当有效元素个数是总容量的1/2时，为了不浪费剩余容量，我们也可以将容量减少至一半，下面我们对remove方法动手：

def remove(self, index):
        """
        删除索引为index的元素。index后面的元素都要向前移动一个位置
        时间复杂度：O(n)
        :param index: 目标索引
        :return:      位于该索引的元素的值
        """
        if index < 0 or index >= self._size:    # index合法性检查
            raise Exception('Remove failed.Require 0 <= index < self._size')
        ret = self._data[index]                 # 拷贝一下index处的元素，便于返回
        for i in range(index + 1, self._size):  # index后面的元素都向前挪一个位置
            self._data[i - 1] = self._data[i]
        self._size -= 1         # 维护self._size
        self._data[self._size] = None   # 最后一个元素的垃圾回收
 
        if self._size and self._capacity // self._size == 2:   # 如果当前有效元素为总容量的二分之一且还存在有效元素，则将容量缩减为原来的一半
            self._resize(self._capacity // 2)
        return ret

此时，我们才算真正实现了动态数组！

4.2增删改查时间复杂度

But，我们开始考虑一下动态数组的时间复杂度。
注意：一般会考虑最坏情况。

  • 添加操作 ： O（n）
    在这里插入图片描述

  • 删除操作 ：O（n）
    在这里插入图片描述

  • 修改操作 ：
    在这里插入图片描述

  • 查询操作：
    在这里插入图片描述
    总结动态数组时间复杂度分析：
    在这里插入图片描述

4.3动态数组均摊复杂度

但这时候会想到，addLast方法是O（1），只有触发resize方法后才会变成O（n），可是并不适合什么时候都会触发resize来扩容的呀。举个如下例子：
在这里插入图片描述
9次addLast操作，触发resize，从而需要8次转移操作，总共进行了17次基本操作。因此平均每次addLast进行了2次基本操作。
推广开来，假设capacity=m,m+1次addLast操作，触发resize，从而需要m次转移操作，总共进行了2m+1次基本操作。因此平均每次addLast进行了2次基本操作。
所以，我们可以说addLast的均摊复杂度是O(1)，跟我们当前数组有多少个元素没关系。同理对于removeLast一样。
通俗来说，这样算均摊复杂度是比算最坏情况有意义的，因为最坏的情况不是每次都出现。实际考量中，如果一个相对比较耗时的操作（如这里resize）不是经常被触发，它的耗时可以被分摊到其他基本操作上的。

4.4复杂度震荡

这个时候我想到一个比较极端的情况，如果一个数组已经满了，再在尾部加一个元素，触发resize,从而复杂度是O（n），但接着我需要删掉刚刚的元素，这时容量变成原来一半了，又触发resize，从而复杂度又是O（n）。
在这里插入图片描述

可是我们前面才讲过addLast和removeLast的均摊复杂度是O（1）啊，究其原因，原来是我们其实减容减的太着急了。所以我们可以试着等有效元素个数是总容量的1/4时，再去减容。

def remove(self, index):
        """
        删除索引为index的元素。index后面的元素都要向前移动一个位置
        时间复杂度：O(n)
        :param index: 目标索引
        :return:      位于该索引的元素的值
        """
        if index < 0 or index >= self._size:    # index合法性检查
            raise Exception('Remove failed.Require 0 <= index < self._size')
        ret = self._data[index]                 # 拷贝一下index处的元素，便于返回
        for i in range(index + 1, self._size):  # index后面的元素都向前挪一个位置
            self._data[i - 1] = self._data[i]
        self._size -= 1         # 维护self._size
        self._data[self._size] = None   # 最后一个元素的垃圾回收
 
        if self._size and self._capacity // self._size == 4:   # 如果当前有效元素为总容量的四分之一且还存在有效元素，则将容量缩减为原来的一半
            self._resize(self._capacity // 2)
        return ret

5.Python列表与字典操作的时间复杂度

5.1列表操作时间复杂度

在这里插入图片描述

5.2字典操作时间复杂度

在这里插入图片描述

6.致谢

这是第一次学着去在博客总结自己的学习经历，也希望看过的朋友多多指教！也希望自己能坚持下去！

孤岛使者
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前端基础，深入以及算法数据结构.zip
12-30
结合理论和实践：在学习的过程中，请结合算法代码和理论知识。尝试自己编写代码实现数据结构，并在遇到问题时参考提供的代码。 由浅入深：建议先从基础的数据结构开始学习，如数组和链表，然后再学习更复杂的数据...
数组理论基础（概念、二分法+双指针+滑动窗口+模拟行为）
chenjh027的博客
12-09 382
数组是非常基础的数据结构，是面试必问的基础而不失“优雅”的知识点。思维有时很简单，但是在具体实现上很容易陷入暴力循环的深渊里，虽然大部分时候暴力循环可以解决问题，但其复杂度往往在O（n^2)及以上，让心动的offer离我们越来越远，那么，如何能够做到在高效解决问题的同时占用较少的资源呢？本文将详细介绍数组面试题中的四大法宝---二分法+双指针法+滑动窗口法+模拟法。
数组基本知识
小菜鸡
03-04 9299
数组基础知识
数组的基础理论
u012828513的博客
07-27 181
1、数组定义：按次序排列的一组值。方括号作为标志。任何类型的数据都可以放入到数组中：对象、数组、函数都可以。可以形成多维数组。 2、本质上数组属于特殊的对象，使用typeof 会返回对象类型object。 数组的键名是【0，1，2】，键名一般是字符串，之所以数组可以用数字来读取，是因为键名会将数字转换为字符串。数组不能用"点结构"来读取 3、length属性 数组中最大键名值加1，键名为数字1，2，3。数组的数字键不需要连续。 可以设置length的值，设置后，数组中大于length的值将会被删除。 数组的
数组理论干货
qq_45907053的博客
09-01 560
数组   如果看文字麻烦就直接跳到最后一个代码块 Array 1、Java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object。 2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。） 数组：字面意思是“一组数据” 3、数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。 4、数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的） 5、数组当中如果存储的是“java对象
数组原理
isnil的专栏
06-12 2094
先来看看如何定义和初始化一个数组：int myArray[5];int i;for(i=0; i{      std::cout       std::cin >> myArray[i];}myArray[5]有5个元素，它们分别为myArray[0]、myArray[1]、myArray[2]、myArray[3]、myArray[4]。注意：数组索引从0
数据结构与算法.zip
12-30
结合理论和实践：在学习的过程中，请结合算法代码和理论知识。尝试自己编写代码实现数据结构，并在遇到问题时参考提供的代码。 由浅入深：建议先从基础的数据结构开始学习，如数组和链表，然后再学习更复杂的数据...
算法和数据结构.zip
最新发布
12-30
结合理论和实践：在学习的过程中，请结合算法代码和理论知识。尝试自己编写代码实现数据结构，并在遇到问题时参考提供的代码。 由浅入深：建议先从基础的数据结构开始学习，如数组和链表，然后再学习更复杂的数据...
数据结构和算法.zip
12-30
结合理论和实践：在学习的过程中，请结合算法代码和理论知识。尝试自己编写代码实现数据结构，并在遇到问题时参考提供的代码。 由浅入深：建议先从基础的数据结构开始学习，如数组和链表，然后再学习更复杂的数据...
数据结构课程设计-排序算法集成
12-23
定义动态数组类（或类模板）以表示待排序数据，在此基础上实现多种排序算法。 要求设计函数模板来实现下列排序算法： 直接插入排序 冒泡排序 简单选择排序 希尔排序 快速排序 堆排序 并设计主函数测试...
数组掌握的理论知识
weixin_44469024的博客
11-26 117
数组是存放在连续内存空间上的相同类型的数据集合。 注意：数组下标是从0开始，且是连续的。正因为是连续的在删除或者添加元素时候，难免要移动其他元素的地址。比如，当我们要删除下表是3的元素，需要对下表为3的元素后面进行移动操作。因此数组不适合做频繁的增删操作。二维数组在空间内是连续的吗？是。二维数组是属于一维数组的，数组名代表元素的首地址。 ...
形式化13：数组理论
weixin_47539430的博客
07-18 217
则是将数组的写入进行了函数式化,在函数式程序中,数组是不可变的,因此写入操作会返回一个新构造的数组,在数组推理中，证明器总会把命令程序先转换成函数式程序，对命令式程序的推理则转换成了等价的对函数式程序的推理。,一般来说,对于高阶的结果是不可判定的！描述了推理Array数组相关性质时，能够出现的逻辑命题的形式是什么。很容易就能检查得到上面的命题是UNSAT的,因此原命题为真!为一阶,二来限制了数组必须为原子变量。,对于上述命题来说,索引集合为。但是,如果上面的式子变为。的SAT,等同于证明。...
数组的特性
weixin_30342827的博客
07-12 372
固定存储空间在最初的设计层面上，数组是依赖内存分配形成的，在使用数组前必须先为它申请空间。这使得数组这种数据结构具有了下面这样的特性：1、一个数组占据的存储空间大小固定，不能改变2、所占据的存储空间是专用的，不能被其他信息占据3、所占据的存储空间是连续性的，中间不能间隔其他的信息4、数组中的各个元素可以用数组名和下标直接访问 优点这样的数据结构肯定是很方便的，要读要写都很直接。无论多长的数字，要...
算法：数组和链表-理论
yingqi的博客
07-17 201
目录 数组 Java的数组是怎么实现 链表 Java的链表是怎么实现 我们先看看百度百科关于数组和链表的介绍吧。 数组 所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。 数组 既然我们刚刚讲到了算法的时间复杂度。 数组访问的时间复杂度是多少呢！O(1）。 数组插入...
树状数组理论与实现
一只叫做Unix的猫
01-15 492
理论：http://www.cnblogs.com/zhangshu/archive/2011/08/16/2141396.html 今天听了大神的讲课 了解了点东西 发现是之前学过的 于是试着再写一遍 #include #include #include #include using namespace std; const int M=1e6+1; int num[M]={0}; int
C语言数组理论小结
liuhangsheng的博客
10-31 764
一维数组定义:    类型说明符 数组名[常量表达式]  一维数组引用: 数组名[下标] 一维数组初始化 .对数组全部元素赋初始值 .对数组的部分元素赋初始值 .对数组的全部元素赋初始值时，可以确定一个不确定长度的数组。 .数组的名字是一个地址常量，即存储该数组的第一个元素的存放地址，然后一次存放该数组的后续元素。 二维数组定义:    类型说明符 数组名[常量表达式][常量表达...
数组
AOOOOO李
11-17 154
数组的定义： 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。 数组的声明创建： 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar; //首选方法 or dataType arrayRefVar[]; //效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[
牛客网JS能力测评经典题笔记
qq_39240593的博客
02-12 417
这是我在做完牛客网的45道JS能力测评经典题之后，结合他人的解析整理的一些笔记。如果有什么不对的地方，欢迎大家指出。
python程序设计与算法基础教程电子版
09-10
总的来说，《Python程序设计与算法基础教程》是一本非常适合初学者的Python编程入门教材，它在理论和实践方面都给予了很好的指导和支持。如果你想系统地学习Python编程和算法设计，这本教材会是一个不错的选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值