六种常见算法实例

不想废话,直接上代码,代码都是调试过的。

实现的算法有:冒泡,直接选择,直接插入,归并,二叉堆,快速排序这六种。

对于后三种的理解方法,请百度这个系列的文章“白话经典算法系列 ”,个人感觉作者讲的特别不错!

下面贴代码

#include <stdio.h>
#include <conio.h>
//冒泡排序
void BubbleSort(int arry[], int n)
{
	int i, j, k;
	for (i = 0; i < n; i++)
	{
		k = 0;
		for (j = 0; j < n - 1; j++)
		{
			if (arry[j] > arry[j + 1])
			{
				int t = arry[j];
				arry[j] = arry[j+1];
				arry[j+1] = t;
				k = 1;
			}
		}
		if (k == 0)
			break;
	}
}
//插入排序
void InsertSort(int arry[], int n)
{
	//{ 9,23,1,8,5,13,7,12,0,4 };
	int i, j, k;
	for (i = 1; i < n; i++)
	{
		k = arry[i];
		for (j = i - 1; j >= 0&& arry[j] >=k; j--)
		{
			arry[j + 1] = arry[j];
		}
		arry[j + 1] = k;
	}
}
//选择排序
void SelectSort(int arry[], int n)
{
	int i, j, k;
	for (int i = 0; i < n; i++)
	{
		k = i;
		for (j = i+1; j < n; j++)
		{
			if (arry[k]> arry[j])
			{
				k = j;
			}
		}
		int t = arry[i];
		arry[i] = arry[k];
		arry[k] = t;
	}
}
//堆排序
//最小堆向上向下排列函数
void MakeMinHeapUp(int arry[], int i)
{
	int j = (i - 1) / 2;
	int temp = arry[i];
	while (j >= 0)
	{
		if (arry[j] < arry[i])
			break;
		arry[i] = arry[j];
		i = j;
		j = (j - 1) / 2;
	}
	arry[i] = j;
}
void MakeMinHeapDown(int arry[],int n,int i)
{
	int j = i * 2 + 1;
	int temp = arry[i];
	while (j < n)
	{
		if (j+1<n&&arry[j + 1] < arry[j])
			j++;
		if (arry[i] < arry[j])
			break;
		arry[i] = arry[j];
		i = j;
		j = 2 * j + 1;
	}
	arry[i] = temp;
}
//最大堆向上向下排列函数
void MakeMaxHeapUp(int arry[], int i)
{
	int j = (i - 1) / 2;
	int temp = arry[i];
	while (j >= 0)
	{
		if (arry[j] > arry[i])
			break;
		arry[i] = arry[j];
		i = j;
		j = (j - 1) / 2;
	}
	arry[i] = j;
}
void MakeMaxHeapDown(int arry[], int n, int i)
{
	int j = i * 2 + 1;
	int temp = arry[i];
	while (j < n)
	{
		if (j + 1<n&&arry[j + 1] > arry[j])
			j++;
		if (arry[i] > arry[j])
			break;
		arry[i] = arry[j];
		i = j;
		j = 2 * j + 1;
	}
	arry[i] = temp;
}
//生成最小堆,排序后为降序
void MakeMinHeap(int arry[], int n)
{
	for (int i = n / 2 - 1; i >= 0; i--)
	{
		MakeMinHeapDown(arry, n, i);
	}
}
//生成最大堆,排序后为升序
void MakeMaxHeap(int arry[], int n)
{
	for (int i = n / 2 - 1; i >= 0; i--)
	{
		MakeMaxHeapDown(arry, n, i);
	}
}
void HeapSortMain(int arry[], int n)
{
	int temp;
	for (int i = n - 1; i >= 1; i--)
	{
		temp = arry[i];
		arry[i] = arry[0];
		arry[0] = temp;
		//MakeMinHeap(arry, i);
		MakeMaxHeap(arry, i);
	}
}
void HeapSort(int arry[],int n)
{
	//MakeMinHeap(arry, n);
	MakeMaxHeap(arry, n);
	HeapSortMain(arry, n);
}

