数据结构算法学习（一）
数据结构算法学习（一）
简单地说，数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对于某些操作是高效的，而对于其他操作则是低效的。首先我们需要理解各种数据结构，才能在处理实际问题时选取最合适的数据结构。
常用数据结构
常用的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等
1. 数组
- 简介
数组是可以再内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进行访问，数组下标从0开始
- 实例
NSArray *array = [NSArray arrayWithObjects:@"1",@"2",@"3",@"4", nil];
// NSArray *array = @[@"1",@"2",@"3",@"4"];
NSLog(@"%@",array[0]);
- 优点
1、按照索引查询元素速度快
2、按照索引遍历数组方便 - 缺点
1、数组的大小固定后就无法扩容了
2、数组只能存储一种类型的数据
3、添加，删除的操作慢，因为要移动其他的元素。 - 用法
- 数组的基本操作
Insert——在指定索引位置插入一个元素
Get——返回指定索引位置的元素
Delete——删除指定索引位置的元素
Size——得到数组所有元素的数量 - 实用场景
频繁查询，对存储空间要求不大，很少增加和删除的情况。 - 面试中关于数组的常见问题
寻找数组中第二小的元素
找到数组中第一个不重复出现的整数
合并两个有序数组
重新排列数组中的正值和负值
2. 栈
- 简介
栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。栈的特点是：先进后出，或者说是后进先出，从栈顶放入元素的操作叫入栈，取出元素叫出栈。
线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）
2. 实例
-
优点
-
缺点
-
用法
-
栈的基本操作
Push——在顶部插入一个元素
Pop——返回并移除栈顶元素
isEmpty——如果栈为空，则返回true
Top——返回顶部元素，但并不移除它 -
面试中关于栈的常见问题
使用栈计算后缀表达式
对栈的元素进行排序
判断表达式是否括号平衡
3. 链表
- 简介
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
根据指针的指向，链表能形成不同的结构，例如单链表，双向链表，循环链表等。
如图所示：
- 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
-
实例
-
优点
链表是很常用的一种数据结构，不需要初始化容量，可以任意加减元素；
添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可，所以添加，删除很快； -
缺点
因为含有大量的指针域，占用空间较大；
查找元素需要遍历链表来查找，非常耗时。 -
用法
链表是另一个重要的线性数据结构，乍一看可能有点像数组，但在内存分配、内部结构以及数据插入和删除的基本操作方面均有所不同。
链表就像一个节点链，其中每个节点包含着数据和指向后续节点的指针。 链表还包含一个头指针，它指向链表的第一个元素，但当列表为空时，它指向null或无具体内容。
链表一般用于实现文件系统、哈希表和邻接表。 -
适用场景
数据量较小，需要频繁增加，删除操作的场景 -
链表的基本操作：
InsertAtEnd - 在链表的末尾插入指定元素
InsertAtHead - 在链接列表的开头/头部插入指定元素
Delete - 从链接列表中删除指定元素
DeleteAtHead - 删除链接列表的第一个元素
Search - 从链表中返回指定元素
isEmpty - 如果链表为空，则返回true -
面试中关于链表的常见问题
反转链表
检测链表中的循环
返回链表倒数第N个节点
删除链表中的重复项
4. 队列
-
简介
与栈相似，队列是另一种顺序存储元素的线性数据结构。栈与队列的最大差别在于栈是LIFO（后进先出），而队列是FIFO，即先进先出。
一个完美的队列现实例子：售票亭排队队伍。如果有新人加入，他需要到队尾去排队，而非队首——排在前面的人会先拿到票，然后离开队伍。
下图是包含四个元素（1，2，3和4）的队列，其中在顶部的1将被最先移除：
移除先入队的元素、插入新元素
-
实例
-
优点
-
缺点
-
用法
-
队列的基本操作
Enqueue()——在队列尾部插入元素
Dequeue()——移除队列头部的元素
isEmpty()——如果队列为空，则返回true
Top()——返回队列的第一个元素 -
面试中关于队列的常见问题
使用队列表示栈
对队列的前k个元素倒序
使用队列生成从1到n的二进制数
5. 树
- 简介
树形结构是一种层级式的数据结构，由顶点（节点）和连接它们的边组成。 树类似于图，但区分树和图的重要特征是树中不存在环路。
树形结构被广泛应用于人工智能和复杂算法，它可以提供解决问题的有效存储机制。
这是一个简单树的示意图，以及树数据结构中使用的基本术语：
Root - 根节点
Parent - 父节点
Child - 子节点
Leaf - 叶子节点
Sibling - 兄弟节点
以下是树形结构的主要类型：
- N元树
- 平衡树
- 二叉树
- 二叉搜索树
- AVL树
- 红黑树
- 2-3树
其中，二叉树和二叉搜索树是最常用的树。
树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：
每个节点有零个或多个子节点；
没有父节点的节点称为根节点；
每一个非根节点有且只有一个父节点；
除了根节点外，每个子节点可以分为多个不相交的子树；
在日常的应用中，我们讨论和用的更多的是树的其中一种结构，就是二叉树
二叉树是树的特殊一种，具有如下特点：
1、每个结点最多有两颗子树，结点的度最大为2。
2、左子树和右子树是有顺序的，次序不能颠倒。
3、即使某结点只有一个子树，也要区分左右子树。
二叉树是一种比较有用的折中方案，它添加，删除元素都很快，并且在查找方面也有很多的算法优化，所以，二叉树既有链表的好处，也有数组的好处，是两者的优化方案，在处理大批量的动态数据方面非常有用。
二叉树有很多扩展的数据结构，包括平衡二叉树、红黑树、B+树等，这些数据结构二叉树的基础上衍生了很多的功能，在实际应用中广泛用到，例如mysql的数据库索引结构用的就是B+树，还有HashMap的底层源码中用到了红黑树。这些二叉树的功能强大，但算法上比较复杂，想学习的话还是需要花时间去深入的。
-
实例
-
优点
-
缺点
-
用法
-
面试中关于树结构的常见问题：
求二叉树的高度
在二叉搜索树中查找第k个最大值
查找与根节点距离k的节点
在二叉树中查找给定节点的祖先节点
6. 图
- 简介
图是一组以网络形式相互连接的节点。节点也称为顶点。 一对节点（x，y）称为边（edge），表示顶点x连接到顶点y。边可以包含权重/成本，显示从顶点x到y所需的成本。
图的类型
无向图
有向图
常见图遍历算法
广度优先搜索
深度优先搜索
-
实例
-
优点
-
缺点
-
用法
-
面试中关于图的常见问题
实现广度和深度优先搜索
检查图是否为树
计算图的边数
找到两个顶点之间的最短路径
7. 堆
- 简介
堆是一种比较特殊的数据结构，可以被看做一棵树的数组对象，具有以下的性质：
堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。
将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。
堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。
(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2)，
满足前者的表达式的成为小顶堆，满足后者表达式的为大顶堆，这两者的结构图可以用完全二叉树排列出来
-
实例
-
优点
-
缺点
-
用法
8. 散列
- 简介
散列表，也叫哈希表，是根据关键码和值 (key和value) 直接进行访问的数据结构，通过key和value来映射到集合中的一个位置，这样就可以很快找到集合中的对应元素。
记录的存储位置=f(key)
这里的对应关系f 成为散列函数，又称为哈希 (hash函数)，而散列表就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，
然后就将该数字对数组长度进行取余，取余结果就当作数组的下标
将value存储在以该数字为下标的数组空间里
这种存储空间可以充分利用数组的查找优势来查找元素，所以查找的速度很快。
哈希表在应用中也是比较常见的，就如Java中有些集合类就是借鉴了哈希原理构造的，例如HashMap，HashTable等，利用hash表的优势，对于集合的查找元素时非常方便的，然而，因为哈希表是基于数组衍生的数据结构，在添加删除元素方面是比较慢的，所以很多时候需要用到一种数组链表来做，也就是拉链法。拉链法是数组结合链表的一种结构，较早前的hashMap底层的存储就是采用这种结构，直到jdk1.8之后才换成了数组加红黑树的结构.iOS中weak表（弱引用表）就是典型的哈希表
左边很明显是个数组，数组的每个成员包括一个指针，指向一个链表的头，
当然这个链表可能为空，也可能元素很多。
我们根据元素的一些特征把元素分配到不同的链表中去，
也是根据这些特征，找到正确的链表，再从链表中找出这个元素。
哈希表的应用场景很多，当然也有很多问题要考虑，比如哈希冲突的问题，如果处理的不好会浪费大量的时间，导致应用崩溃。
-
实例
-
优点
-
缺点
-
用法
哈希法（Hashing）是一个用于唯一标识对象并将每个对象存储在一些预先计算的唯一索引（称为“键（key）”）中的过程。因此，对象以键值对的形式存储，这些键值对的集合被称为“字典”。可以使用键搜索每个对象。基于哈希法有很多不同的数据结构，但最常用的数据结构是哈希表。
哈希表通常使用数组实现。
散列数据结构的性能取决于以下三个因素：
哈希函数
哈希表的大小
碰撞处理方法
- 面试中关于哈希结构的常见问题：
在数组中查找对称键值对
追踪遍历的完整路径
查找数组是否是另一个数组的子集
检查给定的数组是否不相交
9. 字典树（Trie）
- 简介
字典树，也称为“前缀树”，是一种特殊的树状数据结构，对于解决字符串相关问题非常有效。它能够提供快速检索，主要用于搜索字典中的单词，在搜索引擎中自动提供建议，甚至被用于IP的路由。
以下是在字典树中存储三个单词“top”，“so”和“their”的例子：
这些单词以顶部到底部的方式存储，其中绿色节点“p”，“s”和“r”分别表示“top”，“thus”和“theirs”的底部。
- 面试中关于字典树的常见问题
计算字典树中的总单词数
打印存储在字典树中的所有单词
使用字典树对数组的元素进行排序
使用字典树从字典中形成单词
构建T9字典（字典树+ DFS ）
常用算法
算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决，可能会存在着不同的算法，为了衡量一个算法的优劣，提出了空间复杂度与时间复杂度这两个概念。
- 时间复杂度
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，算法的时间度量记为 ** T(n) = O(f(n)) **，它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度。这里需要重点理解这个增长率。
//举个例子，看下面3个代码：
1、{++x;}
2、for(i = 1; i <= n; i++) { ++x; }
3、for(j = 1; j <= n; j++)
for(j = 1; j <= n; j++)
{ ++x; }
//上述含有 ++x 操作的语句的频度分别为1 、n 、n^2，
//假设问题的规模扩大了n倍，3个代码的增长率分别是1 、n 、n^2
//它们的时间复杂度分别为O(1)、O(n )、O(n^2)
- 空间复杂度
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。
1. 排序相关算法
常用的算法一般为快速排序、归并排序、希尔排序等。特别的，如果一个序列基本成有序，插入排序是最快的。
1. 插入排序
- 时间复查度：O(n^2)
最好情况下，当待排序序列中记录已经有序时，则需要n-1次比较，不需要移动，时间复杂度为** O(n) 。最差情况下，当待排序序列中所有记录正好逆序时，则比较次数和移动次数都达到最大值，时间复杂度为 O(n^2) 。平均情况下，时间复杂度为 O(n^2) **。
- 简介
直接插入的思想是：是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。
例如，排序序列(3,2,1,5)的过程是，初始时有序序列为(3)，然后从位置1开始，先访问到2，将2插入到3前面，得到有序序列(2,3)，之后访问1,找到合适的插入位置后得到有序序列(1,2,3)，最后访问5，得到最终有序序列(1,2,3,5).
- 算法
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
算法步骤：
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
原始：5 4 1 3 6 7 8 2
第一趟：4 5 1 3 6 7 8 2
第二趟：1 4 5 3 6 7 8 2
- 代码实现
static void funDInsertSort(int[] array) {
int j;
for (int i = 1; i < array.length; i++) {
int temp = array[i];
j = i - 1;
while (j > -1 && temp < array[j]) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
2. 希尔排序
-
时间复查度：O(nlog(n))
-
简介
希尔排序又称“缩小增量排序”，它是基于直接插入排序的以下两点性质而提出的一种改进：(1) 直接插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。(2) 直接插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位
由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
- 算法
算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。
注意：增量的选择尤为重要，一种参考h=3*d+1进行迭代。
说明一下：每一趟分组后进行排序，按照小到大顺序，交换位置
第一趟中： 592 72交换位置，但是该数据在原始数据的位置仍然不变。
（1，592）----（6，72）交换后（1，72）—（6，592）
第二趟中：（1，72）–（3，874）–（5，283）–（7，911）–（9，820）
交换排序后（1，72）–（3，283）–（5，820）–（7，874）–（9，911）
- 代码实现
//Shell排序的算法实现:
//1． 不设监视哨的算法描述
void ShellPass(SeqList R，int d)
{//希尔排序中的一趟排序，d为当前增量
for(i=d+1;i<=n；i++) //将R[d+1．．n]分别插入各组当前的有序区
if(R[ i ].key<R[i-d].key){
R[0]=R[i];j=i-d； //R[0]只是暂存单元，不是哨兵
do {//查找R的插入位置
R[j+d]=R[j]； //后移记录
j=j-d； //查找前一记录
}while(j>0&&R[0].key<R[j].key)；
R[j+d]=R[0]； //插入R到正确的位置上
} //endif
c实现代码：
#include<stdio.h>
#include<math.h>
#define MAXNUM 10
void main()
{
void shellSort(int array[],int n,int t);//t为排序趟数
int array[MAXNUM],i;
for(i=0;i<MAXNUM;i++)
scanf("%d",&array[i]);
shellSort(array,MAXNUM,(int)(log(MAXNUM+1)/log(2)));//排序趟数应为log2(n+1)的整数部分
for(i=0;i<MAXNUM;i++)
printf("%d ",array[i]);
printf("\n");
}
//根据当前增量进行插入排序
void shellInsert(int array[],int n,int dk)
{
int i,j,temp;
for(i=dk;i<n;i++)//分别向每组的有序区域插入
{
temp=array[i];
for(j=i-dk;(j>=i%dk)&&array[j]>temp;j-=dk)//比较与记录后移同时进行
array[j+dk]=array[j];
if(j!=i-dk)
array[j+dk]=temp;//插入
}
}
//计算Hibbard增量
int dkHibbard(int t,int k)
{
return (int)(pow(2,t-k+1)-1);
}
//希尔排序
void shellSort(int array[],int n,int t)
{
void shellInsert(int array[],int n,int dk);
int i;
for(i=1;i<=t;i++)
shellInsert(array,n,dkHibbard(t,i));
}
//此写法便于理解，实际应用时应将上述三个函数写成一个函数。
3. 选择排序
-
时间复查度：O(n^2)
-
算法
算法步骤：
1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3）重复第二步，直到所有元素均排序完毕。
例子：5 8 3 6 4
第一趟：用除去第一个元素5以外的其余元素的最小值（为3）来与5比较，最小的交换（5>3）
3 8 5 6 4
第二趟：同理，用除去第二个元素8以外的其余元素的最小值（为4）来与8比较
3 4 5 6 8
- 代码实现
static void funSelectionSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
int mink = i;
// 每次从未排序数组中找到最小值的坐标
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[mink]) {
mink = j;
}
}
// 将最小值放在最前面
if (mink != i) {
int temp = array[mink];
array[mink] = array[i];
array[i] = temp;
}
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
- 分析
简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2，即进行比较操作的时间复杂度为 O(n^2) ，进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。
最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。最坏情况下，即待排序记录初始状态是按第一条记录最大，之后的记录从小到大顺序排列，则需要移动记录的次数最多为3（n-1）。
简单选择排序是不稳定排序。
4. 冒泡排序
- 时间复查度：O(n^2)
最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序，不需要进行下一次遍历，所以最佳情况下，时间复杂度为** O(n) 。
最坏情况下冒泡排序需要n-1次遍历，第一次遍历需要比较n-1次，第二次遍历需要n-2次，…，最后一次需要比较1次，最差情况下时间复杂度为 O(n^2) **。
-
简介
冒泡排序的基本思想是：设排序序列的记录个数为n，进行n-1次遍历，每次遍历从开始位置依次往后比较前后相邻元素，这样较大的元素往后移，n-1次遍历结束后，序列有序。 -
算法
算法步骤：
1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3）针对所有的元素重复以上的步骤，除了最后一个。
4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
5 3 8 4 7 假设从小到大，从后面第一个开始：
5 3 4 8 7
3 5 4 8 7 ----第一次排序结束，最小的在前面
3 5 4 7 8
3 4 5 7 8 ----第二次排序结束，第二最小排好
结束
- 代码实现
// 冒泡排序 注意 flag 的作用
static void funBubbleSort(int[] array) {
boolean flag = true;
for (int i = 0; i < array.length - 1 && flag; i++) {
flag = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
flag = true;
}
}
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
5. 快速排序
- 时间复查度：O(nlogn)
- 简介
快速排序的主要思想是：在待排序的序列中选择一个称为主元的元素，将数组分为两部分，使得第一部分中的所有元素都小于或等于主元，而第二部分中的所有元素都大于主元，然后对两部分递归地应用快速排序算法。其实其思想是来自冒泡排序，冒泡排序是通过相邻元素的比较和交换把最小的冒泡到最顶端，而快速排序是比较和交换小数和大数，这样一来不仅把小数冒泡到上面同时也把大数沉到下面。
- 算法
- 代码实现
// 快速排序
static void funQuickSort(int[] mdata, int start, int end) {
if (end > start) {
int pivotIndex = quickSortPartition(mdata, start, end);
funQuickSort(mdata, start, pivotIndex - 1);
funQuickSort(mdata, pivotIndex + 1, end);
}
}
// 快速排序前的划分
static int quickSortPartition(int[] list, int first, int last) {
int pivot = list[first];
int low = first + 1;
int high = last;
while (high > low) {
while (low <= high && list[low] <= pivot) {
low++;
}
while (low <= high && list[high] > pivot) {
high--;
}
if (high > low) {
int temp = list[high];
list[high] = list[low];
list[low] = temp;
}
}
while (high > first && list[high] >= pivot) {
high--;
}
if (pivot > list[high]) {
list[first] = list[high];
list[high] = pivot;
return high;
} else {
return first;
}
}
- 分析
在快速排序算法中，比较关键的一个部分是主元的选择。在最差情况下，划分由n个元素构成的数组需要进行n次比较和n次移动，因此划分需要的时间是O(n)。在最差情况下，每次主元会将数组划分为一个大的子数组和一个空数组，这个大的子数组的规模是在上次划分的子数组的规模上减1，这样在最差情况下算法需要(n-1)+(n-2)+…+1= ** O(n^2) 时间。
最佳情况下，每次主元将数组划分为规模大致相等的两部分，时间复杂度为 O(nlogn) **。
6. 归并排序
- 时间复查度：O(nlogn）
归并排序的时间复杂度为O(nlogn)，它是一种稳定的排序。 - 简介
归并排序是另一种不同的排序方法，因为归并排序使用了递归分治的思想，所以理解起来比较容易。其基本思想是，先递归划分子问题，然后合并结果。把待排序列看成由两个有序的子序列，然后合并两个子序列，然后把子序列看成由两个有序序列。倒着来看，其实就是先两两合并，然后四四合并。。。最终形成有序序列。空间复杂度为O(n)，时间复杂度为O(nlogn)。
- 算法
例如，排序序列(3,2,8,6,7,9,1,5)的过程是，先将序列分为两部分，(3,2,8,6)和(7,9,1,5)，然后对两部分分别应用归并排序，第1部分(3,2,8,6)，第2部分(7,9,1,5)，对两个部分分别进行归并排序，第1部分继续分为(3,2)和(8,6)，(3,2)继续分为(3)和(2)，(8,6)继续分为(8)和(6)，之后进行合并得到(2,3)，(6,8)，再合并得到(2,3,6,8)，第2部分进行归并排序得到(1,5,7,9)，最后合并两部分得到(1,2,3,5,6,7,8,9)。
- 代码实现
//归并排序
static void funMergeSort(int[] array) {
if (array.length > 1) {
int length1 = array.length / 2;
int[] array1 = new int[length1];
System.arraycopy(array, 0, array1, 0, length1);
funMergeSort(array1);
int length2 = array.length - length1;
int[] array2 = new int[length2];
System.arraycopy(array, length1, array2, 0, length2);
funMergeSort(array2);
int[] datas = merge(array1, array2);
System.arraycopy(datas, 0, array, 0, array.length);
}
}
//合并两个数组
static int[] merge(int[] list1, int[] list2) {
int[] list3 = new int[list1.length + list2.length];
int count1 = 0;
int count2 = 0;
int count3 = 0;
while (count1 < list1.length && count2 < list2.length) {
if (list1[count1] < list2[count2]) {
list3[count3++] = list1[count1++];
} else {
list3[count3++] = list2[count2++];
}
}
while (count1 < list1.length) {
list3[count3++] = list1[count1++];
}
while (count2 < list2.length) {
list3[count3++] = list2[count2++];
}
return list3;
}
7. 堆排序
-
时间复查度：
-
简介
在介绍堆排序之前首先需要了解堆的定义，n个关键字序列K1，K2，…，Kn称为堆，当且仅当该序列满足如下性质（简称为堆性质）：(1) ki <= k(2i）且 ki <= k(2i+1) (1 ≤ i≤ n/2），当然，这是小根堆，大根堆则换成>=号。
如果将上面满足堆性质的序列看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有的非终端节点的值均不大于（或不小于）其左右孩子节点的值。
堆排序的主要思想是：给定一个待排序序列，首先经过一次调整，将序列构建成一个大顶堆，此时第一个元素是最大的元素，将其和序列的最后一个元素交换，然后对前n-1个元素调整为大顶堆，再将其第一个元素和末尾元素交换，这样最后即可得到有序序列。
- 算法
基本过程：
a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
- 代码实现
//堆排序
public class TestHeapSort {
public static void main(String[] args) {
int arr[] = { 5, 6, 1, 0, 2, 9 };
heapsort(arr, 6);
System.out.println(Arrays.toString(arr));
}
static void heapsort(int arr[], int n) {
// 先建大顶堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapAdjust(arr, i, n);
}
for (int i = 0; i < n - 1; i++) {
swap(arr, 0, n - i - 1);
heapAdjust(arr, 0, n - i - 1);
}
}
// 交换两个数
static void swap(int arr[], int low, int high) {
int temp = arr[low];
arr[low] = arr[high];
arr[high] = temp;
}
// 调整堆
static void heapAdjust(int arr[], int index, int n) {
int temp = arr[index];
int child = 0;
while (index * 2 + 1 < n) {
child = index * 2 + 1;
// child为左右孩子中较大的那个
if (child != n - 1 && arr[child] < arr[child + 1]) {
child++;
}
// 如果指定节点大于较大的孩子 不需要调整
if (temp > arr[child]) {
break;
} else {
// 否则继续往下判断孩子的孩子 直到找到合适的位置
arr[index] = arr[child];
index = child;
}
}
arr[index] = temp;
}
}
- 分析
由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn)，空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比，堆排序在最差情况下的时间复杂度优于快排，空间效率高于归并排序。
2. 查找相关算法
1. 顺序查找
顺序查找又称线性查找。它的过程为：从查找表的最后一个元素开始逐个与给定关键字比较，若某个记录的关键字和给定值比较相等，则查找成功，否则，若直至第一个记录，其关键字和给定值比较都不等，则表明表中没有所查记录查找不成功，它的缺点是效率低下。
2. 二分查找
- 简介
二分查找又称折半查找，对于有序表来说，它的优点是比较次数少，查找速度快，平均性能好。
二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x，算法中止；如果x<a[n/2]，则只要在数组a的左半部分继续搜索x，如果x>a[n/2]，则只要在数组a的右半部搜索x。
二分查找的时间复杂度为O(logn) - 算法
- 代码实现
//给定有序查找表array 二分查找给定的值data
//查找成功返回下标 查找失败返回-1
static int funBinSearch(int[] array, int data) {
int low = 0;
int high = array.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (data == array[mid]) {
return mid;
} else if (data < array[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}
3. 经典算法
3.1.递归算法
- 简介
在平常解决一些编程或者做一些算法题的时候，经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。
- 实例代码
- 斐波那契数列，又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）。
//斐波那契数列 递归实现
static long funFib(long index) {
if (index == 0) {
return 0;
} else if (index == 1) {
return 1;
} else {
return funFib(index - 1) + funFib(index - 2);
}
}
上面代码是斐波那契数列的递归实现，然而我们不难得到它的时间复杂度是O(2^n)，递归有时候可以很方便地解决一些问题，但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式，效率比递归方法的效率高。
static long funFib2(long index) {
long f0 = 0;
long f1 = 1;
long f2 = 1;
if (index == 0) {
return f0;
} else if (index == 1) {
return f1;
} else if (index == 2) {
return f2;
}
for (int i = 3; i <= index; i++) {
f0 = f1;
f1 = f2;
f2 = f0 + f1;
}
return f2;
}
- 分析
3.2.分治算法
- 简介
分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题，递归地求解这些子问题，然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。百度讲解
- 实例
- 分析
3.3.动态规划
- 简介
动态规划与分治方法相似，都是通过组合子问题的解来求解待解决的问题。但是，分治算法将问题划分为互不相交的子问题，递归地求解子问题，再将它们的解组合起来，而动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。查看更多关于动态规划的内容百度百科介绍
动态规划典型的一个例子是最长公共子序列问题可以参考大神播客。
4. 链表相关算法
需要掌握的算法
- 图搜索 （广度优先、深度优先）
- 排序
- 动态规划
- 匹配算法和网络流算法
- 正则表达式和字符串匹配
- 贪婪算法
- 概率方法
- 近似算法
- 三路划分-快速排序
- 合并排序（更具扩展性，复杂度类似快速排序）
- DF/BF 搜索 （要知道使用场景）
- Prim / Kruskal （最小生成树）
- Dijkstra （最短路径算法）
- 选择算法
- 遗传算法
比较好的算法学习文章：
674
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
