C语言实现直接插入排序,冒泡排序以及二分查找(巩固理解记忆)

C语言实现直接插入排序,冒泡排序以及二分查找(巩固理解记忆)

虽然直接插入排序,冒泡排序以及二分查找是算法中最为基础以及老掉牙的话题,但作为一名算法的深爱者,有时候无聊时候总会将这些简单的话题重新理解并敲写一番,目的只是为了得到理解娴熟的程度。而且,我觉得越是简单基础的东西,有时候更应该反复的去敲写,深化它,并最终让其中的思想内化为自己的一部分。待到他日一提起之时,会相当娴熟的“刷刷刷。。。”几分钟搞定,那就很有成就感了!

因为我喜欢对于一个问题进行实例的剖析,进而再转化为特有的用某种数学式子或者算法符号来表达,然后再附上一部分的算法伪代码,最终再“哒哒哒。。。”敲上自己的”艺术杰作“。而在这一过程,我喜欢在纸上思绪腾飞般胡乱描绘我的思路。。。

首先是直接插入排序

以下是自己的分析过程以及实例解析

对应的代码:

/**
直接插入排序:加强理解记忆
*/

#include <stdio.h>

#define N 7

void DInsertSort(int* arr,int n)
{
	int i,temp,pos,k;
	//从第二个元素开始
	for (i=1;i<n;i++)
	{
		temp=arr[i];
		pos=i;
		k=i-1;
		while (k>=0 && temp<arr[k])
		{
			k -= 1;
		}
		//终于跳出while循环----有两种情况:k<0  或者  temp>=arr[k]   不管哪种情况,以下都适合
		k += 1;
		//往后搬迁元素
		while (pos>k)
		{
			arr[pos] = arr[pos-1];
			pos -= 1;
		}
		//搬迁完毕,回填元素
		arr[pos]=temp;

	}
}

int main()
{
	//int R[N]={0,2,3,1,5,7,0};
	int R[N]={-1,-3,-5,-9,0,1,0};
	printf("数组原先的元素: ");
	for (int i=0;i<N;i++)
	{
		printf("%d ",R[i]);
	}
	printf("\n");

	DInsertSort(R,N);

	printf("直接插入排序后数组的元素: ");
	for (int j=0;j<N;j++)
	{
		printf("%d ",R[j]);
	}
	printf("\n");

	return 0;
}

接着是冒泡排序:这一老掉牙的算法在这里提供两种实现方式--一种是传统的两两比较作交换,一种是加上一个change作为在一次比较中发现后续元素是否有序。

代码如下:

/**
冒泡排序:加强对其的理解
*/

#include <STDIO.H>

#define N 7

//传统的冒泡排序
void BubbleSortOne(int* arr,int n,int& count)
{
	int temp;
	for (int j=0;j<n-1;j++)
	{
		for (int i=0;i<n-j-1;i++)
		{
			if (arr[i]>arr[i+1])
			{
				temp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=temp;

				count += 1;
			}
		}
	}

}

//加上change标志的冒泡排序
void BubbleSortTwo(int* arr,int n,int& count)
{
	bool change=true;
	int temp;
	for (int j=0;j<n-1&&change;j++)
	{
		change=false;
		for (int i=0;i<n-j-1;i++)
		{
			if (arr[i]>arr[i+1])
			{
				temp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=temp;

				change=true;

				count += 1;
			}
		}

	}
}

int main()
{
	//int R[N]={2,4,1,0,0,2,5};
	int R[N]={1,0,2,0,7,3,5};
	printf("原先数组的元素: ");
	for (int i=0;i<N;i++)
	{
		printf("%d ",R[i]);
	}
	printf("\n");

	int count=0;

	BubbleSortOne(R,N,count);

	//BubbleSortTwo(R,N,count);

	printf("交换的次数: %d\n",count);

	printf("冒泡排序之后数组的元素: ");
	for (int j=0;j<N;j++)
	{
		printf("%d ",R[j]);
	}
	printf("\n");

	return 0;
}

最后是二分查找:在这里需要注意的是---1.二分查找需要查找的序列已经有序 2.在找到元素之后要跳出查找的循环。

以下是分析过程

二分查找的代码:

/**
二分查找:加强理解记忆
*/

#include <stdio.h>

#define N 7

/*找到即返回元素在数组中的物理位置,找不到则返回-1*/
int BinarySearch(int* arr,int n,int se)
{
	int low=0,high=n-1;
	int mid=0,pos=-1;
	while (low<=high)
	{
		mid=(low+high)/2;
		if (se>arr[mid])
		{
			low=mid+1;
		}
		else if (se<arr[mid])
		{
			high=mid-1;
		}
		else
		{
			//return mid;
			pos=mid;
			break;
			//差点忘记break掉;  ---或者此处直接return回去:return pos也可以---只是觉得这样子写不规范
		}
	}
	if (pos!=-1)
	{
		return pos;
	}
	else
	{
		return -1;
	}

}

