精华内容
下载资源
问答
  • 哪一种数据结构是无序的
    千次阅读
    2020-12-13 12:55:56

    Python最常用的数据结构6种:数字、字符串、列表、元组、字典和集合。其中最为常用的是数字、字符串、列表和字典。可以用type()查看数据类型;

    1、数字(number)

    用于存储数值。python3支持4种类型的数字:int(整数类型)、foat(浮点型)、bool(布尔类型)、complex(复数类型)。

    2、字符串(string)

    由数值、字母、下划线组成的一串字符,可以使用单引号(')、双引号(")和三引号(''')指定字符串,使用"+"号可以连接两个字符串

    3、列表(list)

    一维列表,变长、其内容可以进行修改。

    列表是任何对象的有序集合,用“[]”标识。元素之间用逗号隔开,列表中的元素即可以是数字或字符串,也可以是列表。每个列表中的元素都是从0开始计算的。列表可以通过“列表对象.列表方法(参数)”的方式调用。示例如下:

    1 list1=[2,3,4]

    2 list2=['a','b','c']

    3 list1+list2

    Out:[2, 3, 4, 'a', 'b', 'c']

    4、元组(tuple)

    一维序列,定长、不可变,其内容不能修改,用“()“标识。

    元组的创建方式很简单,只需在括号内添加元素,用逗号隔开即可。示例如下:

    In:("张三","23","女")

    Out:("张三","23","女")

    5、字典(dict)

    最重要的内置结构之一,大小可变的键值对集,其中键(key)和值(value)都是python对象,用”{}“指定,可以使用大括号”{}“创建空字典。格式如下:

    {Key1: Value1,Key2: Value2,Key3: Value3}或者dict(Key1:=Value1,Key2=Value2,Key3=Value3})

    需要注意的是:键必须唯一,键值不必。值可以取任何数据类型,如数字、字符串、元组。示例如下:

    In:dict(姓名="张三",年龄=23,性别="女")

    Out:{'姓名': '张三', '年龄': 23, '性别': '女'}

    In :{"姓名": "张三","年龄": 23,"性别": "女"}

    Out:{'姓名': '张三', '年龄': 23, '性别': '女'}

    6、集合(set)

    由唯一元素组成的无序集,可以看成是只有键没有值的字典,可以使用大括号“{}”或者set()函数创建集合。一个空集合必须使用set()函数创建

    更多相关内容
  • 数据结构中的有序和无序

    千次阅读 2021-05-13 10:53:54
    在我的印象中有序的数据结构是可以保留插入顺序的一种数据结构。而无序则是指在插入数据时进行了排序、去重等操作的数据结构。 正是因为这个迷惑让我开始了对于有序和无序的思考。 以Python的list和JavaScript的...

    数据结构中的有序和无序

    文章开头首先感谢正在学C++博主

    个人最起始的迷惑

    我的迷惑来自有序列表这个名词。

    在我的印象中有序的数据结构是可以保留插入顺序的一种数据结构。而无序则是指在插入数据时进行了排序、去重等操作的数据结构。

    正是因为这个迷惑让我开始了对于有序和无序的思考。

    以Python的list和JavaScript的Array为例来说,以下的数据是有序还是无序

    # py
    arr = [1,3]
    arr.append(2)
    print(arr) #[1,3,2]
    
    // JavaScript
    let arr = [1,3];
    arr.push(2);
    console.log(arr); // [1,3,2]
    

    下面是疑惑点

    • 如果说上面的是有序的,则可以认为是下标拥有排列顺序
    • 如果说上面的是无序的,则可以认为是值无排列顺序,所以是无序的

    正在学C++进行讨论

    机缘巧合下,我发现正在学C++博主发布了很多有关算法的博客,本能的觉得老哥铁定知道,然后厚着脸皮向老哥留言了。没想到老哥竟然回复我了,哈哈。

    原讨论地址,讨论内容在评论区

    这里对讨论内容进行整理

    • Q:

      对于数据结构而言, 有序和无序是指插入元素的顺序还是元素的排列顺序(如从小到大)

    • A:

      任意给一组数,可以说这组数是有序(小到大/大到小)或无序(乱序)的,然后对这组数进行排序使得它按照一个顺序排列。插入元素的顺序,怎么叫有序怎么叫无序?你可以说,对于一组有序的数,把另一个单独的数插入到这组数中使得这组数依旧有序。

    • Q:

      或许是考虑的角度问题,我下面举一个具体一点例子:

      有序链表,此处的有序为元素有排列顺序, 但是有序链表其实是一个无序的数据结构

      数据结构的有序无序是以插入元素的顺序来看的。

      如果在插入元素时 如同set数据结构一样进行了去重, 或者进行了排序打乱了插入的元素, 则认为该数据结构是无序的。

      如同python的list一样,很多人的介绍是一个有序可变的序列

    • A:

      我学习的严蔚敏老师的数据结构中,有序就是指一组数,按某个关键字有序排列,就是有序。

      可以有重复值,可以插入,可以删除,但是有序无序与这些操作没关系。

      有序无序,指的是整体的元素关键字是否按照某个顺序。

      你说的有序链表,我理解的意思是,一组数的逻辑结构是线性的,物理结构是链式存储。我没有懂你说的“有序为元素有排列顺序, 但是有序链表其实是一个无序的数据结构”。

      数据元素相互之间的关系,存在着四种逻辑结构和四种物理结构。你说的是什么数据结构?

      还有,有序无序是以插入元素的顺序来看的,我不懂,可以插入在末尾、在中间在任何一个位置,怎么判断有序无序?

      (个人补充:当我看到可以插入在末尾、在中间在任何一个位置的时候又蒙了,随后看到了老哥在问答中的回答后就明白了)

    • Q:

      讲的很透彻,我大概明白所谓的有序和无序应该站在从什么角度去理解了。谢谢您。


    下方为正在学C++老哥在问答上的回答,原文地址

    • Q:

      数据结构中的有序和无序是如何理解的?

      以JavaScript为例

      let arr = [1,3];
      arr.push(2);
      console.log(arr); //[1,3,2]
      

      上方的数组是一个有序的还是无序的呢?

      如果是有序的则可以理解为是以插入顺序来看的;

      如果是无序的则可以理解为是以值的排序顺序来看的;

      目前在看数据结构, 看到有序链表这一块有点懵, 感觉有序和无序的定义很模糊.

    • A:

      这一般来说是无序的。

      排序,是将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列。

      如果你的关键字是元素的大小,就是无序的。

      如果你为每个元素增加一个属性:位置,1的位置是1,3的位置是2,2的位置是3,且关键字是每个元素的位置,那就是有序。

    总结

    判断有序和无序需要辩证地来说。

    以上面的例子来说:

    let arr = [1,3];
    arr.push(2);
    console.log(arr); //[1,3,2]
    

    如果站在值的角度来说这个数组为无序的,因为它没有对数据进行排序,数据依然是以乱序排列的

    如果站在数组本身的实现逻辑的角度来说,它是有序的,因为可以按照索引进行取值,并且索引是有序的

    有序集合:集合里的元素可以根据key或index访问
    无序集合:集合里的元素只能遍历。

    编程是一个不断试错的过程,在这个过程中感谢每一个帮助过我的人,每一个把自己的理解和学习心得无私分享出来人。

    如果文章中有不对的地方请您在评论区指出来,我会及时改正。

    文章的末尾再次感谢正在学C++博主。

    展开全文
  • 篇文章讲清python开发必懂的8种数据结构

    千次阅读 多人点赞 2021-08-05 09:08:57
    知道哪个数据结构最适合当前的解决方案将提高程序的性能,并减少开发所需的时间。出于这个原因,大多数顶级公司都要求对数据结构有很深的理解,并在编码面试中对其进行深入的考察。 下面是我们今天要讲的内容: 什么...

    image.png
    在解决现实世界的编码问题时,雇主和招聘人员都在寻找运行时和资源效率。

    知道哪个数据结构最适合当前的解决方案将提高程序的性能,并减少开发所需的时间。出于这个原因,大多数顶级公司都要求对数据结构有很深的理解,并在编码面试中对其进行深入的考察。

    下面是我们今天要讲的内容:

    • 什么是数据结构?
    • 在Python中数组
    • 队列在Python中
    • 栈在Python中
    • Python中的链表
    • Python中的循环链表
    • Python种的树
    • Python中的哈希表
    • 接下来学什么

    什么是数据结构?

    数据结构是用于存储和组织数据的代码结构,使修改、导航和访问信息变得更加容易。数据结构决定了如何收集数据、我们可以实现的功能以及数据之间的关系。
    数据结构几乎用于计算机科学和编程的所有领域,从操作系统到前端开发,再到机器学习。
    数据结构有助于:

    • 管理和利用大型数据集
    • 从数据库中快速搜索特定数据
    • 在数据点之间建立清晰的分层或关系连接
    • 简化并加快数据处理

    数据结构是高效、真实解决问题的重要构建模块。数据结构是经过验证和优化的工具,为您提供了一个简单的框架来组织您的程序。毕竟,你没有必要每次都重新制作轮子 (或结构)。

    每个数据结构都有一个最适合解决的任务或情况。Python有4个内置的数据结构、列表、字典、元组和集合。这些内置数据结构带有默认方法和幕后优化,使其易于使用。

    • List:类似数组的结构,允许将一组相同类型的可变对象保存为变量。
    • 元组:元组是不可变的列表,意味着元素不能被更改。它是用圆括号声明的,而不是方括号。
    • Set:集合是无序的集合,这意味着元素是没有索引的,并且没有集合序列。它们用花括号声明。
    • 字典(dict):类似于其他语言中的hashmap或哈希表,字典是键/值对的集合。用空花括号初始化空字典,并用冒号分隔的键和值填充。所有键都是唯一的、不可变的对象。

    现在,让我们看看如何使用这些结构来创建面试官想要的所有高级结构。

    Arrays (Lists) in Python

    Python没有内置数组类型,但您可以为所有相同的任务使用列表。数组是以相同名称保存的相同类型的值的集合。
    数组中的每个值都被称为“元素”,索引表示其位置。您可以通过使用所需元素的索引调用数组名称来访问特定的元素。您还可以使用len()方法获取数组的长度。

    image.png

    不像Java这样的编程语言在声明后有静态数组,Python的数组在添加/减去元素时自动伸缩。

    例如,可以使用append()方法在现有数组的末尾添加一个额外的元素,而不是声明一个新数组。

    这使得Python数组特别易于使用和动态适应。

    cars = ["Toyota", "Tesla", "Hyundai"]
    print(len(cars))
    cars.append("Honda")
    cars.pop(1)
    for x in cars:
      print(x)
    

    优势:

    • 创建和使用数据序列简单
    • 自动缩放以满足不断变化的尺寸要求
    • 用于创建更复杂的数据结构

    缺点:

    • 未针对科学数据进行优化 (与NumPy的数组不同)
    • 只能操作列表的最右边

    应用:

    • 相关值或对象的共享存储,即myDogs
    • 通过循环访问
    • 数据结构的集合,例如元组列表

    Python中的常见数组面试问题

    • 从列表中删除偶数整数
    • 合并两个排序列表
    • 在列表中找到最小值
    • 最大总和子列表
    • 打印所有元素

    Python中的队列

    队列是一种线性数据结构,以 “先进先出” (FIFO) 顺序存储数据。与数组不同,您不能按索引访问元素,而只能提取下一个最旧的元素。这使得它非常适合订单敏感任务,如在线订单处理或语音邮件存储。
    你可以把在杂货店排队; 收银员不会选择下一个结账的人,而是会处理排队时间最长的人。

    image.png

    我们可以使用带有append()和pop()方法的Python列表来实现队列。然而,这是低效的,因为当您向开始添加新元素时,列表必须按一个索引移动所有元素。

    相反,最好的做法是使用Python的collections模块中的deque类。deque对追加和弹出操作进行了优化。deque实现还允许创建双端队列,该队列可以通过popleft()和popright()方法访问队列的两端。

    from collections import deque
    # Initializing a queue
    q = deque()
    # Adding elements to a queue
    q.append('a')
    q.append('b')
    q.append('c')
    print("Initial queue")
    print(q)
    # Removing elements from a queue
    print("\nElements dequeued from the queue")
    print(q.popleft())
    print(q.popleft())
    print(q.popleft())
    print("\nQueue after removing elements")
    print(q)
    # Uncommenting q.popleft()
    # will raise an IndexError
    # as queue is now empty
    

    优点:

    • 按时间顺序自动处理数据
    • 根据数据量大小自动缩放
    • deque类的时间效率高

    缺点:

    • 只能访问两端的数据

    应用程序:

    • 打印机或CPU核心等共享资源的操作
    • 作为批处理系统的临时存储
    • 为同等重要的任务提供一个简单的默认顺序

    Python中的常见队列面试问题

    • 反转队列的前k个元素
    • 使用链表实现队列
    • 使用队列实现堆栈

    Python中的栈

    栈是一种连续的数据结构,充当队列的后进先出(LIFO)版本。插入到堆栈中的最后一个元素被认为是堆栈的顶部,并且是唯一可访问的元素。要访问中间元素,必须首先删除足够多的元素,使所需的元素位于堆栈顶部。

    许多开发者将堆栈想象成一堆餐盘;你可以把盘子加到或移到盘子堆的顶部,但必须移动整个盘子堆才能把一个放在底部。

    image.png

    添加元素称为push,删除元素称为pop。你可以在Python中使用内置的列表结构来实现栈。对于列表实现,推操作使用append()方法,弹出操作使用pop()。

    stack = []
    # append() function to push
    # element in the stack
    stack.append('a')
    stack.append('b')
    stack.append('c')
    print('Initial stack')
    print(stack)
    # pop() function to pop
    # element from stack in 
    # LIFO order
    print('\nElements popped from stack:')
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())
    print('\nStack after elements are popped:')
    print(stack)
    # uncommenting print(stack.pop())  
    # will cause an IndexError 
    # as the stack is now empty
    

    优势:

    • 提供应用程序无法实现的后进先出数据管理:
    • 自动缩放和对象清理
    • 简单可靠的数据存储系统

    缺点:

    • 堆栈内存有限
    • 堆栈上的对象太多会导致堆栈溢出错误

    应用:

    • 用于开发高吞吐量的系统
    • 内存管理系统首先使用堆栈来处理最近的请求
    • 对括号匹配等问题有帮助

    Python中的常见堆面试问题

    • 使用栈实现队列
    • 使用栈计算后缀表达式
    • 使用栈获取下一个最大元素
    • 使用栈创建min() 函数

    Python中的链表

    链表是数据的顺序集合,使用每个数据节点上的关系指针链接到列表中的下一个节点。

    与数组不同,链表在列表中没有目标位置。相反,它们基于节点串联起来。

    链表中的第一个节点称为头节点,最后一个节点称为尾节点,其中尾节点的next指向为null。

    image.png

    链表可以是单链,也可以是双链,这取决于每个节点是只有一个指向下一个节点的指针,还是还有一个指向前一个节点的指针。

    你可以把链表想象成一条链;单个链接只与相邻的链接有一个连接,但所有链接一起形成一个更大的结构。

    Python没有链表的内置实现,因此需要实现一个Node类来保存数据值和一个或多个指针。

    class Node:
        def __init__(self, dataval=None):
            self.dataval = dataval
            self.nextval = None
    class SLinkedList:
        def __init__(self):
            self.headval = None
    list1 = SLinkedList()
    list1.headval = Node("Mon")
    e2 = Node("Tue")
    e3 = Node("Wed")
    # Link first Node to second node
    list1.headval.nextval = e2
    # Link second Node to third node
    e2.nextval = e3
    

    优势:

    • 新元素插入和删除更高效
    • 比数组更易于重组
    • 高级数据结构 (如图形或树)都是基于链表的

    缺点:

    • 每个数据点的指针存储增加了内存使用量
    • 必须始终从头节点遍历链表以查找特定元素

    应用:

    • 高级数据结构的构建块
    • 需要频繁添加和删除数据的解决方案

    Python中的常见链表面试问题

    • 打印给定链表的中间元素
    • 从已排序的链表中删除重复元素
    • 检查单链接列表是否为回文
    • 合并K排序链表
    • 查找两个链表的交点

    Python中的循环链表

    标准链表的主要缺点是,您总是必须从Head节点开始。循环链表通过将Tail节点的空指针替换为指向Head节点的指针来解决这个问题。当遍历时,程序将跟随指针,直到到达它开始的节点。

    image.png
    这种设置的优点是,您可以从任何节点开始遍历整个列表。它还允许您通过设置结构中所需的循环次数来使用链表作为一个可循环结构。循环链表对于长时间循环的进程非常有用,比如操作系统中的CPU分配。

    优点:

    • 可以从任何节点开始遍历整个列表
    • 使链表更适合循环结构

    缺点:

    • 如果没有空标记,将更难找到列表的Head和Tail节点

    应用:

    • 定期循环解决方案,如CPU调度

    Python中常见的循环链表面试问题

    • 在链表中检测循环
    • 反转循环链表
    • 给定大小的组中的反向圆形链表

    Python中的树形结构

    树是另一种基于关系的数据结构,专门用于表示层次结构。与链表一样,它们也被Node对象填充,Node对象包含一个数据值和一个或多个指针,用于定义其与直接节点的关系。

    每棵树都有一个根节点,所有其他节点都从根节点分支出来。根节点包含指向它正下方所有元素的指针,这些元素被称为它的子节点。这些子节点可以有它们自己的子节点。二叉树的节点不能有两个以上的子节点。

    在同一层上的任何节点都称为同级节点。没有连接子节点的节点称为叶节点。

    image.png

    二叉树最常见的应用是二叉搜索树。二叉搜索树擅长于搜索大量的数据集合,因为时间复杂度取决于树的深度而不是节点的数量。

    二叉搜索树有四个严格的规则:

    • 左子树只包含元素小于根的节点。
    • 右子树只包含元素大于根的节点。
    • 左右子树也必须是二叉搜索树。他们必须以树的“根”来遵循上述规则。
    • 不能有重复的节点,即不能有两个节点具有相同的值。
    lass Node:
        def __init__(self, data):
            self.left = None
            self.right = None
            self.data = data
        def insert(self, data):
    # Compare the new value with the parent node
            if self.data:
                if data < self.data:
                    if self.left is None:
                        self.left = Node(data)
                    else:
                        self.left.insert(data)
                elif data > self.data:
                    if self.right is None:
                        self.right = Node(data)
                    else:
                        self.right.insert(data)
            else:
                self.data = data
    # Print the tree
        def PrintTree(self):
            if self.left:
                self.left.PrintTree()
            print( self.data),
            if self.right:
                self.right.PrintTree()
    # Use the insert method to add nodes
    root = Node(12)
    root.insert(6)
    root.insert(14)
    root.insert(3)
    root.PrintTree()
    

    优点:

    • 用于表示层次关系
    • 动态大小,规模巨大
    • 快速插入和删除操作
    • 在二叉搜索树中,插入的节点被立即排序。
    • 二叉搜索树的搜索效率高;长度只有O(高度)。

    缺点:

    • 修改或“平衡”树或从已知位置检索元素的时间开销为O(logn)
    • 子节点在父节点上没有信息,并且很难向后遍历
    • 仅适用于排序的列表。未排序的数据退化为线性搜索。

    应用:

    • 非常适合存储分层数据,如文件位置

    Python中的常见树面试问题

    • 检查两棵二叉树是否相同
    • 实现一个二叉树的层次顺序遍历
    • 打印二叉搜索树的周长
    • 对路径上的所有节点求和
    • 连接二叉树的所有兄弟

    python中的图

    图是一种数据结构,用于表示数据顶点(图的节点)之间关系的可视化。将顶点连接在一起的链接称为边。

    边定义了哪些顶点被连接,但没有指明它们之间的流向。每个顶点与其他顶点都有连接,这些连接以逗号分隔的列表形式保存在顶点上。

    image.png

    还有一种特殊的图叫做有向图,它定义了关系的方向,类似于链表。在建模单向关系或类似流程图的结构时,有向图很有帮助。

    image.png

    它们主要用于以代码形式传达可视化的网络结构网络。这些结构可以为许多不同类型的关系建模,比如层次结构、分支结构,或者只是一个无序的关系网络。图形的通用性和直观性使它们成为数据科学的宠儿。
    当以纯文本形式编写时,图具有顶点和边的列表:

    V = {a, b, c, d, e}
    E = {ab, ac, bd, cd, de}
    

    在Python中,图的最佳实现方式是使用字典,每个顶点的名称作为键,边列表作为值。

    # Create the dictionary with graph elements
    graph = { "a" : ["b","c"],
                     "b" : ["a", "d"],
                     "c" : ["a", "d"],
                      "d" : ["e"],
                      "e" : ["d"]
             }
    # Print the graph          
    print(graph)
    

    优点:

    • 通过代码快速传达视觉信息
    • 可用于建模广泛的现实世界问题
    • 语法学习简单

    缺点:

    • 在大型图中很难理解顶点链接
    • 从图表中解析数据的时间昂贵

    应用:

    • 非常适合网络或类似网络的结构建模
    • 曾为Facebook等社交网站建模

    Python中的常见图形面试问题

    • 在有向图中检测周期
    • 在有向图中找到一个“母顶点”
    • 计算无向图中的边数
    • 检查两个顶点之间是否存在路径
    • 求两个顶点之间的最短路径

    Python中的哈希表

    哈希表是一种复杂的数据结构,能够存储大量信息并有效检索特定元素。
    此数据结构使用键/值对,其中键是所需元素的名称,值是存储在该名称下的数据。

    image.png

    每个输入键都要经过一个哈希函数,该函数将其从初始形式转换为一个整数值,称为哈希。哈希函数必须始终从相同的输入产生相同的哈希,必须快速计算,并产生固定长度的值。Python包含一个内置的hash()函数,可以加速实现。

    然后,该表使用散列来查找所需值(称为存储桶)的一般位置。然后,程序只需要在这个子组中搜索所需的值,而不必搜索整个数据池。

    除了这个通用框架之外,根据应用程序的不同,哈希表也可能非常不同。有些可能允许来自不同数据类型的键,而有些可能有不同的设置桶或不同的散列函数。

    下面是一个Python代码中的哈希表示例:

    import pprint
    class Hashtable:
        def __init__(self, elements):
            self.bucket_size = len(elements)
            self.buckets = [[] for i in range(self.bucket_size)]
            self._assign_buckets(elements)
        def _assign_buckets(self, elements):
            for key, value in elements: #calculates the hash of each key
                hashed_value = hash(key)
                index = hashed_value % self.bucket_size # positions the element in the bucket using hash
                self.buckets[index].append((key, value)) #adds a tuple in the bucket
        def get_value(self, input_key):
            hashed_value = hash(input_key)
            index = hashed_value % self.bucket_size
            bucket = self.buckets[index]
            for key, value in bucket:
                if key == input_key:
                    return(value)
            return None
        def __str__(self):
            return pprint.pformat(self.buckets) # pformat returns a printable representation of the object
    if __name__ == "__main__":
         capitals = [
            ('France', 'Paris'),
            ('United States', 'Washington D.C.'),
            ('Italy', 'Rome'),
            ('Canada', 'Ottawa')
        ]
    hashtable = Hashtable(capitals)
    print(hashtable)
    print(f"The capital of Italy is {hashtable.get_value('Italy')}"
    

    优点:

    • 可以将任何形式的键隐藏为整数索引
    • 对于大型数据集非常有效
    • 搜索效率高
    • 每次搜索的步骤数不变,添加或删除元素的效率不变
    • 在Python 3中进一步优化

    缺点:

    • 哈希值必须是唯一的,两个键转换为相同的哈希值会导致冲突错误
    • 碰撞错误需要对哈希函数进行全面修改
    • 对于初学者来说很难构建

    应用程序:

    • 用于频繁查询的大型数据库
    • 根据关键字检索的系统

    Python中常见的哈希表面试问题

    • 从头开始构建哈希表(不含内置函数)
    • 找出两个加起来是k的数
    • 为冲突处理实现开放寻址
    • 使用哈希表检测列表是否循环

    _学习愉快!

    展开全文
  • Python中的4种数据结构

    千次阅读 2021-01-29 11:13:42
    Python中内置的数据结构分别是:list、tuple、dict、set。list(列表)特征1.列表中每个元素都是可变的;2.列表中的元素是有序的;3.列别中可以容纳Python的任何对象。基础操作创建列表直接创建列表1list = ["百度", ...

    2ff34e647e2e3cdfd8dca593e17d9b0a.png

    Python中内置的数据结构分别是:list、tuple、dict、set。

    list(列表)

    特征

    1.列表中每个元素都是可变的;

    2.列表中的元素是有序的;

    3.列别中可以容纳Python的任何对象。

    基础操作

    创建列表

    直接创建列表1list = ["百度", "腾讯", "阿里巴巴"]

    通过循环来创建列表1

    2a = [1,2,3,4,5,6]

    b = [i*10 for i in a]

    增加元素

    列表后面追加元素1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list.append("谷歌")

    在指定位置插入元素1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list.insert(1, "FaceBook")

    删除元素

    删除尾部元素1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list.pop()

    删除指定位置的元素1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list.pop(1)

    删除列表中某一个确定元素1

    2list = ["百度", "腾讯", "阿里巴巴", "FaceBook"]

    list.remove("FaceBook")

    删除列表指定索引位置范围内的元素1

    2list = ["百度", "腾讯", "阿里巴巴", "FaceBook"]

    del list[1:3] #删除列表角标1到3的所有数据

    获取列表信息

    获取列表长度1

    2list = ["百度", "腾讯", "阿里巴巴"]

    len(list)

    获取列表指定位置的数据获取列表指定索引位置的数据1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list[1]获取列表指定范围的数据1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list[1:2]获取列表从索引位为0开始到指定索引位置的数据1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list[ :2]获取指定索引位到列表结尾的数据1

    2list = ["百度", "腾讯", "阿里巴巴"]

    list[1: ]

    tuple(元组)

    特征

    元组与列表类似,不同支出在于元组的元素不能修改。

    基础操作

    新建元组1

    2tuple1 = () #创建一个空元组

    tuple1 = (50, ) #创建一个元素只有一个的元组

    访问元组的元素1

    2

    3

    4

    5tuple1 = ('physics', 'chemistry', 1997, 2000)

    tuple2 = (1, 2, 3, 4, 5, 6, 7)

    print "tuple1[0]: ", tuple1[0]

    print "tuple2[1:5]: ", tuple2[1:5]

    修改元组

    元组中的元素值是不允许修改的

    元组拼接1

    2

    3

    4tuple1 = (12, 34.56)

    tuple2 = ('abc', 'xyz')

    tuple3 = tuple1 + tuple2

    print tuple3

    删除元组1

    2tuple1 = (12, 34.56)

    del tuple1

    获取元组的一些信息

    获取元组的长度1

    2tuple = (1, 2, 3)

    len(tuple)

    获取元组中的元素的最大值1

    2tuple = (1, 2, 3)

    max(tuple)

    获取元组中的元素的最小值1

    2tuple = (1, 2, 3)

    min(tuple)

    判断某一个元素是否存在在元组中1

    2tuple = (1, 2, 3)

    a = 3 in tuple

    遍历元组1

    2

    3tuple = (1, 2, 3)

    for x in tuple

    print x

    将列表转化成元组1

    2list = [1, 2, 3]

    tuple = tuple(list)

    元组的一些运算

    两个元组拼接1

    2

    3

    4tuple1 = (12, 34.56)

    tuple2 = ('abc', 'xyz')

    tuple3 = tuple1 + tuple2

    print tuple3

    复制操作1

    2

    3tuple = (1, )

    result = tuple * 4

    print result

    元组截取1

    2

    3

    4tuple = ("百度","腾讯","阿里巴巴")

    tuple[2] #读取索引值为2的元素

    tuple[-2] #反向读取,读取倒数第二个元素

    tuple[1:] #截取从索引值为1到末尾的所有元素

    dict(字典)

    特征

    1.字典中的元素必须是键值对形式出现的;

    2.字典中的元素的键不可以重复,值可以重复;

    3.字典中元素的键不可以修改,值可以修改。

    基础操作

    新建字典1dict = ["B": "百度", "A": "阿里巴巴", "T": "腾讯"]

    新增元素

    新增单一元素1

    2dict = ["B": "百度", "A": "阿里巴巴", "T": "腾讯"]

    dict["F"] = "FaceBook"

    新增多元素1

    2dict = ["B": "百度", "A": "阿里巴巴", "T": "腾讯"]

    dict.update({"F":"FaceBook", "W": "微博"})

    删除元素

    删除字典中某一元素1

    2dict = ["B": "百度", "A": "阿里巴巴", "T": "腾讯", "F":"FaceBook"]

    del d["F"]

    删除字典中所有算数1

    2dict = ["B": "百度", "A": "阿里", "T": "腾讯"]

    dict.clear()

    修改元素1

    2dict = ["B": "百度", "A": "阿里", "T": "腾讯"]

    dict["A"] = "阿里巴巴"

    查询元素1

    2dict = ["B": "百度", "A": "阿里巴巴", "T": "腾讯"]

    dict["A"]

    内置函数及说明函数描述cmp(dict1, dict2)比较两个字典元素。

    len(dict)计算字典元素个数,即键的总数。

    str(dict)输出字典可打印的字符串表示。

    type(variable)返回输入的变量类型,如果变量是字典就返回字典类型。

    dict.clear()删除字典内所有元素。

    dict.copy()返回一个字典的浅复制。

    dict.fromkeys(seq[, val])创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值。

    dict.get(key, default=None)返回指定键的值,如果值不在字典中返回default值。

    dict.has_key(key)如果键在字典dict里返回true,否则返回false。

    dict.items()以列表返回可遍历的(键, 值) 元组数组

    dict.keys()以列表返回一个字典所有的键

    dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default。

    dict.update(dict2)把字典dict2的键/值对更新到dict里

    dict.values()以列表返回字典中的所有值

    pop(key[,default])删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。

    popitem()随机返回并删除字典中的一对键和值。

    set(集合)

    特征

    1.集合更接近数学上集合的概念。集合中每个元素都是无序的、不重复的任意对象;

    2.可以通过集合去判断数据的从属关系,也可以通过集合把数据结构中重复的元素减掉。集合可做集合运算,可添加和删除元素;

    3.集合内数据无序,即无法使用索引和分片;

    4.集合内部数据元素具有唯一性,可以用来排除重复数据;

    5.集合内的数据:str,int,float,tuple,冰冻集合等,即内部只能放置可哈希数据。

    基础操作

    新建一个集合

    新建一个空集合1s = set()

    新建一个有元素的集合1s = {1, 2, 3, 4, 5, 6}

    新增集合中的元素1

    2s = {1, 2, 3, 4, 5, 6}

    s.add(7)

    删除集合中的元素1

    2s = {1, 2, 3, 4, 5, 6}

    s.remove(6)

    展开全文
  • Redis的五种数据结构的底层实现原理

    万次阅读 多人点赞 2021-01-31 02:49:22
    Redis的五种数据结构的底层实现原理: 1、String底层实现方式:动态字符串sds 或者 long; 2、Hash底层实现方式:压缩列表ziplist 或者 字典dict; 3、List在Redis3.2之前的底层实现方式:压缩列表ziplist 或者 双向...
  • 本文代码实现基本按照《数据结构》课本目录顺序,外加大量的复杂算法实现,篇文章足够。能换你个收藏了吧?
  • 数据结构可以从两个方面分析:逻辑结构与物理结构...数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 数据结构与算法的关系: 数据结构指的是“一组数据的存储结构”,算法指的是“操作数据的一.
  • Redis的5基本数据结构

    千次阅读 2021-10-30 09:45:31
    一、String类型 String数据类型是Redis中最基本的数据类型,是key-value的对应形式,redis中的string可以包含任何类型的数据,数字,字符串,图片等等...本身是一个HashMap,一种键值对的形式,field对应value 使用:所有h
  • 学算法先学数据结构?是否是无稽之谈?

    万次阅读 多人点赞 2022-03-02 08:30:55
    反正也没有 KPI 压力,就当成是工作之余的一种消遣,还能够提升思维能力。所谓: 「 十年磨一剑,今朝把示君 」 。 3、坚持并且把它当成兴趣   相信看我文章的大多数都是「 大学生 」,能上大学的都是「 精英 」,...
  • 数据结构有两个概念、逻辑结构,物理结构(存储) 逻辑结构:描述数据节点之间的关系,有集合结构,线性结构,树形结构,图形结构四。 物理结构:描述数据在内存中是如何存储的(分配内存空间),有顺序存储结构,...
  • 数据结构与算法学习笔记

    万次阅读 多人点赞 2018-09-25 13:55:49
    数据结构指的是“组数据的存储结构”,算法指的是“操作数据的组方法”。 数据结构是为算法服务的,算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构:数组、链表、栈、队列、散列表、...
  • 树状图是一种数据结构,它是由n(n>=1)个有限结点组成一个具有层次关系的集合。看起来就像一棵倒挂的树。 树状图的特点: 每个结点有零个或多个子结点; 没有父结点的结点称为根结点; 每一个非根结点有且...
  • Python中主要有8种数据类型:number(数字)、string(字符串)、list(列表)、tuple(元组)、dict(字典)、set(集合)、Boolean(布尔值)、None(空值)。其中Python有六个标准的数据类型,...
  • redis的5种数据结构及其底层实现原理

    万次阅读 多人点赞 2020-10-21 19:55:43
    Redis支持五种数据类型:string(字符串),hash(哈希),list(列表),set(无序集合)及zset(有序集合)。 在秒杀项目里,我用过redis的Set和Hash结构: String:个 key 对应个字符串,string是Redis 最...
  • 基本数据结构

    千次阅读 2019-03-18 09:29:46
    集合结构:该结构数据元素间的关系是“属于同个集合”; 线性结构:该结构数据元素之间存在的关系; 树形结构:该结构数据元素之间存在对多的关系; 图形结构:该结构数据元素之间存在多对多的...
  • Python基本内置数据类型有哪些

    千次阅读 2020-11-20 20:08:13
    它也是在一种语言4102中最基本1653的类型,与编译器编译出的代码具有重大关系。值得一提的是,不同语言也拥有不同的内置类型, 但是所有内置类型的定义都与计算机的运算方式相关。Python主要内置类型包括数值、序列...
  • Redis的五种数据结构

    千次阅读 2022-05-18 23:41:30
    程序是用来处理数据的,redis是用来存储数据的,程序处理完的数据要存储到redis中,不同特点的数据要存储在redis中不同类型的数据结构中。字符串:         单key: 单value list列表: 有序可重复     ...
  • 数据结构——八大排序算法(面试必备)

    万次阅读 多人点赞 2021-04-24 14:38:41
    目录1. 交换排序——冒泡排序2....从要排序序列的第个元素开始,次比较相邻元素的值,发现逆序则交换,将值较大的元素逐渐从前向后移动。 public void bubbleSort(int[] arr){ for (int i = 0; i < arr.le...
  • redis的五种数据结构原理分析

    万次阅读 多人点赞 2018-11-13 15:51:08
    redis中的五种数据结构分析 应用场景分析 总结   关于Redis redis是个开源的使用C语言编写的个kv存储系统,是个速度非常快的非关系远程内存数据库。它支持包括String、List、Set、Zset、hash五种数据...
  • Redis五种数据结构详解

    千次阅读 多人点赞 2020-09-01 15:27:00
    Redis的五种数据结构包括以下五种: String:字符串类型 List:列表类型 Set:无序集合类型 ZSet:有序集合类型 Hash:哈希表类型 但是作为名优秀的程序员可能不能只停留在只会用这五种类型进行crud工作,还是得...
  • 数据结构面试常见问题

    千次阅读 多人点赞 2021-01-04 16:00:05
    目录、绪论二、线性表三、栈和队列四、串、数组和广义表五、树和二叉树六、图七、查找八、内部排序 、绪论 1.时间复杂度和空间复杂度的区别是什么? (1)时间复杂度是对个算法运行所占用CPU时间多少的量度; ...
  • 超硬核!数据结构学霸笔记,考试面试吹牛就靠它

    万次阅读 多人点赞 2021-03-26 11:11:21
    上次发操作系统笔记,很快浏览上万,这次数据结构比上次硬核的多哦,同样的会发超硬核代码,关注吧。
  • 集合这个概念应该大家在学习数学的时候都听过并且有学习过,它也是一种数据结构,我们还是需要用代码来实现集合的很多方法。 学习过ES6语法的小伙伴应该知道,ES6新增了一种 Set 数据结构,这就是集合,尽管官方已经...
  • 根据此书所做随笔笔记。 、绪论 1.1、数据机构的研究内容 ...由于数据必须在计算机中处理,因此不能局限于数据本身的数学问题的研究,还必须考虑数据的物理结构,即数据在计算机中的存储结构。 1.
  • JavaScript中的常见数据结构

    千次阅读 2021-09-27 12:31:30
    JavaScript中的常见数据结构 队列 栈 链表 集合 树 堆
  • 为什么说Go的Map是无序的?

    千次阅读 2021-03-04 10:44:50
    Go源码版本1.13.8系列导读本系列基于64位平台、1Page=8KB 前言是的,我也是个PHPer,对于我们PHPer转Gopher的银????,一定有个困扰:Go语言里每次遍历Ma...
  • 简述redis数据结构

    千次阅读 2021-10-16 14:28:25
    Set:无序集合 Sorted Set:有序集合 bitmap:布隆过滤器 GeoHash:坐标,借助Sorted Set实现,通过zset的score进行排序就可以得到坐标附近的其他元素,通过讲score还原成坐标值就可以得到元素的原始坐标 ...
  • Redis五种数据结构及实现原理

    千次阅读 2018-08-05 11:05:59
    2.Redis的数据结构简介 2.1 字符串 2.2 列表(list) 2.2.1 右边进左边出:队列 2.2.2 右边进右边出:栈 2.2.3 慢操作 2.2.4 快速列表 2.3 集合(set) 2.4 散列(hash) 2.5 有序集合(zset) 2.5.1 ...
  • Redis有五基础数据结构,分别为: 1、string(字符串) 2、list(列表) 3、hash(字典) 4、set(集合) 5、zset(有序集合) 数据结构有八分类,分别为: 1、数组 2、栈 3、队列 4、链表 5、树 6、散列表 7、堆 8、图 ...
  • 力扣刷题的第题:两数之和的最佳解决方法就是哈希表,本篇就是来讲解数据结构:哈希表的,来帮助大家认识哈希表,助力解题!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,149
精华内容 58,459
热门标签
关键字:

哪一种数据结构是无序的

数据结构 订阅