zoukankan      html  css  js  c++  java

  • 数据结构与算法(二）

    排序与搜索

    排序算法（英语：Sorting algorithm）是一种能将一串数据依照特定顺序进行排列的一种算法。

    排序算法的稳定性

    稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

    当相等的元素是无法分辨的，比如像是整数，稳定性并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。

    (4, 1)  (3, 1)  (3, 7)（5, 6）

    在这个状况下，有可能产生两种不同的结果，一个是让相等键值的纪录维持相对的次序，而另外一个则没有：

    (3, 1)  (3, 7)  (4, 1)  (5, 6)  （维持次序）
(3, 7)  (3, 1)  (4, 1)  (5, 6)  （次序被改变）

    不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被实现为稳定。做这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个对象间之比较，（比如上面的比较中加入第二个标准：第二个键值的大小）就会被决定使用在原先数据次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。

    冒泡排序

    冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

    冒泡排序算法的运作如下：

    • 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
    • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
    • 针对所有的元素重复以上的步骤，除了最后一个。
    • 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

    冒泡排序的分析

    交换过程图示(第一次)：

    那么我们需要进行n-1次冒泡过程。

     1 #!/usr/bin/eny python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 def bubble_sort(alist):
 6     for j in range(len(alist)-1,0,-1):
 7         # j表示每次遍历需要比较的次数，是逐渐减小的
 8         for i in range(j):
 9             if alist[i] > alist[i+1]:
10                 alist[i], alist[i+1] = alist[i+1], alist[i]
11 
12 li = [54,26,93,17,77,31,44,55,20]
13 bubble_sort(li)
14 print(li)
15 print len(li)
16 print range(9)

    结果：

    [17, 20, 26, 31, 44, 54, 55, 77, 93]

    时间复杂度

    • 最优时间复杂度：O(n) （表示遍历一次发现没有任何可以交换的元素，排序结束。）
    • 最坏时间复杂度：O(n2)
    • 稳定性：稳定

    选择排序

    选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

    选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

    选择排序分析

    排序过程：

     1 #!/usr/bin/eny python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 def selection_sort(alist):
 6     n = len(alist)
 7     # 需要进行n-1次选择操作
 8     for i in range(n-1):
 9         # 记录最小位置
10         min_index = i
11         # 从i+1位置到末尾选择出最小数据
12         for j in range(i+1, n):
13             if alist[j] < alist[min_index]:
14                 min_index = j
15         # 如果选择出的数据不在正确位置，进行交换
16         if min_index != i:
17             alist[i], alist[min_index] = alist[min_index], alist[i]
18 
19 alist = [54,226,93,17,77,31,44,55,20]
20 selection_sort(alist)
21 print(alist)

    结果：

    [17, 20, 31, 44, 54, 55, 77, 93, 226]

    时间复杂度

    • 最优时间复杂度：O(n2)
    • 最坏时间复杂度：O(n2)
    • 稳定性：不稳定（考虑升序每次选择最大的情况）

    插入排序

    插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

    插入排序分析

     1 #!/usr/bin/eny python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 def insert_sort(alist):
 6     # 从第二个位置，即下标为1的元素开始向前插入
 7     for i in range(1, len(alist)):
 8         # 从第i个元素开始向前比较，如果小于前一个元素，交换位置
 9         for j in range(i, 0, -1):
10             if alist[j] < alist[j-1]:
11                 alist[j], alist[j-1] = alist[j-1], alist[j]
12 
13 alist = [54,26,93,17,77,31,44,55,20]
14 insert_sort(alist)
15 print(alist)

    结果：

    [17, 20, 26, 31, 44, 54, 55, 77, 93]

    时间复杂度

    • 最优时间复杂度：O(n) （升序排列，序列已经处于升序状态）
    • 最坏时间复杂度：O(n2)
    • 稳定性：稳定

    快速排序

    快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

    步骤为：

    1. 从数列中挑出一个元素，称为"基准"（pivot），
    2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
    3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

    递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

    快速排序的分析

     

     1 #!/usr/bin/eny python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 def quick_sort(alist, start, end):
 6     """快速排序"""
 7 
 8     # 递归的退出条件
 9     if start >= end:
10         return
11 
12     # 设定起始元素为要寻找位置的基准元素
13     mid = alist[start]
14 
15     # low为序列左边的由左向右移动的游标
16     low = start
17 
18     # high为序列右边的由右向左移动的游标
19     high = end
20 
21     while low < high:
22         # 如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
23         while low < high and alist[high] >= mid:
24             high -= 1
25         # 将high指向的元素放到low的位置上
26         alist[low] = alist[high]
27 
28         # 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
29         while low < high and alist[low] < mid:
30             low += 1
31         # 将low指向的元素放到high的位置上
32         alist[high] = alist[low]
33 
34     # 退出循环后，low与high重合，此时所指位置为基准元素的正确位置
35     # 将基准元素放到该位置
36     alist[low] = mid
37 
38     # 对基准元素左边的子序列进行快速排序
39     quick_sort(alist, start, low-1)
40 
41     # 对基准元素右边的子序列进行快速排序
42     quick_sort(alist, low+1, end)
43 
44 
45 alist = [54,26,93,17,77,31,44,55,20]
46 quick_sort(alist,0,len(alist)-1)
47 print(alist)

    结果：

    [17, 20, 26, 31, 44, 54, 55, 77, 93]

    时间复杂度

    • 最优时间复杂度：O(nlogn)
    • 最坏时间复杂度：O(n2)
    • 稳定性：不稳定

    从一开始快速排序平均需要花费O(n log n)时间的描述并不明显。但是不难观察到的是分区运算，数组的元素都会在每次循环中走访过一次，使用O(n)的时间。在使用结合（concatenation）的版本中，这项运算也是O(n)。

    在最好的情况，每次我们运行一次分区，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递归调用处理一半大小的数列。因此，在到达大小为一的数列前，我们只要作log n次嵌套的调用。这个意思就是调用树的深度是O(log n)。但是在同一层次结构的两个程序调用中，不会处理到原来数列的相同部分；因此，程序调用的每一层次结构总共全部仅需要O(n)的时间（每个调用有某些共同的额外耗费，但是因为在每一层次结构仅仅只有O(n)个调用，这些被归纳在O(n)系数中）。结果是这个算法仅需使用O(n log n)时间。

    希尔排序

    希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

    希尔排序过程

    希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

     1 def shell_sort(alist):
 2     n = len(alist)
 3     # 初始步长
 4     gap = n / 2
 5     while gap > 0:
 6         # 按步长进行插入排序
 7         for i in range(gap, n):
 8             j = i
 9             # 插入排序
10             while j>=gap and alist[j-gap] > alist[j]:
11                 alist[j-gap], alist[j] = alist[j], alist[j-gap]
12                 j -= gap
13         # 得到新的步长
14         gap = gap / 2
15 
16 alist = [54,26,93,17,77,31,44,55,20]
17 shell_sort(alist)
18 print(alist)

    时间复杂度

    • 最优时间复杂度：根据步长序列的不同而不同
    • 最坏时间复杂度：O(n2)
    • 稳定想：不稳定

    归并排序

    归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

    将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

    def merge_sort(alist):
    if len(alist) <= 1:
        return alist
    # 二分分解
    num = len(alist)/2
    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])
    # 合并
    return merge(left,right)

