基础数据结构相关知识点

分类为:线性数据结构,树型数据结构,图型数据结构,集合结构

常用的如下几种:

一,线性数据结构

1,数组:

一种连续的数据存储和组织规则,占据一段连续的内存空间.符合这个规则的就是数组数据结构.

一维数组是有限个具有相同类型的变量组成的序列。若其中每个变量本身是一维数组，则构成二维数组。

多维数组:若每个变量本身为（n-1）维数组，则构成n维数组。

标识：在一维数组中，每个元素对应一个下标以标识该元素。类似的，在n维数组中，每个元素对应n个方向的下标以标识该元素。

特点：由于一维数组的线性关系，因此，一维数组中的每个元素最多有一个直接前驱和一个直接后继。类似的，在n维数组中，每个元素最多有n个直接前驱和n个直接后继。

 

运算：①给定一组下标，存取相应的数组元素。

②给定一组下标，修改相应的元素值。

由于这两个运算在内部实现时都需要计算出给定元素的实际存储地址，因此，计算数组元素地址这一运算就成了数组中最基本的运算。

 

2,栈:

栈（stack）又名堆栈，是一种数据结构,它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。进栈,弹栈.

后进先出的数据存取方式.

深度优先遍历中就用到该数据结构,例如在爬虫的深度优先搜索中,可以用一个栈结构来存储和取出未访问的url, 用列表存放已访问的url,栈空时深度优先遍历结束.

线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。

1. 进制转换
2. 在计算机中，使用栈存储函数调用过程

 

 

3,队列:

数据结构,队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队尾插入队前删除.

采用先进先出的存取方式;

在广度优先遍历中,采用队列存储和取出未访问的url,当队列为空时,广度优先遍历终止.

 

4,链表

是一种物理存储单元上非连续、非顺序的存储结构，它既可以表示线性结构，也可以用于表示非线性结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

顺序表和链表的区别

1. 顺序表查找快，增删慢
2. 链表查找慢，增删快
3. 顺序表的内存空间利用率比链表低

常见算法实现:

#冒泡排序，相邻元素对比，大的往后移动：时间复杂度：O(n^2)

# a =[1,6,3,4,9,2,1]

# n = len(a)

# for i in range(n-1):

#     for j in range(n-1-i):

#         if a[j]>a[j+1]:

#             a[j],a[j+1] = a[j+1],a[j]

# print(a)

 

# #选择排序，从选择首位元素分别对比其他元素，大的往后换：时间复杂度：O(n^2)

# a =[1,6,3,4,9,2,1]

# n = len(a)

# for i in range(n-1):

#     for j in range(i+1,n):

#         if a[i]>a[j]:

#             a[i],a[j] = a[j],a[i]

# print(a)

 

#快速排序：时间复杂度：O(log(n))

# def qSort(qlist):

#     if qlist == []:

#         return []

#     else:

#         qfirst = qlist[0]

#         lessPart = qSort([l for l in qlist[1:] if l < qfirst])

#         morePart = qSort([m for m in qlist[1:] if m >= qfirst])

#         return lessPart+[qfirst]+morePart

#

# a = [8,5,66,11,22,4,9,1,3,7]

# b = qSort(a)

# print(b)

 

#归并排序：把列表递归拆分为只包含一个元素的一个个列表，然后合并所有单元素列表

# def merge_sort(array):

#     #比较所有拆分过的列表元素，然后合并拆分后的列表

#     def merge_array(l_arr,r_arr):

#         array = []

#         while len(l_arr) and len(r_arr):

#             if l_arr[0] <= r_arr[0]:

#                 array.append(l_arr.pop(0))

#             elif l_arr[0] > r_arr[0]:

#                 array.append(r_arr.pop(0))

#         #左右两列表其中一个为空，另一个不是空时

#         if len(l_arr) != 0:

#             array += l_arr

#         elif len(r_arr) != 0:

#             array += r_arr

#         return array

#     #递归拆分列表：

#     def recursive(array):

#         if len(array) == 1:

#             return array

#         mid = len(array) // 2

#         l_arr = recursive(array[:mid])

#         r_arr = recursive(array[mid:])

