交换类排序:冒泡,快速(递归与非递归)

<pre name="code" class="cpp">交换类排序:1:冒泡排序O(n^2),空间复杂度O(1)
            2:快速排序O(n乘以log以2为底,n的对数),空间复杂度O(log以2为底,n的对数)

//冒泡排序
void BubbleSort(int R[],int n)
{
	int i,j,tmp,flag;
	for(i=0;i<n-1;i++)
	{
		flag=0;
		for(j=n-1;j>i;j--)
		{
			if(R[j]<R[j-1])
			{
				tmp=R[j];
				R[j]=R[j-1];
				R[j-1]=tmp;
				flag=1;
			}
		}
		if(flag==0)
			return;
	}
}

//快速排序
void QuickSort(int R[],int s,int t)
{
	int i=s,j=t;
	int tmp;
	if(s<t)
	{
		tmp=R[s];
		while(i!=j)
		{
			while(j>i && R[j]>tmp)
				j--;
			R[i]=R[j];
			while(i<j && R[i]<tmp)
				i++;
			R[j]=R[i];
		}
		R[i]=tmp;//最后一个[i]给了别人,此处的值没有用了,用来存放基准值
		QuickSort(R,s,i-1);
		QuickSort(R,i+1,t);
	}
}

//快速排序的非递归算法
void QuickSort(int R[],int n)
{
	int i,j,low,high,top=-1;
	int temp;
	struck
	{
		int low;
		int high;
	}St[MAXITEM];
	top++;
	St[top].low=0;
	St[top].high=n-1;
	while(top>-1)
	{
		//出栈
		low=St[top].low;
		high=St[top].high;
		top--;
		i=low;
		j=high;
		if(low<high)
		{
			temp=R[low];
			while(i!=j)
			{
				while(i<j && R[j]>temp)
					j--;
				R[i]=R[j];
				while(i<j && R[i]<temp)
					i++;
				R[j]=R[i];
			}
			R[i]=temp;
			//入栈
			top++;
			St[top].low=low;
			St[top].high=i-1;
			top++;
			St[top].low=i+1;
			St[top].high=high;
		}
	}
}
				
时间: 2024-10-06 18:12:07

交换类排序:冒泡,快速(递归与非递归)的相关文章

交换类排序算法

#include<stdio.h> /* *交换类排序,每天一道算法题 *按照从小到大的顺序进行排序 * 毛施平 */ //冒泡排序 void traverseArray(int *p,int length) { int i=0; for(;i<length;i++) { printf("%d\n",p[i]); } } //这个是最简单的 void bubbleSortOne(int *p,int length) { int i=length; int j,temp

全排列算法的递归与非递归实现

全排列算法的递归与非递归实现 全排列算法是常见的算法,用于求一个序列的全排列,本文使用C语言分别用递归与非递归两种方法实现,可以接受元素各不相同的输入序列. 题目来自leetcode: Given a collection of numbers, return all possible permutations. For example, [1,2,3] have the following permutations: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3

全排列(递归与非递归实现)

全排列问题在公司笔试的时候很常见,这里介绍其递归与非递归实现. 递归算法 1.算法简述 简单地说:就是第一个数分别以后面的数进行交换 E.g:E = (a , b , c),则 prem(E)= a.perm(b,c)+ b.perm(a,c)+ c.perm(a,b) 然后a.perm(b,c)= ab.perm(c)+ ac.perm(b)= abc + acb.依次递归进行. void swap(string &pszStr,int k,int m) { if(k==m) return ;

二叉树之AVL树的平衡实现(递归与非递归)

这篇文章用来复习AVL的平衡操作,分别会介绍其旋转操作的递归与非递归实现,但是最终带有插入示例的版本会以递归呈现. 下面这张图绘制了需要旋转操作的8种情况.(我要给做这张图的兄弟一个赞)后面会给出这八种情况对应平衡实现. [1] 情况1-2: 这种需要旋转的结构一般称之为LL型,需要右旋 (顺时针旋转). 我用一个图来抽象一下这两个情况,画的不好,我尽量表达吧. 此时需要对A进行平衡操作,方法为: 将A的左子树换为B的右子树. B的右子树换为A. 非递归实现的代码为: 1 void rotate

算法之归并排序的递归与非递归的实现

一.什么是归并排序 归并排序就是将多个有序的数据段合成一个有序的数据段,如果参与合并的只有两个有序的数据段,则称为二路归并.与快速排序和堆排序相比,其最大的特点是一种稳定的算法,算法的平均时间复杂度O(nlog2n). 二.归并排序的基本思路 (1).对于一个原始的待排序表,可以将R[1]到R[n]可以看做是n个长度为1的有序表,即分解. (2).进行第一趟归并,即将上述的n个子序两两合并,得到 n/2向上取整 个有序表,若n为奇数,则归并到最后一个子序列长度为1,即合并. (3).再将两个 n

图的深度优先搜索 递归和非递归实现 c++版本

本文参考了李春葆版本的数据结构上机指导,但是原版是c代码, 本文用了c++实现,并且修复了深度优先搜索非递归的一个bug. graph.cpp文件: #include "graph.h" #include <queue> #include <stack> int visited[MAXV ]; MGraph ::MGraph(int A[100][10], int nn , int ee) { e= ee ; n= nn ; for (int i=0;i<

数据结构二叉树的递归与非递归遍历之 实现可编译(1)java

前一段时间,学习数据结构的各种算法,概念不难理解,只是被C++的指针给弄的犯糊涂,于是用java,web,javascript,分别去实现数据结构的各种算法. 二叉树的遍历,本分享只是以二叉树中的先序遍历为例进行说明,中序遍历和后序遍历,以此类推! 二叉树递归与非递归遍历的区别,虽然递归遍历,跟容易读懂,代码量少,运算快,但是却容易出现溢出的问题,所以所以非递归遍历,在处理千万级的运算量时会先的很有用处. 二叉树的先序遍历:先访问根节点,再访问先后访问左右节点.如图: 二叉树的递归遍历之java

归并排序(递归、非递归、以及自然归并排序)算法总结

注:本文所指归并排序指 二路归并排序. 归并排序是平均情况.最坏情况.最好情况时间复杂度都为O(Nlog2N)的稳定的排序算法.最近梳理了下归并排序的递归.非递归.以及自然归并排序算法. 归并排序的基础:将两个有序数组合并为一个有序数组,需要O(n)的辅助空间. 图片来自:https://www.cnblogs.com/chengxiao/p/6194356.html // array:待排序数组 //temparray: 临时数组 //startindex:起始下标 //middleindex

数据结构——二叉树遍历之“递归与非递归遍历”

简述 二叉树的遍历分为先序遍历.中序遍历和后序遍历.如下图所示: 递归遍历 private void bianli1(List<Integer> list, TreeNode root) { // 先序遍历 if (root == null) { return; } list.add(root.val); bianli1(list, root.left); bianli1(list, root.right); } private void bianli2(List<Integer>