def merge(left, right):
    '''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
    #left与right的下标指针
    l, r = 0, 0
    result = []
    while l<len(left) and r<len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result

alist = [54,26,93,17,77,31,44,55,20]
sorted_alist = mergeSort(alist)
print(sorted_alist)

    时间复杂度

    • 最优时间复杂度：O(nlogn)
    • 最坏时间复杂度：O(nlogn)
    • 稳定性：稳定

    常见排序算法效率比较

     

     

    搜索

    搜索是在一个项目集合中找到一个特定项目的算法过程。搜索通常的答案是真的或假的，因为该项目是否存在。 搜索的几种常见方法：顺序查找、二分法查找、二叉树查找、哈希查找

    二分法查找

    二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

     

    二分法查找实现（非递归实现）

     1 def binary_search(alist, item):
 2       first = 0
 3       last = len(alist)-1
 4       while first<=last:
 5           midpoint = (first + last)/2
 6           if alist[midpoint] == item:
 7               return True
 8           elif item < alist[midpoint]:
 9               last = midpoint-1
10           else:
11               first = midpoint+1
12     return False
13 testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
14 print(binary_search(testlist, 3))
15 print(binary_search(testlist, 13))

    （递归实现）

     1 def binary_search(alist, item):
 2     if len(alist) == 0:
 3         return False
 4     else:
 5         midpoint = len(alist)//2
 6         if alist[midpoint]==item:
 7           return True
 8         else:
 9           if item<alist[midpoint]:
10             return binary_search(alist[:midpoint],item)
11           else:
12             return binary_search(alist[midpoint+1:],item)
13 
14 testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
15 print(binary_search(testlist, 3))
16 print(binary_search(testlist, 13))

    时间复杂度

    • 最优时间复杂度：O(1)
    • 最坏时间复杂度：O(logn)

    树与树算法

    树的概念

    树（英语：tree）是一种抽象数据类型（ADT）或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

    • 每个节点有零个或多个子节点；
    • 没有父节点的节点称为根节点；
    • 每一个非根节点有且只有一个父节点；
    • 除了根节点外，每个子节点可以分为多个不相交的子树；

    树的术语

    • 节点的度：一个节点含有的子树的个数称为该节点的度；
    • 树的度：一棵树中，最大的节点的度称为树的度；
    • 叶节点或终端节点：度为零的节点；
    • 父亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
    • 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
    • 兄弟节点：具有相同父节点的节点互称为兄弟节点；
    • 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
    • 树的高度或深度：树中节点的最大层次；
    • 堂兄弟节点：父节点在同一层的节点互为堂兄弟；
    • 节点的祖先：从根到该节点所经分支上的所有节点；
    • 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
    • 森林：由m（m>=0）棵互不相交的树的集合称为森林；

    树的种类

    • 无序树：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树；
    • 有序树：树中任意节点的子节点之间有顺序关系，这种树称为有序树；
      • 二叉树：每个节点最多含有两个子树的树称为二叉树；
        • 完全二叉树：对于一颗二叉树，假设其深度为d(d>1)。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树，其中满二叉树的定义是所有叶节点都在最底层的完全二叉树;
        • 平衡二叉树（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树；
        • 排序二叉树（二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树）；
      • 霍夫曼树（用于信息编码）：带权路径最短的二叉树称为哈夫曼树或最优二叉树；
      • B树：一种对读写操作进行优化的自平衡的二叉查找树，能够保持数据有序，拥有多余两个子树。

    树的存储与表示

    顺序存储：将数据结构存储在固定的数组中，然在遍历速度上有一定的优势，但因所占空间比较大，是非主流二叉树。二叉树通常以链式存储。

     

    链式存储

    由于对节点的个数无法掌握，常见树的存储表示都转换成二叉树进行处理，子节点个数最多为2

    常见的一些树的应用场景

    1.xml，html等，那么编写这些东西的解析器的时候，不可避免用到树
    2.路由协议就是使用了树的算法
    3.mysql数据库索引
    4.文件系统的目录结构
    5.所以很多经典的AI算法其实都是树搜索，此外机器学习中的decision tree也是树结构

    二叉树

    二叉树的基本概念

    二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）

    二叉树的性质(特性)

    性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0）
    性质2: 深度为k的二叉树至多有2^k - 1个结点（k>0）
    性质3: 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
    性质4:具有n个结点的完全二叉树的深度必为 log2(n+1)
    性质5:对完全二叉树，若从上至下、从左至右编号，则编号为i 的结点，其左孩子编号必为2i，其右孩子编号必为2i＋1；其双亲的编号必为i/2（i＝1 时为根,除外）

    (1)完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。
    完全二叉树

    (2)满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。满二叉树

    二叉树的遍历

    树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的信息的访问，即依次对树中每个结点访问一次且仅访问一次，我们把这种对所有节点的访问称为遍历（traversal）。那么树的两种重要的遍历模式是深度优先遍历和广度优先遍历,深度优先一般用递归，广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。 

    深度优先遍历

    对于一颗二叉树，深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。
    那么深度遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder），中序遍历（inorder）和后序遍历（postorder）。

    • 先序遍历 在先序遍历中，我们先访问根节点，然后递归使用先序遍历访问左子树，再递归使用先序遍历访问右子树
      根节点->左子树->右子树
    • 中序遍历 在中序遍历中，我们递归使用中序遍历访问左子树，然后访问根节点，最后再递归使用中序遍历访问右子树
      左子树->根节点->右子树
    • 后序遍历 在后序遍历中，我们先递归使用后序遍历访问左子树和右子树，最后访问根节点
      左子树->右子树->根节点

    广度优先遍历(层次遍历)

    从树的root开始，从上到下从从左到右遍历整个树的节点
  • 相关阅读:
    基于jquery自己写滑动门(通用版)
    这一年,做为asp.net程序员我合格吗?
    基于jquery的滚动条滚动固定div(附Demo)
    asp.net获取数据随机显示(原创)
    为昨天一篇博文【asp.net,对于一个有点经验的猴子,我的要求高么?】做点解释
    2012年总结，2013年更精彩。
    放大镜
    be strong
    模拟凡客导航
    Ajax中Get请求与Post请求的区别（转载）
  • 原文地址：https://www.cnblogs.com/jiangzijiang/p/8509675.html
Copyright © 2011-2022 走看看