数据结构复习-图、查找、排序

最新推荐文章于 2022-04-25 21:54:17 发布

Anyanyamy

最新推荐文章于 2022-04-25 21:54:17 发布

阅读量612

点赞数

分类专栏： Software designer exam

本文链接：https://blog.csdn.net/u011680118/article/details/44586933

版权

C 同时被 2 个专栏收录

29 篇文章 0 订阅

订阅专栏

Software designer exam

19 篇文章 0 订阅

订阅专栏

//查找/检索算法： 
//平均比较/查找次数：ASL=pi*ci  i:1~n ci是找第i个记录需要进行比较的次数 
//静态查找：顺序查找O(N)、二分查找O(log2 N)、分块查找 
//动态查找：二叉排序树、平衡二叉树 

//排序算法： 以从小到大为例 
//基于选择：选择排序 O(N^2)、堆排序 O(N*log2 N)
//基于交换：冒泡排序 O(N^2)、快速排序 O(N*log2 N)
//基于比较：插入排序 O(N^2)、希尔排序 
//其他：合并排序 O(N*log2 N)、基数排序 O(d(r+N)) -- d最长位数，r基数（即链表的个数），N数字个数 

int LinearSearch(int arr[],int item)
{
}

int BinarySearch(int arr[],int n,int item)
{
	int low = 0,high = n-1,mid;
	while(low <= high)
	{
		mid = (low+high)/2;
		if(arr[mid] == item)
		{
			return mid;
		}
		if(arr[mid] > item)
		{
			high = mid -1;
		}
		else
		 	low = mid + 1;
	}
	return -1;
}

//性能介于顺序和二分法之间的,二分查找索引表，块内采取顺序查找 
#define MAX 20
typedef struct {
	int key; //关键字
	int link; //对应块的起始下标 
}IdxType;
typedef IdxType IDX[MAX];

int BlockSearch(IDX I, int m,int r[],int n,int item)
{
	int low = 0,high = m-1,mid , i;
	int b = n/m;   //每块的记录个数
	while(low <= high)
	{
		mid = (low + high)/2;
		if(I[mid].key >= k)
			high = mid -1;
		else
		 	low = mid +1;
	} 
	
	//查找完索引表后，顺序查找块中元素 
	i = I[high+1].link;
	while(i <= I[high+1].link + b -1 && r[i].key!=k)
		i ++;
	if(i <= I[high +1].link +b-1)
		return i;
	else
		return -1;
}

//内部查找的： 
//二叉排序树：BST  左子树<根节点<右子树，按中序遍历得到的是递增序列
//任何节点插入二叉排序树时，均以叶子节点的形式插入。对一个序列依次插入所有节点。 
//构造： O(N*log2 N)  查找：O(log2 N) 
int BTreeSearch(int arr[], int item)
{
}

//平衡二叉树：AVL  每个节点的平衡因子（左子树高度-右子树高度）为0，-1，1   查找O(log2 N) 
int BalTreeSearch(int arr[],int item)
{
}

//外部查找的：
//B-（多路平衡查找树） B+树 

//哈希表查找
//哈希表：H(Ki)是关键字Ki所对应的对象存储在内存中的地址。关键字的取值区间一般远大于哈希地址的变化区间
//目标：使哈希地址均匀分布在连续内存上
//哈希函数构造方法:直接定址法（h(k) = k+c，浪费空间）；除留余数法（h(k) = k mod p，最常使用，p是不大于关键字总数的素数） 
//哈希冲突（同义词冲突）解决：开放定址法（以冲突的哈希地址为自变量，通过哈希冲突函数得到新的地址），拉链法（把所有的同义词用单链表连接
//起来，哈希表中存放链表头指针）
//开发定址法：记录规模小时使用，但是不能探查所有冲突，在冲突时做删除标记
//拉链法：无法确定表长，需要额外的空间，但是能真正的删除记录 
 

//Sort  
//选择排序，始终是O（N＾2） 
void Choose(int arr[],int n)
{
	int tmp,k; 
	for (int i = 0; i < n-1 ; i++)
	{
		k = i;
		
		for(int j = i+1; j < n ; j++)
		{
			if(arr[j] < arr[k])
			{
				k = j;
			}
		}
		if(k!= i)
		{
			tmp = arr[i];
			arr[j] = arr[k];
			arr[k] = tmp;
		}
	}
}  

