算法学习-数据结构基础（总）

主要是在B站看“爱学习的饲养员的视频”，用word做笔记好麻烦，开始在CSDN做记录，也方便自己查找吧。之前用MATLAB更多，和Python好多习惯都不太一样，

一、Number相关

对number的操作：+ - × /

//：向下取整？同Ceil 的取整结果？

%：取余数

abs(): 取绝对值

max(a,b), min(a, b)

pow(x, y) = x^y

sqrt: 求平方根（需要import math）

二、列表list

一个列表中可以同时包含多种数据类型，eg：a = [1, 1.5, "apple"]。(方括号声明)

可涉及的操作：查找、增加、更新、删除。

1、查找： [索引序号] 进行查找，索引序号从0开始到 len-1

2、增加：a.append(增加的内容）：eg：a=[1,2]-->a.append(3)--->a=[1,2,3]

3、更新：直接对某位置的值进行重新赋值，eg: a[0]=9

4、删除：a.pop(索引序号)。什么都不写的情况下默认删除最后一个

5、常用函数：

①求长度：len(a)

②求极值：max min

③翻转：a.reverse()  将a中的元素倒序显示

④清除： a.clear()  将a中的元素清空，即a = [ ]

⑤初始化：c初始化赋值为和a同等长度的元素全为0的list

c = [0]*len(a)

⑥判断a中是否有某元素，返回 true or false 。eg： 3 in a

⑦切片slice：获取列表的一部分。基本和MATLAB的操作相同，不同的有不能用end，可以用负数来表示倒数第几个元素（例如-1表示倒数第一个），但是注意python全部是左闭右开区间，也就是说eg：a[0:-1] 将不包括最后一个元素。如果要包含最后一个元素，则留空即可，eg: a[:]表示a中全部元素。

⑧遍历迭代的两种写法

##### 方式一
for x in a : #x是a中的元素
    print(x)

##### 方式二
for index in range(len(a)) #index是索引，范围从0 到 len-1
    print(a[index])

⑨高端操作，把遍历和迭代直接写进列表里（替代for循环的这一步，更加简洁），同样也是两种写法

### 方式一，按元素索引
b = [x*x for x in a]#依次对a中的每个元素做平方，得到b.仅循环
b = [x*x if x<3 else x for x in a]#循环+判断

三、Tuple元组

和list基本相同，同样可以包含多种该数据类型。eg：a = (1, 1.5, "apple")。(用圆括号声明）。注意，只有一个元素的时候记得加逗号，不然类别会被改变,即： b = (1, ))

不同的是，Tuple中的元素，只能查找不可以增删改。

大部分情况Tuple都可以用list来替代，一般用在查找某固定集合内的数，防止集合内容被更改时使用。

①len、max、min、in、slice、遍历迭代、复合操作等，都和 list 完全相同

②list和Tuple的互相转换：假设a为list，b为Tuple

a = list(b)#将tuple b 转换为list类型
b = tuple(a)#将list a 转换为tuple类型

四、set集合

用{}集合的一段元素，在一个集合中同样可以包括不同的数据类型，eg：a={1， 1.5， “apple”}。

和list一样，同样支持增删改查。

不同的是，集合中的所有元素都是唯一的、存储无序的，所以集合中的元素不支持通过索引访问。

1、查：in，eg："apple" in a----->返回True or False

2、增改：

(1) a.add(要增加的元素），注意：

①一次只能增加一个元素，且由于集合的特点，如果add的元素是a中已有的，那么add完，a中元素不会有变化。eg：a.add(1)-->a={1,1.5,"apple"}

②如果add的元素是a中已有的，则可以成功add元素。但是集合中数据的存储是无序的，因此不可以用索引序号来查找元素。eg：a.add(2)-->a={1,2,1.5,"apple"}

(2) a.update(要增加的元素）

与add不同的是，update可以一次性增加多个元素，且要增加的元素数据类型不限？eg：

## 集合和集合
set1 = {1,2,3}, set2 = [3,4,5]
set1.update(set2)
---->set1 = {1,2,3,4,5}

## 集合和列表
set1 = {1,2,3}, list1 = [3,4,5]
set1.update(list1)
---->set1 = {1,2,3,4,5}

## 集合和元组
set1 = {1,2,3}, tuple1 = [3,4,5]
set1.update(tuple1)
---->set1 = {1,2,3,4,5}

## 集合和字符串
set1 = {1,2,3}, str1 = "345" #注意字符串的每个字符会被分开添加，而不是作为一个整体
set1.update(str1)
---->set1 = {"1","2","3","4","5"}

3、删除：a.remove(要删除的元素，可以指定）或者是a.pop(不填，随机删除一个元素)

4、常用函数：len、 max、min等操作和list一致

5、针对集合的逻辑关系运算符：- | & ^

a - b: a有b没有的元素

a | b: a有或者b有的元素--->并集

a & b: ab都有的元素----->交集

a ^ b: ab中不同时拥有的元素，a有b没有或者是b有a没有的

五、dictionary字典

也是一对{}表示的数据，但是和set不同的是，dictionary中的数据，都是以键对值（key：value）形式给出的，eg：dict = {"name" : "learning", "age" : 18}。

同样也具有增删改查操作，但是与其他数据类型不同的是，dictionary以key作为索引：

1、查：查key，得value。eg：dict["name"] = "learning"

2、增：直接赋值。eg：dict["platform"] = "youtube"

3、改：同样也是直接赋值。eg：dict["platform"] = "bilibili"

4、删：dict.pop(要删除的key-value）。eg：dict.pop("platform")，则对应的key-value将都被删除。

5、遍历：

## 遍历key
for i in dict:
    print(i) #将依次print出key

## 遍历value
for j in dict.value():
    print(j) #将依次print出value值

## 遍历键对值
 for k,v in dict.items():
    print(k,v) #将以k=v的形式依次print

六、字符串string

eg：s = "Hello World"。常用函数

1、len(s)：空格也算字符

2、max(s)、min(s)：根据ASSIC码进行排序

3、s.count(要查找的符号)：返回要查找的符号在该字符串中数量

4、s.isupper()：s中是否全是大写字母，返回True or False

      s.islower()：s中是否全是小写字母

      s.isdigit()：s中是否全是数字

      s.isalpha()：s中是否全是字母

5、s.lower()：将s中的字母全部转换为小写

      s.upper()：将s中的字母全部转换为大写

      s.swapcase()：将s中的字母大写换小写，小写换大写

6、s.strip()：去掉左右两端的空格。eg：s="   ab  "---->"ab"

      s.lstrip()：去掉左边的空格。eg：s="   ab  "---->"ab "

      s.rstrip()：去掉右边的空格。eg：s="   ab  "---->"   ab"

7、s.replace(old,new)：用new字符替代old对应的字符

8、s.split(分隔符)：从分隔符处截断，将s分割为若干个字符，并以list形式存储。eg：a=s.split(" ")以空格为分隔符分割s，得到a=["Hello","World"]

七、数组Array

当list中的数据类型相同的时候，就得到了数组。这些数据集中存储在一块连续的内存区域

优点：访问非常快，通过索引序号来读取。

缺点：查询、插入和删除很慢。需要按内存顺序一个个查询或者排序存储。

八、链表Linkedlist

链表的数据存储形式：一组数据是一个value+一个next指针指向下一组数据。由于有next指针，因此链表数据不同于数组，不需要存储在一起。

优点：插入和删除很快（更改next指针内容即可）（和list相反）

缺点：访问很慢（和list相反，没法通过索引直接访问），查找也很慢（和list相同）

九、哈希表Hashtable

结合了链表和dictionary数据的优势？可认为哈希算法替代了链表中next指针？

哈希表的数据同样也是通过键对值来存储的。得到key：value后，通过哈希算法，将这一对值存储在想要的位置（可以是分散的位置）。因此在查找时，可以通过输入key，经过哈希算法后，找到对应键对值的存储位置，从而可以实现快速查阅（dictionary数据的优势）。

而哈希表类似链表，可以将键对值分开存储在不同位置，因此插入和删除数据都非常的快。

缺点：但是没有办法通过索引快速访问。

十、Queue队列（暂存疑）

特点：先进先出（FIFO: first in first off），常用在BFS？

双端队列：可以左进右出，也可以右进左出，但是同样保持先进先出的规则。

有两种类型，一种是list（单端队列），还有一种叫deque（双端队列）？这里不是很明白，没搜到什么讲的清除的？

新认识：list和deque应该是实现队列的两种不同的容器

1、list方法实现队列----增删元素

（1）增加：a.append(要增加的元素)，增加的元素每次都被排在最后一位

（2）删除：a.pop(0），每次都先删掉第一个元素。

2、deque队列，四个常用操作

（1）增加：a.append(要增加的元素)，a.pependleft()--->在左侧添加元素

（2）删减：a.pop()---->从右侧开始删减，a.popleft()---->从左侧开始删减

十一、stack栈

先入后出（RILO），常用在DFS？

和deque队列相同的操作：

（1）增加：a.append(要增加的元素)，a.pependleft()--->在左侧添加元素

（2）删减：a.pop()---->从右侧开始删减，a.popleft()---->从左侧开始删减

只是要保证先入后出，也就是说，对栈：append和pop搭配，appendleft和popleft搭配，保证先入后出；对deque：append和popleft搭配，appendleft和pop搭配，保证先入先出。

同样len、max、min函数同样适用。

十二、Heap堆

一堆数据，分为大堆到小堆。对大堆，pop数据时，永远pop当前这一堆数据的最大值，小堆相反。一般默认小堆

常用在前k个最大的值和前k个最小的值这种问题时。（需要import heapq，from heapq import 需要的function）

常用函数：

①heapify：将列表转换为堆（默认小堆）,如果要做大堆的话，把heap中的值都乘-1，然后pop，对pop和其他操作涉及的数再乘-1，以得到期望的值。

②heappush(heap名，数据)：将一个元素添加到一个堆中，注意元素一定要可比较

③heappop(heap名)：弹出堆中的元素

④nlargest(k，数据堆)：从这堆数据中弹出前k个最大的值

⑤nsmallest(k，数据堆)：从这堆数据中弹出前k个最小的值

十三、Tree树

1、讲究父子关系。几个概念：

（1）节点、根节点（最初始的那个节点）、叶子节点（没有孩子的节点）、兄弟节点（具有同父节点的节点）

（2）高度、深度、层：

2、二叉树分类：

（1）普通二叉树：每个节点最多两个叉（可以一个叉）。

（2）满二叉树：除了叶子节点，每个节点都有左右两个叉（可以没叉，但是如果有叉必定俩叉）

（3）完全二叉树：与满二叉树的区别--->完全二叉树的最低级别的可以只有左叉没有右叉---->节点从上到下从左到右进行编号，数据的存储顺序（空节点会留位置并存空，如下图所示）和节点的编号顺序一致。

还参考了这个（一文带你详解完全二叉树（超详细）-CSDN博客）

3、二叉树遍历

不需要构建树、需要会遍历节点中的数、找到节点对应的值。