day40 数据结构-算法(二)

什么是数据结构?

  • 简单来说,数据结构就是设计数据以何种方式组织并存储在计算机中。
  • 比如:列表、集合与字典等都是一种数据结构。
  • N.Wirth: “程序=数据结构+算法”

列表

  • 列表:在其他编程语言中称为“数组”,是一种基本的数据结构类型。
  • 关于列表的问题:
    • 列表中元素使如何存储的?
    • 列表提供了哪些基本的操作?
    • 这些操作的时间复杂度是多少?
  • 列表与可变对象*

  • 栈(Stack)是一个数据集合,可以理解为只能在一端进行插入或删除操作的列表。
  • 栈的特点:后进先出(last-in, first-out)
  • 栈的概念:
    • 栈顶
    • 栈底
  • 栈的基本操作:
    • 进栈(压栈):push
    • 出栈:pop
    • 取栈顶:gettop

栈的Python实现

  • 不需要自己定义,使用列表结构即可。

    • 进栈函数:append
    • 出栈函数:pop
    • 查看栈顶函数:li[-1]

栈的应用——括号匹配问题

  • 括号匹配问题:给一个字符串,其中包含小括号、中括号、大括号,求该字符串中的括号是否匹配。
  • 例如:
    • ()()[]{} 匹配
    • ([{()}]) 匹配
    • []( 不匹配
    • [(]) 不匹配

括号匹配问题——实现

 1 def check_kuohao(s):
 2     stack = []
 3     for char in s:
 4         if char in {‘(‘, ‘[‘, ‘{‘}:
 5             stack.append(char)
 6         elif char == ‘)‘:
 7             if len(stack) > 0 and stack[-1] == ‘(‘:
 8                 stack.pop()
 9             else:
10                 return False
11         elif char == ‘]‘:
12             if len(stack) > 0 and stack[-1] == ‘[‘:
13                 stack.pop()
14             else:
15                 return False
16         elif char == ‘}‘:
17             if len(stack) > 0 and stack[-1] == ‘{‘:
18                 stack.pop()
19             else:
20                 return False
21     if len(stack) == 0:
22         return True
23     else:
24         return False

栈的应用——迷宫问题

给一个二维列表,表示迷宫(0表示通道,1表示围墙)。给出算法,求一条走出迷宫的路径。

maze = [ [1,1,1,1,1,1,1,1,1,1],

    [1,0,0,1,0,0,0,1,0,1],

    [1,0,0,1,0,0,0,1,0,1],

     [1,0,0,0,0,1,1,0,0,1],

    [1,0,1,1,1,0,0,0,0,1],

     [1,0,0,0,1,0,0,0,0,1],

    [1,0,1,0,0,0,1,0,0,1],

    [1,0,1,1,1,0,1,1,0,1],

    [1,1,0,0,0,0,0,0,0,1],

    [1,1,1,1,1,1,1,1,1,1]

    ]

解决思路

  • 在一个迷宫节点(x,y)上,可以进行四个方向的探查:maze[x-1][y], maze[x+1][y], maze[x][y-1], maze[x][y+1]
  • 思路:从一个节点开始,任意找下一个能走的点,当找不到能走的点时,退回上一个点寻找是否有其他方向的点。
  • 方法:创建一个空栈,首先将入口位置进栈。当栈不空时循环:获取栈顶元素,寻找下一个可走的相邻方块,如果找不到可走的相邻方块,说明当前位置是死胡同,进行回溯(就是讲当前位置出栈,看前面的点是否还有别的出路)

迷宫问题——栈实现

 1 dirs = [lambda x, y: (x + 1, y), lambda x, y: (x - 1, y),
 2 lambda x, y: (x, y - 1), lambda x, y: (x, y + 1)]
 3 def mgpath(x1, y1, x2, y2):
 4     stack = []
 5     stack.append((x1, y1))
 6     while len(stack) > 0:  # 栈不空时循环
 7         curNode = stack[-1]  # 查看栈顶元素
 8         if curNode[0] == x2 and curNode[1]:
 9             # 到达终点
10             for p in stack:
11                 print(p)
12             break
13         for dir in dirs:
14             nextNode = dir(*curNode)
15             if mg[nextNode[0]][nextNode[1]] == 0:  # 找到了下一个方块
16                 stack.append(nextNode)
17                 mg[nextNode[0]][nextNode[1]] = -1  # 标记为已经走过,防止死循环
18                 break
19         else:
20             mg[curNode[0]][curNode[1]] = -1  # 死路一条
21             stack.pop()
22         return False

队列

  • 队列(Queue)是一个数据集合,仅允许在列表的一端进行插入,另一端进行删除。
  • 进行插入的一端称为队尾(rear),插入动作称为进队或入队
  • 进行删除的一端称为队头(front),删除动作称为出队
  • 队列的性质:先进先出(First-in, First-out)
  • 双向队列:队列的两端都允许进行进队和出队操作。

队列的实现

  • 队列能否简单用列表实现?为什么?
  • 使用方法:from collections import deque
    • 创建队列:queue = deque(li)
    • 进队:append
    • 出队:popleft
    • 双向队列队首进队:appendleft
    • 双向队列队尾进队:pop

队列的实现原理

  • 初步设想:列表+两个下标指针
  • 创建一个列表和两个变量,front变量指向队首,rear变量指向队尾。初始时,front和rear都为0。
  • 进队操作:元素写到li[rear]的位置,rear自增1。
  • 出队操作:返回li[front]的元素,front自减1。
  • 这种实现的问题?

队列的实现原理——环形队列

  • 改进方案:将列表首尾逻辑上连接起来。

队列的实现原理——环形队列

  • 环形队列:当队尾指针front == Maxsize + 1时,再前进一个位置就自动到0。

    • 实现方式:求余数运算
    • 队首指针前进1:front = (front + 1) % MaxSize
    • 队尾指针前进1:rear = (rear + 1) % MaxSize
    • 队空条件:rear == front
    • 队满条件:(rear + 1) % MaxSize == front

队列的应用——迷宫问题

  • 思路:从一个节点开始,寻找所有下面能继续走的点。继续寻找,直到找到出口。
  • 方法:创建一个空队列,将起点位置进队。在队列不为空时循环:出队一次。如果当前位置为出口,则结束算法;否则找出当前方块的4个相邻方块中可走的方块,全部进队。

迷宫问题——队列实现

 1 def mgpath(x1, y1, x2, y2):
 2     queue = deque()
 3     path = []
 4     queue.append((x1, y1, -1))
 5     while len(queue) > 0:
 6         curNode = queue.popleft()
 7         path.append(curNode)
 8         if curNode[0] == x2 and curNode[1] == y2:
 9             #到达终点
10             print(path)
11             return True
12         for dir in dirs:
13             nextNode = dir(curNode[0], curNode[1])
14             if mg[nextNode[0]][nextNode[1]] == 0:  # 找到下一个方块
15                 queue.append((*nextNode, len(path) - 1))
16                 mg[nextNode[0]][nextNode[1]] = -1  # 标记为已经走过
17     return False

链表

链表中每一个元素都是一个对象,每个对象称为一个节点,包含有数据域key和指向下一个节点的指针next。通过各个节点之间的相互连接,最终串联成一个链表。

节点定义:

class Node(object):
    def __init__(self, item):
        self.item = item
        self.next = None

头结点

链表的遍历

  • 遍历链表:
  • def traversal(head):
        curNode = head  # 临时用指针
        while curNode is not None:
            print(curNode.data)
            curNode = curNode.next

链表节点的插入和删除

  • 插入:

    • p.next = curNode.next
    • curNode.next = p
  • 删除:
    • p = curNode.next
    • curNode.next = curNode.next.next
    • del p

建立链表

  • 头插法:
  • 1 def createLinkListF(li):
    2     l = Node()
    3     for num in li:
    4         s = Node(num)
    5         s.next = l.next
    6         l.next = s
    7     return l

  • 尾插法:
  • 1 def createLinkListR(li):
    2     l = Node()
    3     r = l       #r指向尾节点
    4     for num in li:
    5         s = Node(num)
    6         r.next = s
    7         r = s

双链表

双链表中每个节点有两个指针:一个指向后面节点、一个指向前面节点。

节点定义:

1 class Node(object):
2     def __init__(self, item=None):
3         self.item = item
4         self.next = None
5         self.prior = None

双链表节点的插入和删除

  • 插入:

    • p.next = curNode.next
    • curNode.next.prior = p
    • p.prior = curNode
    • curNode.next = p
  • 删除:
    • p = curNode.next
    • curNode.next = p.next
    • p.next.prior = curNode
    • del p

建立双链表

  • 尾插法:
  • 1 def createLinkListR(li):
    2     l = Node()
    3     r = l
    4     for num in li:
    5         s = Node(num)
    6         r.next = s
    7         s.prior = r
    8         r = s
    9     return l, r

链表-分析

  • 列表与链表

    • 按元素值查找
    • 按下标查找
    • 在某元素后插入
    • 删除某元素

Python中的集合与字典(了解)

  • 哈希表查找
  • 哈希表(Hash Table,又称为散列表),是一种线性表的存储结构。通过把每个对象的关键字k作为自变量,通过一个哈希函数h(k),将k映射到下标h(k)处,并将该对象存储在这个位置。
  • 例如:数据集合{1,6,7,9},假设存在哈希函数h(x)使得h(1) = 0, h(6) = 2, h(7) = 4, h(9) = 5,那么这个哈希表被存储为[1,None, 6, None, 7, 9]。
  • 当我们查找元素6所在的位置时,通过哈希函数h(x)获得该元素所在的下标(h(6) = 2),因此在2位置即可找到该元素。
  • 哈希函数种类有很多,这里不做深入研究。
  • 哈希冲突:由于哈希表的下标范围是有限的,而元素关键字的值是接近无限的,因此可能会出现h(102) = 56, h(2003) = 56这种情况。此时,两个元素映射到同一个下标处,造成哈希冲突。

解决哈希冲突:

  • 拉链法

    • 将所有冲突的元素用链表连接
  • 开放寻址法
    • 通过哈希冲突函数得到新的地址

  • 在Python中的字典: a = {‘name‘: ‘Alex‘, ‘age‘: 18, ‘gender‘: ‘Man‘}
  • 使用哈希表存储字典,通过哈希函数将字典的键映射为下标。假设h(‘name’) = 3, h(‘age’) = 1, h(‘gender’) = 4,则哈希表存储为[None, 18, None, ’Alex’, ‘Man’]
  • 在字典键值对数量不多的情况下,几乎不会发生哈希冲突,此时查找一个元素的时间复杂度为O(1)。
时间: 2024-11-06 03:56:30

day40 数据结构-算法(二)的相关文章

数据结构与算法二

1.课程安排表: 1. 线性表 2. 字符串 3. 栈和队列 4.树 5.查找 6.排序 7.暴力枚举法 8.广度优先搜索 9.深度优先搜索 10.分治 11.贪心 12.动态规划 13.图 14.数学方法与常见模型 15.大整数运算 16. 基础功能 2.   编程技巧: 1.把较大的数组放在main 函数(全局变量)外,作为全局变量,这样可以防止栈溢出,因为栈的大小是有限制的.GCC (C编译器) 段错误 2.如果能够预估栈,队列的上限,则不要用stack,queue,使用数组来模拟,这样速

数据结构(二) — 算法

一.数据结构与算法的关系 上一次我大致说了数据结构的一些基本概念,应该还蛮通俗易懂的吧(大概吧!!!).数据结构与算法这两个概念其实是可以单独拿出来讲的,毕竟我们大学有数据结构课,有算法课,单独拿出来讲好像没什么问题,但是数据结构就那么一些(数组.队列.树.图等结构),单独拿出来很快就说完了,但是说完之后,一脸懵逼,两脸茫然,感觉数据结构没什么用啊,但是,注意了啊,但是引入算法,变成程序之后你就会发觉某些特别困难的问题,原来可以用程序这么简单的解决. 所以在我们用程序解决问题看来,程序 = 数据

Java数据结构之二叉搜索树

Java数据结构之二叉搜索树 1.二叉搜索树组成 二叉搜索树又称为二叉排序树,它或者是一颗空树,或者是一颗具有如下特性的非空二叉树,需要满足一下三个条件: (1)若它的左子树非空,则左子树上所有结点的关键字均小于根结点的关键字: (2)若它的右子树非空,则右子树上所有结点的关键字均大于(可以等于)根结点的关键字. (3)左子树右子树本身又各是一颗二叉搜索树 在算法描述中,均以结点值的比较来代表其关键字的比较,因为若结点的值为类类型时,该类必须实现系统提供的java.lang.comparable

2、蛤蟆的数据结构进阶二静态查询之顺序查询

2.蛤蟆的数据结构进阶二静态查询之顺序查询 本篇名言:"我从不把安逸和快乐看作是生活的本身 --这种伦理基础,我叫它猪栏的理想. --爱因斯坦" 这篇我们来看下静态查询中的顺序表查询. 我们先来看下概念,然后是代码实现. 欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/47175103 1.  查找 在计算机科学中定义为:在一些(有序的/无序的)数据元素中,通过一定的方法找出与给定关键字相同的数据元素的过程叫做查找.

Kruskal算法(二)之 C++详解

本章是克鲁斯卡尔算法的C++实现. 目录 1. 最小生成树 2. 克鲁斯卡尔算法介绍 3. 克鲁斯卡尔算法图解 4. 克鲁斯卡尔算法分析 5. 克鲁斯卡尔算法的代码说明 6. 克鲁斯卡尔算法的源码 转载请注明出处:http://www.cnblogs.com/skywang12345/ 更多内容:数据结构与算法系列 目录 最小生成树 在含有n个顶点的连通图中选择n-1条边,构成一棵极小连通子图,并使该连通子图中n-1条边上权值之和达到最小,则称其为连通网的最小生成树. 例如,对于如上图G4所示的

数据结构——算法之(012)( linux C 所有字符串操作函数实现)

题目:实现linux C下常用的字符串操作函数 题目分析: 一.面试中可能经常遇到这样的问题:比如strcpy.memcpy.strstr 二.参考了linux 内核代码,对linux大神表示感谢,代码写得相当精致,这里拿来与大家分享吧 算法实现: /* * linux/lib/string.c * * Copyright (C) 1991, 1992 Linus Torvalds */ /* * stupid library routines.. The optimized versions

python入门、python数据分析(numpy、matplotlib、sklearn等)tensflow、爬虫、机器学习、深度学习、自然语言处理、数据挖掘、机器学习项目实战、python全栈、PHP、java、java web、openCV、hadoop、matlab、android、数据结构算法和刷题等教学视频

扫描二维码加好友购买视频,绝对优惠,谢谢支持. python入门和进阶熟练教学视频 入门: 进阶: python数据分析教学视频 python数据分析晋级班 tensorflow教程及实战 python爬虫教学 机器学习课程 深度学习课程 机器学习项目班 自然语言处理教学视频 python全栈教学视频 数据挖掘视频 PHP教学视频 java java web openCV教学视频 Hadoop教学视频 matlab教学 andriod教学视频 数据结构算法班及面试班 原文地址:https://w

数据结构之二叉堆、堆排序

前言 上一篇写了数据结构之二叉搜索树.AVL自平衡树,这次来写堆. 堆的创造者 很久以前排序算法的时间复杂度一直是O(n^2), 当时学术界充斥着"排序算法不可能突破O(n^2)"的声音,直到1959年,由D.L.Shell提出了一种排序算法,希尔排序(Shell Sort),才打破了这种不可能的声音,把排序算法的时间复杂度提升到了O(n^3/2)! 当科学家们知道这种"不可能"被突破之后,又相继有了更快的排序算法,"不可能超越O(n^2)"彻底

1.数据结构&算法的引言+时间复杂度

数据结构&算法的引言+时间复杂度 一.什么是计算机科学? 首先明确的一点就是计算机科学不仅仅是对计算机的研究,虽然计算机在科学发展的过程中发挥了重大的作用,但是它只是一个工具,一个没有灵魂的工具而已.所谓的计算机科学实际上是对问题.解决问题以及解决问题的过程中产生产生的解决方案的研究.例如给定一个问题,计算机科学家的目标是开发一个算法来处理该问题,最终得到该问题的解.或者最优解.所以说计算机科学也可以被认为是对算法的研究.因此我们也可以感受到,所谓的算法就是对问题进行处理且求解的一种实现思路或者