数据结构入门

线性表

线性表的逻辑结构

1.定义

• 线性表(Linear_List)是零个或多个数据元素的有限序列,
• 通常可表示成 : $a_1,a_2,...,a_n(n>=0)$
• n:表的长度； $a_i$是$a_{i+1}$的前驱；$a_i$是$a_{i+1}$的后继；i 称为$a_i$的索引。

2.结构类型

• 线性表的逻辑结构是线性结构
• 基本特征 : 若至少含有一个节点,
• 则除起始节点没有直接前驱外,其他节点有且只有一个前驱
• 除终端节点没有直接后继外,其他节点有且仅有一个直接后继

线性表的基本运算

Initiate(&L):初始化操作, 设定一个空的线性表
Length(L):求长度, 其结果是线性表L的长度
Get(L,i):读表元,
若1<=i<=Length(L),其结果是线性表L的第i个数据元素;否则,其结果为一特殊值.
Locate(L,x):定位运算,
若L中存在一个或多个与x值相等的元素,则运算结果为这些元素序号的最小值,否则运算结果为0
Insert(L,i,x):插入运算,
其作用是在线性表L的第i个位置上(即原第i个元素之前)增加一个以x为值的新元素,使L由($a_1,a_2,...,a_i,a_{i+1},...,a_n$)变为($a_1,a_2,...,x,a_i,a_{i+1},...,a_n$)
Delete(L,i):删除运算,
其作用是删除线性表L的第i个数据元素$a_i$,使L由($a_1,a_2,...,a_i,a_{i+1},...,a_n$)变为($a_1,a_2,...,a_{i-1},a_{i+1},...,a_n$),i的合法取值:1~n.

线性表的顺序存储结构

• 顺序存储分配,即用一组连续的存储单元一次存储线性表的各个元素

• 若线性表的每个元素占用C个连续的存储单元,则表中第i个元素的寻址公式为:

• Local($a_i$)=Loc($a_1$)+(i-1)*C (1<=i<=n)

用C语言定义线性表的顺序存储结构如下:
typedef ElemType Linear_list[n];

其中ElemType数据类型是为了描述的统一而自定的
$a_1$在线性表中的序号为1,其对应的数组的下标为0;
$a_i$在线性表中的序号为i,其对应的数组的下标为i-1;

线性表基本运算的实现(顺序存储分配的情况下)

线性表的插入运算 Insert (Linear_list &L,int i,ElemType x,int &n)

void Insert(Linear_list &L, int i, ElemType x, int &n)
/*
*在长度为 n 的线性表的第 i 个元素之前插入一个元素 x,
* L 为存储线性表的向量,且假定其上界大于n
*/
{
    if(i>=0 && i<=n)
    {
      for(int j=n-1;j>=i-1)
          L[j+1]=L[j];
      L[i-1]=x;
      n=n+1;
    }
    else error("插入的位置非法");
}

线性表中数据元素的删除 Delete(Linear_list &L,int i,int &n)

void Delete(Linear_list &L, int i, int &n)
{
    if(i>=0 && i<=n)
    {
        for(int j=i;j++;j<n)
            L[j-1]=L[j];
        n=n-1;
    }
    else error("非法删除");
}

定位运算 Locate (Linear_list &L,ElemType x,int &n)

int Locate(Linear_list &L, int &n)
{
    int i=0;
    while(i<n && L[i]!=x)
        i++;
    if(i>=n)
        return -1;
    else
        return i;
}

线性表的优缺点

优点:

• 无需为表示节点间的逻辑关系而增加额外的存储空间(因为逻辑上相邻的元素其存储位置也是相邻的)
• 可方便地随机存取表中的任一元素

缺点:

• 插入或删除运算不方便,除表尾的位置外,在表的其他位置上进行插入或删除操作都必须移动大量的元素,其效率较低.
• 由于顺序表要求占用连续的存储空间,存储分配只能与先进行静态分配.因此当表长变化较大时,难以确定合适的存储规模.若按可能达到的最大长度预先分配表空间,则可能造成一部分空间长期闲置而得不到充分利用;若事先对表长估计不足,则插入操作可能使表长超过预先分配的空间而造成溢出

栈

1.栈的基本概念

