数据结构常用算法

//汉诺塔
void Hanoi(int n,string A,string B,string C){

	if(n == 1)
		cout<<A<<"->"<<C<<endl;
	else{
		Hanoi(n-1,A,C,B);
		cout<<A<<"->"<<C<<endl;
		Hanoi(n-1,B,A,C);
	}
}

 //递归实现
int maxNUm(int num[],int n){
	if(1 == n)
		return num[0];
	else
	{
		int tem = maxNUm(num,n-1);
		return (tem > num[n-1]) ? tem : num[n-1];
	}
}
int addNum(int num[],int n){
	if(1 == n)
		return num[0];
	else
	{
		return num[n-1] + addNum(num,n-1);
	}

}
int av(int num[],int n){

	if(1 == n)return num[0];
	else
	{
		return ((n-1)*av(num,n-1) + num[n-1])/n;
	}
}
void pai(int num[],int m,int n){
	int j,tem;
	if(0 == m){
		for (j = 0;j < n;++j)
		{
			cout<<num[j]<<" ";
		}
		cout<<endl;
	}
	else
	{
		for (j = 0;j<=m;++j)
		{
			tem = num[m];
			num[m] = num[j];
			num[j] = tem;
			pai(num,m-1,n);
			tem = num[m];
			num[m] = num[j];
			num[j] = tem;
		}
	}
}
void getNext(char *p,int *next){

	int j,k;
	next[0] = -1;
	j = 0;
	k = -1;
	int b1 = strlen(p);
	while (j < strlen(p) -1)
	{
		if(k ==-1 || p[j] == p[k] )
		{
			++j;
			++k;
			next[j] = k;
		}else
			k = next[k];
	}
}

int KEMMatch(char *t,char *p){
	int *next = new int(strlen(p));
	getNext(p,next);
	int i = 0;
	int j = 0;
	while (i < strlen(t))
	{
		if(j == -1 || t[i] == p[j])
		{
			++i;
			++j;
		}else
		{
			j = next[j];
		}
		if(j == strlen(p))
			return i - strlen(p);
	}
	return -1;

}
/**********************************************************/
//堆插入
//堆插入
void constructHeap(int a[],int n,int value){

	a[n] = value;
	int j,temp = value;
	j = (n-1)/2;
	while (j>=0 && n!=0)
	{
		if(a[j] <= temp)
			break;
		a[n] = a[j];
		n = j;
		j = (n-1)/2;
	}
	a[n] = temp;
}
//堆更新
void UpdataHeap(int a[],int index,int n)
{
	int j,temp = a[index];
	j = 2*index + 1;
	while (j < n)
	{
		if(j+1 < n && a[j+1] < a[j])
			++j;
		if(a[j] >= temp)
			break;
		a[index] = a[j];
		index = j;
		j = index*2 +1;
	}
	a[index] = temp;
}
void HeapDelete(int a[],int n){

	swap(a[0],a[n-1]);
	UpdataHeap(a,0,n-1);
}

//数组堆化
void MakeHeap(int a[],int n){
	for (int i = n/2-1; i>=0; --i)
	{
		UpdataHeap(a,i,n);
	}
}
//堆排序
void HeapSort(int a[],int n){

	for (int i=n-1; i>=1; --i)
	{
		swap(a[0],a[i]);
		UpdataHeap(a,0,i);
	}
}
/*********************************/
/*给定一数组a[N],我们希望构造数组b [N],其中b[j]=a[0]*a[1]…a[N-1] / a[j],在构造过程中,不允许使用除法:

要求O(1)空间复杂度和O(n)的时间复杂度;

	除遍历计数器与a[N] b[N]外,不可使用新的变量(包括栈临时变量、堆空间和全局静态变量等);
	*/
void getB(int a[],int b[],int n){

	b[0] = 1;
	int i;
	for (i = 1;i<n;++i)
	{
		b[i] = b[i-1] * a[i-1];
	}
	for (i = n-1;i>=1;--i)
	{
		b[i] *= b[0];
		b[0] *= a[i];
	}
}
/*************************************/
//冒泡排序
void BubbleSort(int a[],int n){

	int i,j;
	int flag = true;
	for ( i = 0;i < n;++i)
	{
		flag = false;
		for (j = 1;j < n-i;++j)
		{
			if(a[j-1] > a[j])
				swap(a[j-1],a[j]);
			flag = true;
		}
		if(!flag)
			break;
	}

}
/*************************************/
//插入排序
void InsertSort(int a[],int n){
	int i,j,temp;
	for (i = 1;i<n;++i)
	{
		if(a[i] < a[i-1]){
			temp = a[i];
			j = i;
			do
			{
				a[j] = a[j-1];
				--j;
			} while (j>=1 && temp<a[j-1]);
			a[j] = temp;
		}
	}
}
/*************************************/
//希尔排序
void ShellSort(int a[],int n){

	int i,j,temp,gap;
	gap = n;
	do
	{
		gap = gap/3 +1;
		for (i = gap;i < n;++i)
		{
			if(a[i] < a[i-gap]){
				temp = a[i];
				j = i;
				do
				{
					a[j] = a[j-gap];
					j -= gap;
				} while (j>=gap && temp < a[j-gap]);
				a[j] = temp;
			}
		}

	} while (gap > 1);

}

