算法_数据结构相关知识

时间 2019-11-17

标签算法数据结构相关知识繁體版

原文原文链接

1、什么是数据结构？html

数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。
简单来讲，数据结构就是设计数据以何种方式组织并存储在计算机中。
好比：列表、集合与字典等都是一种数据结构。

“程序=数据结构+算法”

2、数据结构的分类算法

数据结构按照其逻辑结构可分为线性结构、树结构、图结构数组

线性结构：数据结构中的元素存在一对一的相互关系
树结构：数据结构中的元素存在一对多的相互关系
图结构：数据结构中的元素存在多对多的相互关系

下面就来讲说线性结构，树结构见连接，图结构待续。。数据结构

3、线性结构app

（1）栈函数

一、定义：栈是一个数据集合，能够理解为只能在一端进行插入或者删除操做的列表。spa

二、栈的特色：后进先出（last-in，first-out），简称LTFO表设计

三、栈的概念：3d

栈顶：容许插入和删除的这一端称之为栈顶
栈底：另外一固定的一端称为栈底
空栈：不含任何元素的栈称为空栈

四、栈的基本操做：指针

进栈（压栈）：push
出栈：pop
取栈顶：gettop

如图：

五、栈的Python实现

不须要本身定义，使用列表结构便可。

进栈函数：append
出栈函数：pop
查看栈顶元素：li[-1]

li = []
li.append(1)
li.append(2)
li.append(3)
print(li)
print(li.pop())
print(li.pop())
print(li.pop())
# print(li.pop())  #当栈空的时候就会报错
# print(li[-1]) #查看栈顶元素

六、栈的应用----括号匹配问题

问题：给一个字符串，其中包含小括号，中括号，大括号，求该字符串中的括号是否匹配

例如：

()()[]{}        匹配
([{()}])        匹配
[](        不匹配
[(])        不匹配

代码以下：

# 方式一
def brace_match(s):
    '''括号匹配问题'''
    stack = []
    # {()}[]
    match = {')': '(', '}': '{', ']': '['}
    match2 = {'(': ')', "{": "}", "[": "]"}
    for ch in s:
        # print(i)
        if ch in {'(', '{', '['}:  # 若是左括号在里面就把左括号添加进去，等待和右括号匹配
            stack.append(ch)
        elif len(stack) == 0:  # 若是再次进来括号的时候，这时候发现栈空了，说明缺乏了左括号了
            print('缺乏了%s' % match[ch])
            return False
        elif stack[-1] == match[ch]:  # 好比栈顶元素是(,ch=')'
            stack.pop()
        else:
            print('括号不匹配')
            return False

    if len(stack) > 0:  # 若是栈剩余了，说明缺乏了右括号
        print('缺乏了%s' % match2[stack[-1]])
        return False
    return '匹配成功'

# 方式二
def check_kuohao(s):
    stack = []
    for char in s:
        if char in {'(', '[', '{'}:
            stack.append(char)
        elif char == ')':
            if len(stack) > 0 and stack[-1] == '(':
                stack.pop()
            else:
                return False
        elif char == ']':
            if len(stack) > 0 and stack[-1] == '[':
                stack.pop()
            else:
                return False
        elif char == '}':
            if len(stack) > 0 and stack[-1] == '{':
                stack.pop()
        else:
            return False
    if len(stack) == 0:
        return True
    else:
        return False

ret = brace_match('{()}]')
print(ret)

print(check_kuohao('{()}]'))

（2）队列

一、介绍

队列是一个数据集合，仅容许在列表的一端进行插入，另外一端进行删除，
进行插入的一端称为队尾（rear），插入动做称之为进队或入队
进行删除的一端称之为对头（front），删除动做称为出队

双向队列：对列的两端都容许进行进队和出队操做

二、队列的实现

队列可否简单用列表实现？为何？

初步设想：列表+两个下标指针
建立一个列表和两个变量，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

三、对列的内置模块

使用方法：from collections import deque #deque是支持双向队列的

建立队列：queue = deque(li)
进队：append
出队：popleft
双向队列队首进队：appendleft
双向队列队尾进队：pop

from collections import deque
queue = deque()#建立队列
queue.append('first')
queue.append('second')
queue.append('third')
print(queue.popleft())
print(queue.popleft())
print(queue.popleft())#出队,,先进先出
print([i for i in queue])  #查看队列里的元素

queue.appendleft('one')#双向队列队首进队
queue.appendleft('two')#双向队列队首进队
queue.appendleft('five')#双向队列队首进队
print(queue.pop())
print(queue.pop())#双向队列从队尾出队
print([i for i in queue])



#单向队列
from queue import Queue
q = Queue()
q.put('a')
q.put('b')
q.put('c')
print(q.get())  #a

（3）单链表

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

一、节点定义：

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

二、创建链表

头插法

尾插法

三、链表的遍历

四、链表节点的插入和删除

# 插入：
p.next = curNode.next
curNode.next = p

#删除：
p = curNode.next
curNode.next = p.next  #当前节点的下一个指向就指向他下一个的下一个
del p

插入：

删除：

< >（4）双链表

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

一、节点定义：

class Node(object):
    def __init__(self,item):
        self.item = item  #数据
        self.next = None  #下一个指向 
        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）

（2）

（3）

（4）

这四张图片分别对应上面的四行代码

（5）哈希表

哈希表（又称为散列表），是一种线性表的存储结构。哈希表由一个顺序表（数组）和一个哈希函数组成。哈希函数h(k)将k做为自变量，返回元素的存储下标。

一、简单哈希函数

除法哈希：h(k) = k mod m #mod就是% #除留余数法
乘法哈希：h(k) = floor(m(kA mod 1)) 0<A<1 #floor是向下取整

假设有一个长度为7的数组，哈希函数h(k)=k%7。元素集合{14,22,3,5}的存储方式以下图。

二、哈希冲突

因为哈希表的大小是有限的，而要存储的值的总数量是无限的，所以对于任何哈希函数，都会出现两个不一样元素映射到同一个位置上的状况，

这种状况叫作哈希冲突。

好比h(k)=k%7, h(0)=h(7)=h(14)=...

三、解决哈希冲突的办法

a、开放寻址法
b、拉链发

开放寻址法：若是哈希函数返回的位置已经有值，则能够向后探查新的位置来存储这个值。

线性探查：若是位置i被占用，则探查i+1, i+2,……
二次探查：若是位置i被占用，则探查i+12,i-12,i+22,i-22,……
二度哈希：有n个哈希函数，当使用第1个哈希函数h1发生冲突时，则尝试使用h2,h3,……

拉链法：哈希表每一个位置都链接一个链表，当冲突发生时，冲突的元素将被加到该位置链表的最后。

四、哈希表在Python中的应用

a、字典与集合都是经过哈希表来实现的
b、在Python中的字典：a = {'name': 'Alex', 'age': 18, 'gender': 'Man'}，使用哈希表存储字典，经过哈希函数将字典的键映射为下标。

假设h(‘name’) = 3, h(‘age’) = 1, h(‘gender’) = 4，则哈希表存储为[None, 18, None, ’Alex’, ‘Man’]

c、在字典键值对数量很少的状况下，几乎不会发生哈希冲突，此时查找一个元素的时间复杂度为O(1)。

参考or转发

https://www.cnblogs.com/haiyan123/p/8407450.html