//快速排序
int GetIndex(int arry[], int l, int r)
{
	int i = l, j = r;
	int k = arry[l];
	while (i < j)
	{
		while (i<j&&k<arry[j])
		{
			j--;
		}
		if (i < j)
		{
			arry[i] = arry[j];
			i++;
		}
		while (i<j&&k>arry[i])
		{
			i++;
		}
		if (i < j)
		{
			arry[j] = arry[i];
			j--;
		}
	}
	arry[i] = k;
	return i;
}
void QuickSortMain(int arry[], int l, int r)
{
	if (l < r)
	{
		int mid = GetIndex(arry, l, r);
		QuickSortMain(arry, l, mid-1);
		QuickSortMain(arry, mid + 1, r);
	}
}
void QuickSort(int arry[], int n)
{
	QuickSortMain(arry, 0, n - 1);
}

//归并排序
void MergeArry(int arry[], int first, int mid, int last, int temp[])
{
	int i = first, j = mid + 1;
	int k = 0;
	while (i <= mid&&j <= last)
	{
		if (arry[i]>arry[j])
		{
			temp[k++] = arry[j++];
		}
		else
		{
			temp[k++] = arry[i++];
		}
	}
	while (i <= mid)
	{
		temp[k++] = arry[i++];
	}
	while (j <= last)
	{
		temp[k++] = arry[j++];
	}
	for (i = 0; i < k; i++)
	{
		arry[first + i] = temp[i];
	}
}
void MergeSortMain(int arry[],int first,int last,int temp[])
{
	if (first < last)
	{
		int mid = (first + last) / 2;
		MergeSortMain(arry, first, mid,temp);
		MergeSortMain(arry, mid + 1, last,temp);
		MergeArry(arry, first, mid, last, temp);
	}
}
void MergeSort(int arry[],int n)
{
	int *p = new int[n];
	if (p == NULL)
	{
		return;
	}
	MergeSortMain(arry, 0, n - 1, p);
	delete[] p;
}

int main()
{
	//int arry[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int arry[10] = { 9,23,1,8,5,13,7,12,0,4 };
	//BubbleSort(arry, 10);
	//InsertSort(arry, 10);
	//SelectSort(arry, 10);
	//ShellSort(arry, 10);
	//QuickSort(arry, 10);
	//MergeSort(arry, 10);
	//HeapSort(arry, 10);
	int i = 0;
	for (; i < 10; i++)
	{
		printf("%d ", *(arry + i));
	}
	getch();
}

  

时间: 2024-10-29 00:14:57

六种常见算法实例的相关文章

六种排序算法C语言版(上)

排序即将一个无序的数组(序列)按照一定的规则排列,常见的规则便是按照从大到小或者从小到大的顺序.本文讨论的排序一律指按照从小到大的顺序进行排列的这种情况. 本文将分为上下两章介绍以下六种排序算法: (1)直接选择排序 (2)冒泡排序 (3)快速排序 (4)二分排序 (5)堆排序 (6)线性时间排序. 首先,直接选择排序.直接选择排序的思想是: 1.第一次从数组A[0]到A[n-1]中选出最小的然后与A[0]进行交换: 2.第二次从A[1]到A[n-1]中选择最小的然后与A[1]进行交换: 依次类

javascript常用经典算法实例详解

javascript常用经典算法实例详解 这篇文章主要介绍了javascript常用算法,结合实例形式较为详细的分析总结了JavaScript中常见的各种排序算法以及堆.栈.链表等数据结构的相关实现与使用技巧,需要的朋友可以参考下 本文实例讲述了javascript常用算法.分享给大家供大家参考,具体如下: 入门级算法-线性查找-时间复杂度O(n)--相当于算法界中的HelloWorld ? 1 2 3 4 5 6 7 8 9 10 //线性搜索(入门HelloWorld) //A为数组,x为要