#         return merge_array(l_arr,r_arr)#

#     return recursive(array)

# a = [3,5,1,2,11,55,22,4,6]

# print(merge_sort(a))

 

#二分查找：从有序列表的候选区data[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半

# 在一段数字内，找到中间值，判断要找的值和中间值大小的比较。

# 如果中间值大一些，则在中间值的左侧区域继续按照上述方式查找。

# 如果中间值小一些，则在中间值的右侧区域继续按照上述方式查 找。

# 直到找到我们希望的数字。

import time

def cal_time(func): #装饰器

    def wrapper(*args, **kwargs):

        t1 = time.time()

        result = func(*args, **kwargs)

        t2 = time.time()

        print("running time:",func.__name__, t2 - t1)

        return result

    return wrapper

@cal_time

def bin_search(data_set,val):

    #low 和high代表下标 最小下标，最大下标，在给定数集列表data_set中查找val这个值

    low=0

    high=len(data_set)-1

    while low <=high:# 只有当low小于High的时候证明中间有数

        mid=(low+high)//2

        if data_set[mid]==val:

            return mid  #返回他的下标

        elif data_set[mid]>val:

            high=mid-1

        else:

            low=mid+1

    return # return null证明没有找到

data_set = list(range(10000000))

print(bin_search(data_set, 999999))

二,树型数据结构

树：具有层次结构

（1）人类社会中的族谱和各种社会机构组织

（2）文件目录结构

（3） 网站结构

相关知识点:

1、结点(Node)：表示树中的数据元素，由数据项和数据元素之间的关系组成。在图中，共有10个结点。
　　2、结点的度(Degree of Node)：结点所拥有的子树的个数，在图中，结点A的度为3。
　　3、树的度(Degree of Tree)：树中各结点度的最大值。在图5.1中，树的度为3。
　　4、叶子结点(Leaf Node)：度为0的结点，也叫终端结点。在图5.1中，结点E、F、G、H、I、J都是叶子结点。
　　5、分支结点(Branch Node)：度不为0的结点，也叫非终端结点或内部结点。在图5.1中，结点A、B、C、D是分支结点。
　　6、孩子(Child)：结点子树的根。在图中，结点B、C、D是结点A的孩子。
　　7、双亲(Parent)：结点的上层结点叫该结点的双亲。在图中，结点B、C、D的双亲是结点A。
　　8、祖先(Ancestor)：从根到该结点所经分支上的所有结点。在图中，结点E的祖先是A和B。
　　9、子孙(Descendant)：以某结点为根的子树中的任一结点。在图中，除A之外的所有结点都是A的子孙。
　　10、兄弟(Brother)：同一双亲的孩子。在图5.1中，结点B、C、D互为兄弟。
　　11、结点的层次(Level of Node)：从根结点到树中某结点所经路径上的分支数称为该结点的层次。根结点的层次规定为1，其余结点的层次等于其双亲结点的层次加1。

12、堂兄弟(Sibling)：同一层的双亲不同的结点。在图中，G和H互为堂兄弟。
　　13、树的深度(Depth of Tree)：树中结点的最大层次数。在图5.1中，树的深度为3。

14、无序树(Unordered Tree)：树中任意一个结点的各孩子结点之间的次序构成无关紧要的树。通常树指无序树。

15、有序树(Ordered Tree)：树中任意一个结点的各孩子结点有严格排列次序的树。二叉树是有序树，因为二叉树中每个孩子结点都确切定义为是该结点的左孩子结点还是右孩子结点。

16、森林(Forest)：m(m≥0)棵树的集合。自然界中的树和森林的概念差别很大，但在数据结构中树和森林的概念差别很小。从定义可知，一棵树有根结点和m个子树构成，若把树的根结点删除，则树变成了包含m棵树的森林。当然，根据定义，一棵树也可以称为森林。

1,二叉树:

二叉树是数据结构中一种重要的数据结构，也是树表家族最为基础的结构。

二叉树的定义：二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2i-1个结点；深度为k的二叉树至多有2k-1个结点；对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。

2,完全二叉树,平衡二叉树,红黑树….