定义
限定仅在表尾进行插入或删除操作的线性表
通常称表尾端为栈顶(top),称表头端为栈底(bottom)
称不含元素的空表为空栈

2.栈的抽象数据类型的定义

• 规格说明: 2.2 ADT Stack

抽象数据类型（ADT）是一个实现包括储存数据元素的存储结构以及实现基本操作的算法。
在这个数据抽象思想中，数据类型的定义和它的实现是分开的，这在软件设计中是一个重要的概念。
这使得只研究和使用它的结构而不用考虑它的实现细节成为可能。

• 数据元素: 可以是各种类型的,只要同属一个数据对象即可
• 结构: 数据元素之间呈线性关系.

• 假设栈中有n个数据元素($a_1,a_2,...,a_n$)

• 则对每一个元素$a_i$(i=1,2,…,n-1)都存在线性关系($a_i,a_{i+1}$)

• 并且$a_1$无前驱,$a_n$无后继

• 操作:

• Inistack(&S):初始化操作,其作用是设置一个空栈S

• Push(&S,x):进栈操作,其作用是将元素x插入栈S中,使x成为栈S的栈顶元素

• Pop(&S):退栈操作,其作用是当栈不空时删除栈顶元素

• Top(&S):读栈顶操作,其结果为栈顶元素;当栈S为空时结果为一特殊标志

• Empty(&S):判栈空操作,若栈S为空栈,则结果为true;否则结果为false

3.栈的基本运算在顺序表上的实现
我们用向量S表示栈,用m表示栈的最大容量,m初始值为0

进栈
进栈的主要操作是:首先判断栈是否已满,若满转出错处理;
若不满,则修改栈顶top的值,然后将入栈元素放入到新的只能订所指的位置

void PushStack(Stack &S,ElemType x,int &top)
{
	if(top=m)
		error("上溢")
	else
	{
		S[top]=x;
		top=top+1;
	}
}

退栈
退栈的主要操作是:先判栈是否为空,若栈空(top=0),则应转"下溢"处理
否则看,修改栈顶指针为top=top-1.

判栈空
若栈空则返回true;否则返回false

• 双重栈的基本运算的实现

PushStack(&S,i,x,int top[]):将元素x压入到第i个栈中

PopStack(&S,i,int top[]):当第i个栈不空时弹出其栈顶元素

4.应用

队列

1.队列的基本概念
2.队列的抽象数据类型的定义
3.队列的顺序存储结构
4.循环队列的基本运算在顺序表上的实现

排序

冒泡排序

public static void bubbleSort(int[] arr){
	for(int i=0;i<arr.length-1;i++) {
		boolean flag=flase;						//表示本趟冒泡是否发生交换的标志
		for(int j=arr.length-1;j>i;j--) {		//一趟冒泡过程
			if(arr[j-1]>arr[j]) {				//若为逆序，（正序为从小到大）
				int temp=arr[j];
				arr[j]=a[j+1];
				arr[j+1]=temp;
				flag=true;
			}
			if(!flag) return;					//本趟遍历没有发生交换，说明表已经有序
		}
	}
}

快速排序

public static void quickSort(int[] a, int low, int high) {
	if(low>high)
		return;
	int i=low,j=high;
	int key=a[low];					//将当前表中第一个元素设为枢轴值，对表进行划分
	while(i<j) {
		while(i<j && a[j]>key) {	//从后向前找到小于等于枢轴值的数
			j--;
		}
		while(i<j && a[i]<=key) {	//从前向后找到大于等于枢轴值的数
			i++;
		}
		if(i<j) {					//交换两个数
			int p=a[i];
			a[i]=a[j];
			a[j]=p;
		}
	}								//直到遍历完一遍这个数组（i=j），做到了该数组中小于枢轴值的都在左边，大于枢轴值的都在右边
	//将枢轴值放在中间，over
	int p=a[i];
	a[i]=a[low];
	a[low]=p;
	//对划分好的左右数组继续进行划分
	quickSort(a,low,i-1);
	quickSort(a,i+1,high);
}

平衡二叉树

任意结点的左、右子树高度差的绝对值不超过1,将这样的二叉树称为平衡二叉树(Balanced Binary Tree), 简称平衡树(AVL)。