//正序时只需要一遍循环 O(N)，平均和最坏都是O(N^2) 
void Booble(int arr[],int n)
{
	int tmp; 
	for (int i = 0; i < n-1 ; i++)
	{
		for(int j = n-1; j > i ; j--)
		{
			if(arr[j] < arr[j-1])
			{
				tmp = arr[j];
				arr[j] = arr[j-1];
				arr[j-1] = tmp;
			}
		}
	}
}

//假设前i个数已经排好序了，把i+1~n的数插入进去 
正序时只需要一遍循环 O(N)，平均和最坏都是O(N^2)  
void Insert(int arr[],int n)
{
	int tmp; 
	for(int i = 1;i < n;i++)
	{
		tmp = arr[i];
		j = i-1;
		//找到应该插入的位置 
		while(j >= 0 && tmp < arr[j])
		{
			arr[j+1] = arr[j];
			j--;
		}
		arr[j+1] = tmp;
	}
}

//二分法查找插入排序 
void BinaInsert(int arr[],int n)
{
	int i,j,low=0,high=n-1,mid;
	int tmp;
	for(int i = 1;i < n;i++)
	{
		tmp = arr[i]; 
		//二分查找应该插入的位置 
		while(low <= high)
		{
			mid = (low + high)/2;
			if(tmp < arr[mid])
			{
				high = mid-1;
			} 
			else
				low = mid+1;
		} 
	
		for(j = i-1; j >= high+1;j--)
		{
			arr[j+1] = arr[j];
		
		}
		arr[high + 1] = tmp;
	} 
}

//希尔排序 O(N^1.3) 
void ShellSort(int arr[],int n)
{
	int i,j,gap = n/2,tmp;
	while(gap>0)
	{
		for(i = gap; i <n ; i++)
		{
			//对间隔gap的元素进行直接插入排序 
			tmp = arr[i];
			j = i-gap;
			while(j >= 0 && tmp < arr[j])
			{
				arr[j+gap] = arr[j];
				j = j-gap;
			}
			arr[j+gap] = tmp;
		}
		//减小增量 
		gap = gap/2;
	}
} 

//快速排序： 平均时间：O(N*log2 N) 平均空间：O(log2 N) --- 递归树的高度 
//最坏时：正序或者反序所需的比较次数最多： O(N^2)  O(N) 
void Quick(int arr[],int s,int t)
{
	int i = s, j = t;
	int tmp;
	if(s < t)
	{
		tmp = arr[s];
		while(i!=j)
		{
			while(j>i && arr[j] > tmp)
				j --;
			arr[i] = arr[j];
			while(i<j && arr[i] < tmp)
				i ++;
			arr[j] = arr[i];
		}
		arr[i] = tmp;
		Quick(arr,s,i-1);
		Quick(arr,i+1,t);
	}
	
} 

//堆是完全二叉树，每次选择双亲节点归位，构造初始堆 
void sift(int arr[],int low,int high)
{
	int i = low,j = 2*i; //j是左孩子 
	int tmp = arr[i];  //保存双亲节点 
	while(j <= high)
	{
		if(j < high && arr[j] < arr[j+1])
		{
			j ++;
		} 
		if(tmp < arr[j])
		{
			arr[i] = arr[j];
			i = j;
			j = 2*i;
		}
		else break;
	}
	arr[i] = tmp;
} 
void Heap(int arr[],int n)
{
	int i,tmp;
	//建立初始堆 
	for(i = n/2;i>=1;i--)
		sift(arr,i,n);
	//进行n-1趟堆排序，每次元素个数-1 
	for(i = n; i >=2; i--)
	{
		tmp = arr[1];
		arr[1] = arr[i];
		arr[i] = tmp;
		sift(arr,1,i-1);
	} 
}