int main()
{
	int arr[N]={0,1,2,4,5,6,8};
	printf("数组中的元素: ");
	for (int i=0;i<N;i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");

	int val=8;
	//int val=-9;

	//printf("%d",BinarySearch(arr,N,val));
	int pos=BinarySearch(arr,N,val);
	if (pos != -1)
	{
		printf("元素%d是数组中第%d元素\n",val,pos+1);
	}
	else
	{
		printf("元素%d不存在与该数组中\n",val);
	}

	return 0;
}

总结:这一整个分析过程下来,感觉有助于提高自己的思考!!很美好

时间: 2024-10-13 11:37:28

C语言实现直接插入排序,冒泡排序以及二分查找(巩固理解记忆)的相关文章

选择、冒泡排序,二分查找法以及一些for循环的灵活运用

import java.util.Arrays;//冒泡排序 public class Test { public static void main(String[] args) { int[] array = { 31, 22, 15, 77, 52, 32, 18, 25, 16, 7 }; // 冒泡 --> 两两比较 --> 提取出最大的数 在最后一位 //拿第一位和它后面的一位进行 两两比较 System.out.println(Arrays.toString(array)); fo

Java冒泡排序和二分查找(预习)

经查阅,将资料整理如下: 一.冒泡排序 1.算法简介 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成. 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名. 2.算法原理 (1)比较相邻的元素.如果第一个比第二个大,就交换他们两个. (2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. (3)针对所有的元素重复以上的

冒泡排序、二分查找法

冒泡排序的基本思想是对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组前面,把大的元素移动到数组后面(也就是交换两个元素的位置),这样数组元素就像气泡一样从底部上升到顶部. 1 package com.hanqi; 2 3 public class maopao { 4 5 public static void main(String[] args) { 6 int[]array=new int[]{63,4,24,1,3,13}; 7 System.out.println("冒

【C/C++】冒泡排序与二分查找

冒泡排序:就是相邻两个数进行比较,如果a>b(或者a<b)则交换值,每次把一个最大(或者最小)的值往后推. 二分查找:每次取头和尾的中间下标的值a与目标值b进行比较,如果a>b表示目标值b在中间下标前面,把头指向中间下标的前一位:如果a<b表示目标值b在是中间下标后面,把尾指向中间下标的后一位:如果a==b则返回中间下标.查找失败返回-1. 1.随机初始化一个指定长度的数组. 2.对数组进行排序. 3.输入一个值,并查找该值在数组中的下标.

关于数组的几个小题目-冒泡排序、二分查找、直接选择排序、反转数组

1. 实现冒泡排序算法,对比相邻元素,如果满足条件就叫唤元素值,把较小的元素移动到数组前面,把较大的元素移动到数组的后面,这样较小的元素就逐渐从底部上升到顶部,排到前面了. public class zuoye14_maopaopaixu { public static void main(String[] args){ int[] array = new int[]{12,45,21,35,65,24,43}; for(int i=0;i<array.length;i++){ for(int

js基本算法:冒泡排序,二分查找

知识扩充: 时间复杂度:算法的时间复杂度是一个函数,描述了算法的运行时间.时间复杂度越低,效率越高. 自我理解:一个算法,运行了几次时间复杂度就为多少,如运行了n次,则时间复杂度为O(n). 1.冒泡排序 解析:1.比较相邻的两个元素,如果前一个比后一个大,则交换位置. 2.第一轮的时候最后一个元素应该是最大的一个. 3.按照步骤一的方法进行相邻两个元素的比较,这个时候由于最后一个元素已经是最大的了,所以最后一个元素不用比较. 1 function sort(elements){ 2 for(v

深入浅出数据结构C语言版(12)——从二分查找到二叉树

在很多有关数据结构和算法的书籍或文章中,作者往往是介绍完了什么是树后就直入主题的谈什么是二叉树balabala的.但我今天决定不按这个套路来.我个人觉得,一个东西或者说一种技术存在总该有一定的道理,不是能解决某个问题,就是能改善解决某个问题的效率.如果能够先了解到存在的问题以及已存在的解决办法的不足,那么学习新的知识就更容易接受,也更容易理解. 万幸的是,二叉树的讲解是可以按照上述顺序来进行的.那么,今天在我们讨论二叉树之前,我们先来讨论一种情形.一种操作:假设现在有一个数组,数组中的数据按照某

C语言练习题1(关于快速排序,二分查找与运行时间)

刚刚完成师兄给的一道题目: 随机生成10000位数,进行快速排序后,用二分查找法定位到某个要查询的数(键盘输入某个要查询的数),  结果输出查询的时间,以及是否查到 分享下自己的解题思路: 1,要懂得如何随机生成数 2,要了解快速排序以及二分法思想 3,要直到如何测试出程序运行时间 下面是自己写的代码,欢迎各位提出宝贵的意见以及见解,小生感激不尽 1 /* 2 本代码描述: 3 4 随机生成10000位数,进行快速排序后, 5 用二分查找法定位到某个要查询的数 6 (键盘输入某个要查询的数),

0913作业(冒泡排序、二分查找法、模拟摇乐游戏)

1.冒泡排序从小到大打印出(代码如下) package f.java; public class LS { public static void main(String[] args) { // TODO Auto-generated method stub int[]i={10,20,30,14,15,26}; for(int a=0;a<i.length;a++) { for(int b=a+1;b<i.length;b++) { int temp; if(i[a]>i[b]) {