定义结点左子树与右子树的高度差为该结点的平衡因子，则平衡二叉树结点的平衡因子的值只可能是-1、0或1。

平衡二叉树的插入

1. LL平衡旋转(右单旋转)

由于在结点A的左孩子(L)的左子树(L)上插入了新结点，

A的平衡因子由1增至2，导致以A为根的子树失去平衡，需要一次向右的旋转操作。

将A的左孩子B向右上旋转代替A成为根结点，将A结点向右下旋转成为B的右子树的根结点，而B的原右子树则作为A结点的左子树。

2. RR平衡旋转(左单旋转)

由于在结点A的右孩子(R)的右子树(R)上插入了新结点,

A的平衡因子由-1减至-2，导致以A为根的子树失去平衡，需要一次向左的旋转操作。

将A的右孩子B向左上旋转代替A成为根结点，将A结点向左下旋转成为B的左子树的根结点，而B的原左子树则作为A结点的右子树。

3. LR平衡旋转(先左后右双旋转)

由于在A的左孩子(L)的右子树(R)上插入新结点，

A的平衡因子由1增至2,导致以A为根的子树失去平衡，需要进行两次旋转操作，先左旋转后右旋转。

先将A结点的左孩子B的右子树的根结点C向左上旋转提升到B结点的位置，

然后再把该C结点向右上旋转提升到A结点的位置。

4. RL平衡旋转(先右后左双旋转)

由于在A的右孩子(R)的左子树(L)上插入新结点,

A的平衡因子由-1减至-2，导致以A为根的子树失去平衡，需要进行两次旋转操作，先右旋转后左旋转。

先将A结点的右孩子B的左子树的根结点C向右上旋转提升到B结点的位置，

然后再把该C结点向左上旋转提升到A结点的位置。

哈夫曼树

在含有n个带权叶子结点的二叉树中，其中带权路径长度(WPL)最小的二叉树称为哈夫曼树，也称最优二叉树。

哈夫曼树的构造

1. 将这n个结点分别作为n棵仅含一个结点的二叉树，构成森林F。

2. 构造一个新结点，从F中选取两棵根结点权值最小的树作为新结点的左、右子树，并且将新结点的权值置为左、右子树上根结点的权值之和。

3. 从F中删除刚才选出的两棵树，同时将新得到的树加入F中。

4. 重复步骤2)和3)，直至F中只剩下一棵树为止。

从上述构造过程中可以看出哈夫曼树具有如下特点:

1. 每个初始结点最终都成为叶结点，且权值越小的结点到根结点的路径长度越大。

2. 构造过程中共新建了n-1个结点(双分支结点)，因此哈夫曼树中的结点总数为2n-1。

3. 每次构造都选择2棵树作为新结点的孩子，因此哈夫曼树中不存在度为1的结点。

哈夫曼编码

首先,将每个出现的字符当作一个独立的结点，其权值为它出现的频度(或次数)，构造出对应的哈夫曼树。

显然，所有字符结点都出现在叶结点中。我们可将字符的编码解释为从根至该字符的路径上边标记的序列,其中边标记为0表示“转向左孩子”,标记为1表示“转向右孩子”。

最小生成树

一个连通图的生成树是图的极小连通子图,它包含图中的所有顶点，并且只含尽可能少的边。

这意味着对于生成树来说，若砍去它的一条边，则会使生成树变成非连通图;若给它增加一条边,则会形成图中的一条回路。

对于一个带权连通无向图G=(V,E),生成树不同，每棵树的权(即树中所有边上的权值之和)也可能不同。

设为G的所有生成树的集合，若T为边的权值之和最小的那棵生成树,则T称为G的最小生成树(Minimum-Spanning-Tree, MST)。

不难看出，最小生成树具有如下性质:

1. 最小生成树不是唯一的，即最小生成树的树形不唯一，R中可能有多个最小生成树。当图G中的各边权值互不相等时，G的最小生成树是唯一的; 若无向连通图G的边数比顶点数少1,即G本身是一棵树时，则G的最小生成树就是它本身。

2. 最小生成树的边的权值之和总是唯一的，虽然最小生成树不唯一，但其对应的边的权值之和总是唯一的，而且是最小的。