//对两个有序表进行二路归并，自底向上的 把表看作多个长度为1的子表进行归并；自顶向下的先分解至子表长度为1，然后进行归并
void Merge(int arr[],int low,int mid,int high)
{
	int *r;
	int i = low,j = mid+1,k=0;
	r = (int *)malloc(sizeof(int)*(high-low +1));
	while(i <= mid&& j <= high)
	{
		if(arr[i] <= arr[j])
		{
			r[k] = arr[i];
			i++; k++;
		}
		else
		{
			r[k] = arr[j];
			j++; k++;
		}
	}
	while(i<= mid)
	{
		r[k] = arr[i];
		i++;k++;
	}
	while(j <= high)
	{
		r[k] = arr[j];
		j ++; k++;
	}
	//把low~mid,mid+1~high归并完后复制回去 
	for(k = 0,i = low;i<=high;k++,i++) 
	{
		arr[i] = r[i];
	}
}
//O(N*log2 N) 
void MergeSort(int arr[],int low,int high)
{
	int mid;
	if(low < high)
	{
		mid = (low + high)/2;
		MergeSort(arr,low,mid);
		MergeSort(arr,mid+1,high);
		Merge(arr,low,mid,high);
	}
}

void MergeS(int arr[],int n)
{
	MergeSort(arr,0,n-1);
}

//分配：把元素插入对应的队列中  收集：把队列连成线性表  重复多遍 
void Jishu(int arr[],int n)
{
}

查找：http://blog.csdn.net/jiuqiyuliang/article/details/24405965

八大排序：http://blog.csdn.net/jiuqiyuliang/article/details/25304009

==============================================================================================================================

以下转载：视觉感受7种常用排序算法：

1. 快速排序

介绍：

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。

步骤：

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

排序效果：

2. 归并排序

介绍：

归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用

步骤：

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针达到序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

排序效果：

3. 堆排序

介绍：

堆积排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

步骤：

（比较复杂，自己上网查吧）

排序效果：

4. 选择排序

介绍：

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

排序效果：

5. 冒泡排序

介绍：

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

步骤：

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

排序效果：

6. 插入排序

介绍：

插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

步骤：

从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置中
重复步骤2

排序效果：

（暂无）

7. 希尔排序

介绍：

希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

1、插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率

2、但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位>

排序效果：

#include <stdio.h>
#include <stdlib.h>

//图的基本概念：
//有向图：入度，出度
//无向图：度
//图中所有顶点的度之和=边数*2
//完全图：每两个顶点间都有一条边，
//路径：从一个顶点到另一个顶点的顶点序列； 路径长度：路径上经过的边的数目
//无向图：任意两个顶点间都存在边，极大连通子图=连通分量 
//无向图：任意两个顶点间都存在边，极大强连通图=强连通分量
//关节点：在删除该节点及其关联的边后，把图的一个连通分量分隔成多个连通分量； 重连通图：没有关节点的连通图
//网：即带权图
//简单路径/回路：路径上的顶点不重复 
 
//图的邻接矩阵和邻接表存储方法
#define MAX 20

/*
邻接矩阵的特性：
1.无向图的邻接矩阵是对称矩阵，可以只存三角矩阵
2.不带权的有向图的邻接矩阵是稀疏矩阵，可以用三元组标识
3.无向图：邻接矩阵的第i行非0元素的个数是第i个顶点的度（对于有向图，是出度）
4.易于确定顶点间是否有边，但是确定总边数时，要按行和列进行扫描，复杂。 
*/ 
typedef struct 
{
	int no;  //定点编号 
	char* info; //顶点其他信息 
} VertexType;  //顶点类型

typedef struct 
{
	int edges[MAX][MAX];   	//邻接矩阵的边数组 
	int n,e;			  	//顶点数，边数 
	VertexType vxs[MAX];	//存放顶点信息 
} MGraph;

//顺序分配与链式分配的结合，邻接表 
/*
邻接表：
1.表示不唯一
2.n,e的无向图需要存储n个顶点和2*e个边，对于稀疏图，邻接表更省空间
3.第i个链表的长度是顶点i的度。 
4.有向图中只存储了以顶点为起点的边，不宜找到指向该顶点的边，可以设计逆邻接表，保存指向该顶点的边。 
*/ 
typedef struct ANode
{
	int adjvex;				///该边的终点位置 
	struct ANode* nextarc;	//指向下一条边的指针 
	char* info;				//边的信息 
} ArcNode;
typedef struct VNode
{
	char* data;         //顶点信息 
	ArcNode* firstarc;  //指向第一条边 
}VNode;

typedef VNode AdjList[MAX];
typedef struct 
{
	AdjList adjlist;  	//邻接表 
	int n,e; 			//顶点数，边数
} ALGraph; 