/*************************************/
//快速排序
void QuikSort(int a[],int l,int r){

	if(l < r)
	{
		int i = l,j = r,tem = a[l];
		while (i < j)
		{
			while (i<j && a[j] >= tem)
				--j;
			if(i < j)
				a[i++] = a[j];
			while (i < j && a[i] <= tem)
				++i;
			if(i < j)
				a[j--] = a[i];
		}
		a[i] = tem;
		QuikSort(a,l,i-1);
		QuikSort(a,i+1,r);
	}
}
/*************************************/
//选择排序
void SelectSort(int a[],int n){

	int i,j,k;
	for (i = 0;i<n-1;++i)
	{
		k = i;
		for (j = i+1; j<n;++j)
		{
			if (a[j] < a[k])
				k = j;
		}
		if(i != k)swap(a[i],a[k]);
	}

}
/*************************************/
//斐波那契数列
long Fibonacci1(int n){
	if(0 == n)
		return 0;
	else if(1 == n)
		return 1;
	else if(n > 1)
		return Fibonacci1(n-1) + Fibonacci1(n-2);
	else return -1;
}

long fab2(int in){
	int x = 0,y = 1,i;
	for(i=2;i<=in;i++){
		y = x + y;
		x = y - x;
	}
	return y;
};
/************************************/
//给定整数sum,在乱序数组中寻找所有满足x+y=sum的组合

void sumN(int a[],int n,int value){

	QuikSort(a,0,n-1);
	int i = 0,j = n-1;
	while (i < j)
	{
		 if((a[i] + a[j]) == value)
		 {
			 cout<<a[i]<<"+"<<a[j]<<endl;
			 ++i;
			 --j;
		 }else if((a[i] + a[j]) < value)
			 ++i;
		 else
			--j;
	}
}
/************************************/
//寻找在数组中最大的K个数
//堆插入
void constructHeap(int a[],int n,int value){

	a[n] = value;
	int j,temp = value;
	j = (n-1)/2;
	while (j>=0 && n!=0)
	{
		if(a[j] <= temp)
			break;
		a[n] = a[j];
		n = j;
		j = (n-1)/2;
	}
	a[n] = temp;
}
//堆更新
void UpdataHeap(int a[],int index,int n)
{
	int j,temp = a[index];
	j = 2*index + 1;
	while (j < n)
	{
		if(j+1 < n && a[j+1] < a[j])
			++j;
		if(a[j] >= temp)
			break;
		a[index] = a[j];
		index = j;
		j = index*2 +1;
	}
	a[index] = temp;
}
void MaxK(int a[],int n,int k){

	int i;
	int *temp = new int[k];
	for (i=0;i<n;++i)
	{
		if(i < k)
			constructHeap(temp,i,a[i]);//先构造k堆
		else
		{
			if (temp[0] < a[i])
			{
				temp[0] = a[i];
				UpdataHeap(temp,0,k);//更新k堆;
			}
		}
	}
	for (i=0;i<k;++i)
	{
		cout<<temp[i]<<" ";
	}
	delete []temp;
}
/************************************/

时间: 2024-10-09 09:40:12

数据结构常用算法的相关文章

2016计算机考研:数据结构常用算法精析

不知道博客园有没有计算机专业的考研党,希望列举的计算机考研考点能帮助大家吧,以下就是数据结构常用算法精析,如果大家看有什么不对的地方,欢迎纠错指正啊哈哈哈.2016考研加油!!!!!!!!! 内部排序(在内存中进行的排序不需要访问外存的)外部排序(排序量很大,通过分批的读写外存,最终完成排序) 稳定排序和非稳定排序:看相同记录的相对次序是否回发生改变.主要看在排序过程中的比较是不是相邻记录,如果是相邻比较,一定是稳定的排序.如果不是相邻的比较,就是不稳定的. 内排序方法 截止目前,各种内排序方法