acm常见算法及例题

转自:http://blog.csdn.net/hengjie2009/article/details/7540135 acm常见算法及例题 初期:一.基本算法:     (1)枚举. (poj1753,poj2965)     (2)贪心(poj1328,poj2109,poj2586)     (3)递归和分治法.     (4)递推.     (5)构造法.(poj3295)     (6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)二.图算法

机器学习常见算法分类汇总

机器学习常见算法分类汇总 机器学习无疑是当前数据分析领域的一个热点内容.很多人在平时的工作中都或多或少会用到机器学习的算法.这里 IT 经理网为您总结一下常见的机器学习算法,以供您在工作和学习中参考. 机器学习的算法很多.很多时候困惑人们都是,很多算法是一类算法,而有些算法又是从其他算法中延伸出来的.这里,我们从两个方面来给大家介绍,第一个方面是学习的方式,第二个方面是算法的类似性. 学习方式 根据数据类型的不同,对一个问题的建模有不同的方式.在机器学习或者人工智能领域,人们首先会考虑算法的学习

前端常见算法JS实现

算法是程序的灵魂,一个优秀的前端工程师对算法也是要有所了解的. 排序算法 1. 冒泡排序 //冒泡排序 function bubbleSort(arr){ var i = j = 0; for(i=1;i<arr.length;i++){ for(j=0;j<=arr.length-i;j++){ var temp = 0; if(arr[j]>arr[j+1]){ temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } 2.

机器学习14种常见算法

最近收到一封公司内部邮件,说,有个机器人程序--**小助手,上线(不知道哪个部门写的),让大家没事的时候,测试,顺便让程序学习一下,超过 50 条聊天,有抽奖机会~我大概试了一下,有点无语,这写得是个神马玩意啊,这么烂,基本聊不上 3 句,最多也就是,"你是谁","多大了",即便我顺着程序说,也是驴唇不对马嘴~你要是让程序学习,互联网这么大,还用得着让人来吗,即便让人来,自己也得差不多才行啊,连个雏形都没有,还好意思让大家测试,美其名曰:让程序学习~ 机器学习无疑是

[Machine Learning] 机器学习常见算法分类汇总

声明:本篇博文根据http://www.ctocio.com/hotnews/15919.html整理,原作者张萌,尊重原创. 机器学习无疑是当前数据分析领域的一个热点内容.很多人在平时的工作中都或多或少会用到机器学习的算法.本文为您总结一下常见的机器学习算法,以供您在工作和学习中参考. 机器学习的算法很多.很多时候困惑人们都是,很多算法是一类算法,而有些算法又是从其他算法中延伸出来的.这里,我们从两个方面来给大家介绍,第一个方面是学习的方式,第二个方面是算法的分类. 博主根据原创基础上加入了遗

面试常见算法-排序查找算法

算法是程序员必被的一个技能,在面试中常常出现,下面总结了面试中出现的常见算法,这些算法程序员应该牢记在心中,要非常熟练. 插入排序算法 原理:将数组分为无序区和有序区两个区,然后不断将无序区的第一个元素按大小顺序插入到有序区中去,最终将所有无序区元素都移动到有序区完成排序. 要点:设立哨兵,作为临时存储和判断数组边界之用. public class InsertSort { private static void insertSort(int[] a) { int j; int tmp; for

Floyd算法实例

~ 当k=0时,我们关注的是邻接矩阵的第0行和第0列,即顶点0的入边和出边: 考察矩阵中其他元素,如果元素D[i][j]向第0行和第0列的投影D[0][j]和D[i][0]都有值,就说明原图中从 i 到 j 存在一条经过顶点0的有向路径 i -> 0 -> j, 这样的路径包含的边数不会超过2,如果其权值小于D[i][j],则应用这个权值更新D[i][j],表明图中有向路径 i -> 0 -> j 相比原有路径更短. k=1.2时情况类似~ OK哒,哈哈~ Floyd算法实例,布布