冒泡---插入---希尔排序

<span style="color:#ff0000;">#include<iostream>
using namespace std;

#define MAXSIZE  21
typedef int SqList[MAXSIZE];
#define   ElementType int
void Swap(int &a, int &b)
{
    a = a^b;
    b = a^b;
    a = a^b;
}
 //////////////////////////////////////////////////////

void Bubble_Sort( ElementType A[], int N )//冒泡排序
{ 

	for ( int P=N-1; P>=0; P-- )
	{
	    int	flag = 0;
		for( int i=0; i<P; i++ )
		{ /* 一趟冒泡*/
		   if ( A[i] > A[i+1] )
			{
				Swap(A[i], A[i+1]);
	       		flag = 1; /* 标识发生了交换*/
			}
		}
	    	if ( flag==0 ) break; /* 全程无交换*/
	}
}
//****************************************
void Insertion_Sort( ElementType A[], int N )//插入排序
{
	for (int P=1; P<N; P++ )
	{
		int Tmp = A[P]; /* 取下一个数*/
		for ( int i=P; i>0 && A[i-1]>Tmp; i-- )
		{
			A[i] = A[i-1]; /* 移出空位*/
		}
		A[i] = Tmp; /* 新数落位*/
	}
}
//***************************************************

void Shell_sort( ElementType A[], int N )//希尔排序
{
	for (int D=N/2; D>0; D/=2 )
	{ /* 希尔增量序列*/
		for (int P=D; P<N; P++ )
		{ /* 插入排序,每次隔D个*/
			int Tmp = A[P];
			for ( int i=P; i>=D && A[i-D]>Tmp; i-=D )
			{
				A[i] = A[i-D];
			}
			 A[i] = Tmp;

		}
	}
}

//////////////////////////////////////////////////////

void main()
{
	SqList sq = { 49, 38, 65, 97, 76, 13, 27, 49 };

    // Bubble_Sort(sq,8 );
	// Insertion_Sort(sq,8);
	 Shell_sort(sq,8);
	 for (int i = 0; i < 8; ++i)
    {
		 cout << sq[i] <<",";
    }
    cout << endl;    

}

///////////////////////////////////////////////////////</span>

时间: 2024-12-21 22:16:53

冒泡---插入---希尔排序的相关文章

算法学习#09--用简单的思维理解选择、插入、冒泡和希尔排序

选择排序 1.原理 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾.以此类推,直到所有元素均排序完毕. 2.特点 ①运行时间与输入无关. 无论输入初始状态如何,是否有序,都需要遍历数组来找出最小的元素.其他算法则更善于利用输入的初始状态来优化时间. ②数据移动次数最小. 如果某个元素位于正确的最终位置上,则它不会被移动.选择排序每次交换一对元素,它们当中至少有一个将被移到其最终位置上,因此对n个元素的表进

算法: 二分查找 冒泡 插入 选择排序

1 二分查找:二分查找从有序列表的候选区data[0:n]开始,通过对半查找的值与候选区中间的值进行比较 方法一:利用for循环, 时间复杂度是o(n) li = [1, 3, 5, 7, 9, 11, 15, 18, 20] def linear_serach(li, value): for i in range(len(li)): if li[i] == value: return i return print(linear_serach(li,3)) 方法二: 利用二分查找, 效率高, 时

1. 算法 -- 排序(插入,冒泡,希尔,快速,选择)

1.  插入排序===================================================== 算法思想简单描述: 在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的.如此反复循环,直到全部排好顺序. 直接插入排序是稳定的.算法时间复杂度O(n2)--[n的平方] 一般来说,插入排序都采用in-place在数组上实现.具体算法描述如下:1.从第一个元素开始,该元素可以认为已经被排序

冒泡 选择 插入 希尔 堆 归并 快速 排序算法

排序相关概念 排序:对一序列对象根据某个关键字进行排序: 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面: 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面: 内排序:所有排序操作都在内存中完成: 外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行: 排序耗时的操作:比较.移动: 排序分类: (1)交换类:冒泡排序.快速排序:此类的特点是通过不断的比较和交换进行排序: (2)插入类:简单插入排序.希尔排序:此类的特点是通过插入的

快排,冒泡排,选择排序,希尔排序

package cn.hncu.dataStruct; public class SortMethods { /* 算法好坏的评价指标(一般只在n值非常大的时候才会考虑,如n取10万): * 1.时间复杂度: 通俗点,就是指程序运行的快慢(时间)---通常用计算机的运算(算术,赋值)次数来代替 * 2.空间复杂度: 占用内存空间的大小---通常用程序中使用了多少变量(栈内存.堆内存),这些变量总共占了多少内存 */ public static void main(String[] args) {

详谈排序算法之插入类排序(两种思路实现希尔排序)

1. 排序( sorting) 的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列.其确切的定义为: 假设有n个数据元素的序列{R1 , R2 , - , Rn},其相应关键字的序列是{K1 , K2 , - , Kn} ,通过排序要求找出下标 1 , 2 , - , n的一种排列p1 , p2 , - , pn,使得相应关键字满足如下的非递减(或非递增)关系Kp1 ≤ Kp2 ≤ - ≤ Kpn这样,就得到一个按关键字有序的纪录序列{ Rp1 , Rp2 , - , Rpn }

数据结构与算法——插入类排序(直接插入排序,希尔排序)

一.直接插入排序 对于一个有序的序列,不断将后面的元素插入前面的有序序列,保持序列继续有序. 对于直接插入排序的思路:将要排序的元素保存,然后逐个和其前面的元素进行比较,如果前面的元素比其大,则将前面的元素后移一个. 时间复杂度为n*n void insert_sort(int a[],int n) { int i,j; int temp; for(i=1;i<n;i++) { temp = a[i]; j=i-1; while((j>=0)&& (temp<a[j]))

排序算法-冒泡——插入——快排

冒泡排序,往两个方向泡,一个往小泡,一个网大泡 #include<stdio.h> #include<stdlib.h> #include<time.h> void bubble_sort(int *a,int n){ int temp; for(int i=0;i<n;i++) for(int j=0;j<n-i-1;j++){ if(a[j]>a[j+1]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } v

插入类排序:直插,折半插,希尔

插入类排序: 1:直接插入排序O(n^2) 2:折半插入排序O(n^2) 3:希尔排序 O(n乘以log以2为底,n的对数) 空间复杂度都是O(1) //直接插入排序 void InsertSort(int R[],int n) { int i,j; int tmp; for(i=1;i<n;i++)//数组下标从0开始,第一个有序,所以从1开始 { tmp=R[i]; j=i-1; while(j>=0 && tmp<R[j])//元素右移,以便插入 { R[j+1]=