常用数据结构及算法C#实现

常用数据结构及算法C#实现 1.冒泡排序.选择排序.插入排序(三种简单非递归排序) 1 int[] waitSort = { 1,0, 12, 13, 14, 5, 6, 7, 8, 9, 10 }; 2 3 //冒泡排序 4 int length = waitSort.Length; 5 6 for (int i = 0; i < length; i++) 7 { 8 for (int j = i + 1; j < length; j++) 9 { 10 if (waitSort[j] &g

java常用的数组、字符串、集合操作以及数据结构与算法基本知识

java中常用封装的数组 .字符串. 集合来操作对象,但数据结构中常用的有栈和队列   数与图以及他们之间的排序,查找. 数组声明没有分配内存空间  只有创建或者是初始化时才分配,创建时把数组中的数据类型数据所在的内存空间首地址赋值给数组名,在创建每个对象时,都会给该对象分配地址和它存储的数据 .如变量    int arr[]; int arr[]={1,2,3};  arr=new int[10] ,int arr[][]={{1,9,7},{1,2,3}}  int arr[][]=new

常用数据结构和算法操作效率的对比总结

前面介绍了经典的数据结构和算法,这一节我们对这些数据结构和算法做一个总结,具体细节,请参见各个章节的详细介绍,这里我们用表格来呈现它们的效率. 1. 数据结构部分 数据结构中常用的操作的效率表 通用数据结构 查找 插入 删除 遍历 数组 O(N) O(1) O(N) - 有序数组 O(logN) O(N) O(N) O(N) 链表 O(N) O(1) O(N) - 有序链表 O(N) O(N) O(N) O(N) 二叉树 O(logN) O(logN) O(logN) O(N) 二叉树(最坏)

Python 常用查找数据结构及算法

一.基本概念 二.无序表查找 三.有序表查找 3.1 二分查找(Binary Search) 3.2 插值查找 3.3 斐波那契查找 四.线性索引查找 4.1 稠密索引 4.2 分块索引 4.3 倒排索引 五.二叉排序树 六. 平衡二叉树 七.多路查找树(B树) 7.1 2-3树 7.2 2-3-4树 7.3 B树 7.4 B+树 八.散列表(哈希表) 8.1 散列函数的构造方法 8.2 处理散列冲突 8.3 散列表查找实现 8.4 散列表查找性能分析 参考书目<大话数据结构> 一.基本概念

五大常用算法

http://www.cnblogs.com/steven_oyj/archive/2010/05/22/1741370.html 分治算法 一.基本概念 在计算机科学中,分治法是一种很重要的算法.字面上的解释是"分而治之",就是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题--直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并.这个技巧是很多高效算法的基础,如排序算法(快速排序,归并排序),傅立叶变换(快速傅立叶变换)-- 任何一个可以用计

[转]五大常用算法:分治、动态规划、贪心、回溯和分支界定

Referred from http://blog.csdn.net/yapian8/article/details/28240973 分治算法 一.基本概念 在计算机科学中,分治法是一种很重要的算法.字面上的解释是“分而治之”,就是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并.这个技巧是很多高效算法的基础,如排序算法(快速排序,归并排序),傅立叶变换(快速傅立叶变换)…… 任何一个可以用计算机求

数据结构和算法之时间复杂度和空间复杂度

前言 上一篇<数据结构和算法>中我介绍了数据结构的基本概念,也介绍了数据结构一般可以分为逻辑结构和物理结构.逻辑结构分为集合结构.线性结构.树形结构和图形结构.物理结构分为顺序存储结构和链式存储结构.并且也介绍了这些结构的特点.然后,又介绍了算法的概念和算法的5个基本特性,分别是输入.输出.有穷性.确定性和可行性.最后说阐述了一个好的算法需要遵守正确性.可读性.健壮性.时间效率高和存储量低.其实,实现效率和存储量就是时间复杂度和空间复杂度.本篇我们就围绕这两个"复杂度"展开

面试常考数据结构与算法

数据结构部分: 1.数组和链表的区别.(很简单,但是很常考,记得要回答全面) C++语言中可以用数组处理一组数据类型相同的数据,但不允许动态定义数组的大小,即在使用数组之前必须确定数组的大小.而在实际应用中,用户使用数组之前无法确定数组的大小,只能够将数组定义成足够大小,这样数组的空间可能不被使用,从而造成内存空间的浪费.链表是一种常见的数据组织形式,他采用动态分配内存的形式实现.需要时可以用new分配内存空间,不需要时用delete将已分配的空间释放,不会造成内存空间的浪费. 从逻辑结构上来看