冒泡排序优化以及插入排序(本文凝视较少适合有一定基础的观看)

#include<stdio.h>
#define cnt 6  //定义排序个数
//冒泡排序优化
void Bubble_Sort(int A[],int N)
{
	for(int P = N - 1; P >= 0;P--)
	{

		int flag = 0;                  //定义一个flag推断之后的序列是否有序
		for(int i = 0;i < P;i++)       //一趟冒泡
		{
			if(A[i] > A[i+1])          //一次一次的冒泡
			{
				int temp = A[i+1];
				A[i+1] = A[i];
				A[i] = temp;
			}
			flag = 1;
		}
		if(flag == 1)                  //说明之后的序列以及有序不用在排
			break;
	}
}

//插入排序
void Insertion_Sort(int A[],int N)
{
	for(int P = 1;P < N;P++) //初始数字 把P【0】当成基本数字 然后进行插入N张牌  for循环运行顺序先运行1 然后推断是否满足条件
	{
		int Tmp = A[P];      //存放须要插入的数字
		int i;               //记录移动位置
		for(i = P;i>0&&A[i-1]>Tmp;i--)     //对须要插入的数进行移动
		{
			A[i] = A[i-1];
		}
		A[i] = Tmp;
	}
}
int main()
{
	int a[cnt] = {5,7,4,1,9,6};
	Insertion_Sort(a,cnt);
	for(int i=0;i< cnt;i++)
	{
		printf("%d ",a[i]);
	}
	getchar();
}
时间: 2024-10-23 07:42:49

冒泡排序优化以及插入排序(本文凝视较少适合有一定基础的观看)的相关文章

冒泡排序优化以及插入排序(本文注释较少适合有一定基础的观看)

#include<stdio.h> #define cnt 6 //定义排序个数 //冒泡排序优化 void Bubble_Sort(int A[],int N) { for(int P = N - 1; P >= 0;P--) { int flag = 0; //定义一个flag判断之后的序列是否有序 for(int i = 0;i < P;i++) //一趟冒泡 { if(A[i] > A[i+1]) //一次一次的冒泡 { int temp = A[i+1]; A[i+

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定

冒泡排序优化JAVA

本文对传统的冒泡排序进行了一些优化,减少了循环次数. 时间复杂度 若文件的初始状态是正序的,一趟扫描即可完成排序.所需的关键字比较次数 C 和记录移动次数 M 均达到最小值: C(min)=n-1 , M(min)=0 .所以,冒泡排序最好的时间复杂度为 O(n); 若初始文件是反序的,需要进行  趟排序.每趟排序要进行  次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置.在这种情况下,比较和移动次数均达到最大值: 冒泡排序的最坏时间复杂度为O(n^2) . 综上

冒泡排序优化

直接上代码: #define swap(a,b) {a ^= b; b ^= a; a ^= b;} void sort(int *arr, int num){ for(int i = 0; i < num - 1; ++i){ bool isOk = true;   // 是否排序完成 for(int j = 0; j < num - 1 - i; ++j){ if(arr[j] > arr[j + 1]){ isOk = false; swap(arr[j], arr[j + 1])

冒泡排序-优化后的

时间复杂度 若文件的初始状态是正序的,一趟扫描即可完成排序.所需的关键字比较次数  和记录移动次数  均达到最小值:  ,  .所以,冒泡排序最好的时间复杂度为  . 若初始文件是反序的,需要进行  趟排序.每趟排序要进行  次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置.在这种情况下,比较和移动次数均达到最大值: 冒泡排序的最坏时间复杂度为 . 综上,因此冒泡排序总的平均时间复杂度为 . 算法稳定性 冒泡排序就是把小的元素往前调或者把大的元素往后调.比较是相邻

选择排序,冒泡排序,直接插入排序

protected void SelectSort(int[] array) { int tmp;//暂存要交换的数据 int t;//交换数据的位置 for (int i = 0; i < array.Length; i++) { t = i; for (int j = i + 1; j < array.Length; j++) { if (array[j] < array[t]) { t = j; } } tmp = array[i]; array[i] = array[t]; ar

算法_基本排序算法之冒泡排序,选择排序,插入排序和希尔排序

排序的元素实现了Comparable接口,以达到对于通用性. 最基础的排序是冒泡排序,下面是其思路: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 下面是其实现代码: public class Maopao { public void sort(Comparable[]

冒泡排序和直接插入排序和选择排序

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 24.0px "PingFang SC" } p.p2 { margin: 0.0px 0.0px 0.0px 0.0px; font: 24.0px "PingFang SC"; min-height: 33.0px } 简单排序(学完了要及时复习,不然像没学一样,而且 以后要花更多的时间) 冒泡排序:小的数往上冒 冒泡排序(BubbleSort)是重复地走访要排序的数列,

基本排序算法(冒泡排序 选择排序 插入排序 快速排序 归并排序 基数排序 希尔排序)

冒泡排序 public static void bubbleSort(int[] arr){ int lgn = arr.length; for (int i = 0; i < lgn - 1; i++) { for (int j = 0; j < lgn - 1 - i; j++) { if(arr[j] > arr[j + 1]){ int temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; } } } } 选择排序 publ