/*邻接矩阵-->邻接表： O(N*N)
找出表中不为0的元素，然后为该点建立一个表节点并在邻接表对应得单链表中插入。 
  邻接表-->邻接矩阵： O(N+2E) 
在邻接表中找相邻节点，找到后修改矩阵对应值。 
  N---顶点数   E---边数 
*/ 
//图的遍历：BFS  DFS ，只有连通图的情况下才会完全访问
//应用：求简单路径和简单回路，可以采用深度优先的回溯方法。 

//DFS:从初始顶点触发，对相邻的未被访问过的顶点进行访问，再从该顶点出发进行访问。 
//邻接表：O(N+2E)    邻接矩阵：O(N*N) 
void DFS(ALGraph* G,int v)
{
	ArcNode* p;
	//访问数组，从v开始访问 
	visited[v] = 1;
	printf("%d ",v);
	p = G->adjlist[v].firstarc;
	while(p!=NULL)
	{
		if(visited[p->adjvex] == 0)
		{
			DFS(G,p->adjvex);
		}
		p = p->nextarc;
	}
} 

//BFS：层次遍历，广度搜索
void BFS(ALGraph* G,int v)
{
	ArcNode* p;
	//循环队列 
	int queue[MAX],front = 0,rear = 0;
	int visited[MAX];
	int w,i;
	for(i = 0;i<G->n;i++)
	{
		visited[i] = 0;
	}
	printf("%2d ",v);
	visited[v] = 1;
	
	//v进队 
	rear = (rear+1)%MAX;
	queue[rear] = v;
	//队列不空则循环 
	while(front!=rear)
	{
		//出队一个元素 
		front = (front+1)%MAX;
		w = queue[front];
		p = G->adjlist[w].firstarc;
		while(p!=NULL)
		{
			//若该顶点未被访问，则访问该顶点，然后进队 
			if(visited[p->adjvex] == 0)
			{
				printf("%2d ",p->adjvex);
				visited[p->adjvex] = 1;
				rear = (rear+1)%MAX;
				queue[rear] = p ->adjvex;
			}
			p = p->nextarc;
		}
	}
	printf("\n");
} 

// 对于非连通图，需要对于每个顶点进行一次DFS/BFS

//生成树：极小连通子图，含有全部顶点，但是只有N-1条边。图中所有生成树中具有边上权值之和最小的为最小生成树。
//只能用已有的边来构造： Prim / Criskaer 
//Prim:初始化U={v}，以v到其他顶点的边为候选边，从候选边中选出最小权值的，其对应的顶点加入U中，然后修改候选边，若到新顶点的权值更小则更新其权值
//O（N*N）   N---顶点数  两重FOR循环

//Criskaer:把G中的边按权重从小到大排列，每次选择最小权值的边，若存在两个顶点所在的连通分量相同，若加入，则形成了回路，舍弃刚刚选取的边 
//O（E*E）
//改进后O(E*log2 E)：可以采用堆排序对边进行排序，利用并查集进行顶点合并，判断是否在一个连通分量。

//最短路径：无权图：经过顶点最少的路径； 有权图：经过边的权值之和最小的路径。
//求一个顶点到其他各顶点的最短路径： Dijkstra/Floyd
//Dijkstra:初始S={v},U中是其他顶点，选取顶点k使其到v距离最小，然后加入S中，可以借助k修改其他顶点到v的最短距离值，再重复选边，加点，改距离值。
//O(N*N)   可以利用该方法求最小生成树。 

//Floyd: 求每对顶点间的最短路径
//产生一个递推矩阵，A(k)[i][j] 表示从i到j经过顶点编号不大于k的最短路径长度。
//用Path数组保存i到j中间节点编号不大于k的最短路径长度的前一个节点编号，-1标识没有中间节点 
//A(-1)[i][j] = cost[i][j] ;  A(k+1)[i][j] = min{A(k)[i][j],A(k)[i][k+1] + A(k)[k+1][j]}

//有向图的拓扑排序：
//1.选择一个没有前驱的顶点，并输出
//2.删去该点，删去从此出发的有向边，重复直到不存在没有前驱的顶点为止。

//AOE网：描述工程的预计进度的带权有向图，只有一个源点和汇点。从源-》汇的最大路径长度成为关键路径，其上的活动称为关键活动。