3. 最小生成树的边数为顶点数减1。

最小生成树的性质:

假设G=(V,E)是一个带权连通无向图，U是顶点集V的一个非空子集。若(u,v)是一条具有最小权值的边，其中u∈U,v∈V-U,则必存在一棵包含边(u,v)的最小生成树。

普利姆算法

假设N={V,E}是连通网，ET是N上最小生成树中边的集合。

算法从VT={u0}(u0∈V)，ET={}开始，

重复执行下述操作：

在所有u∈VT,v∈V-VT的边(u,v)∈E中找一条代价最小的边(u0,v0)并入集合ET,

同时将v0并入VT，直至VT=V为止。

此时ET中必有n-1条边，则T={VT,ET}为N的最小生成树。

克鲁斯卡尔算法

假设N=(V,E)是连通网,对应的最小生成树T=(VT,ET)。

初始化: VT=V, ET=Ø。即每个顶点构成一棵独立的树, T此时是一个仅含|V|个顶点的森林。

循环(重复下列操作至T是一棵树):

按G的边的权值递增顺序依次从E-ET中选择一条边,

若这条边加入T后不构成回路，则将其加入ET,否则舍弃，直到ET中含有n-1条边。

最短路径

图是带权图时，把从一个顶点v0到图中其余任意一个顶点vi的一条路径(可能不止一条)所经过边上的权值之和，定义为该路径的带权路径长度，把带权路径长度最短的那条路径称为最短路径。

求解最短路径的算法通常都依赖于一种性质，即两点之间的最短路径也包含了路径上其他顶点间的最短路径。

带权有向图G的最短路径问题一般可分为两类:
一是单源最短路径，即求图中某一顶点到其他各顶点的最短路径，可通过经典的Dijkstra算法求解;
二是求每对顶点间的最短路径，可通过Floyd-Warshall算法来求解。

迪杰斯特拉算法

该算法设置一个集合S记录已求得的最短路径的顶点，可用一个数组s[]来实现，初始化为0,

s[vi]=1时表示将顶点vi放入S,初始时把源点v0放入S。

此外，在构造过程中还设置了两个辅助数组:

dist[]:记录从源点v0到其他各顶点当前的最短路径长度，dist[i]的初值为arcs[v0][i]。

path[]:path[i]表示从源点到顶点i之间的最短路径的前驱结点，在算法结束时，可根据其值追溯得到源点v0到顶点vi的最短路径。

假设从项点0出发，即v0= 0,集合S最初只包含顶点0,邻接矩阵arcs表示带权有向图，

arcs[i][j]表示有向边<i,j>的权值，若不存在有向边<i,j>,则arcs[i][j]为∞。

Dijkstra算法的步骤如下(不考虑对path[]的操作):

1. 初始化:集合S初始为{0}, dist[]的初始值dist[i]=arcs[0][i], i=1,2,...,n-1。

2. 从顶点集合V-S中选出vj,满足dist[j]=Min{dist[i] |vi∈V-S}, vj就是当前求得的一条从V0出发的最短路径的终点，令S= S∪{j}。

3. 修改从v0出发到集合V-S上任一顶点vk可达的最短路径长度:若dist[j]+arcs[j][k]< dist[k],则令dist[k]=dist[j]+arcs[j][k]。

4. 重复2)–3)操作共n-1次，直到所有的顶点都包含在S中。

AOE网

在带权有向图中，以顶点表示事件，以有向边表示活动，以边上的权值表示完成该活动的开销(如完成活动所需的时间)，则称这种有向图为用边表示活动的网络，简称为AOE网。

AOE网具有以下两个性质:

① 只有在某顶点所代表的事件发生后，从该顶点出发的各有向边所代表的活动才能开始;

② 只有在进入某一顶点的各有向边所代表的活动都已结束时，该顶点所代表的事件才能发生。

AOE网中仅有一个入度为0的顶点，称为开始顶点(源点),它表示整个工程的开始;

网中也仅存在一个出度为0的顶点，称为结束顶点(汇点),它表示整个工程的结束。

关键路径

从源点到汇点的所有路径中，具有最大路径长度的路径称为关键路径，而把关键路径上的活动称为关键活动。