三类最基本排序(插入,冒泡,选择)

插入是稳定的,冒泡稳定性取决于是否有等号,选择是不稳定的

#include<iostream>
#include<algorithm>
#include <vector>
#include<string.h>
#include<ctype.h>
#include<math.h>
using namespace std;
void fun();
int main()
{
    fun();
    return 0;
}
void fun()
{
	int temp,i,j,
		arr1[8]={19,1,23,17,19,55,84,15},
		arr2[8]={19,1,23,17,19,55,84,15},
		arr3[8]={19,1,23,17,19,55,84,15};
	//插入排序
	for(i=1;i<8;i++)
	{
		if(arr1[i-1]>arr1[i])
		{
			temp=arr1[i];
			for(j=i-1;temp<arr1[j]&&j>-1;--j)
				arr1[j+1]=arr1[j];
			arr1[j+1]=temp;
		}
	}
	//冒泡排序
	for(int flag=1,i=1;i<8&&flag;++i)
	{
		for(flag=0,j=0;j<8-i;++j)
		{
			if(arr2[j]>arr2[j+1])
			{
				flag=1;
				temp=arr2[j+1];
				arr2[j+1]=arr2[j];
				arr2[j]=temp;
			}
		}
	}
	//选择排序
	for(int flag,i=0;i<8-1;i++)
	{
		flag=i;
		for(j=i+1;j<8;j++)
			if(arr3[j]<arr3[flag])flag=j;
		if(i!=flag)
		{
			temp=arr3[i];
			arr3[i]=arr3[flag];
			arr3[flag]=temp;
		}
	}
	for(i=0;i<8;i++)
		cout<<arr1[i]<<" ";
	cout<<endl;
	for(i=0;i<8;i++)
		cout<<arr2[i]<<" ";
	cout<<endl;
	for(i=0;i<8;i++)
		cout<<arr3[i]<<" ";
	cout<<endl;
}

结果为下图所示

时间: 2024-10-10 00:10:03

三类最基本排序(插入,冒泡,选择)的相关文章

九大排序算法及其实现- 插入.冒泡.选择.归并.快速.堆排序.计数.基数.桶排序

  闲着的时候看到一篇“九大排序算法在总结”,瞬间觉得之前数据结构其实都有学过,但当初大多数都只是老师随口带过,并没有仔细研究一下.遂觉:这是欠下的账,现在该还了.   排序按照空间分类: In-place sort不占用额外内存或占用常数的内存 插入排序.选择排序.冒泡排序.堆排序.快速排序. Out-place sort:归并排序.计数排序.基数排序.桶排序. 或者按照稳定性分类: stable sort:插入排序.冒泡排序.归并排序.计数排序.基数排序.桶排序. unstable sort

java中各种经典排序(冒泡 选择 插入 希尔等)

1 import java.util.Arrays; 2 3 public class ArraySort { 4 public static void main(String[] args) { 5 int[] arr = { 12, 23, 14, 5, 64, 35, 42 }; 6 System.out.println("排序前:"); 7 System.out.println(Arrays.toString(arr)); 8 // bubbleSort(arr); 9 //

简单排序:插入,选择和冒泡

void selectsort(int a[],int n) // 选择排序的思路就是每次找到当前序列中最小的元素,然后交换 { // 就是选择最小的,然后交换 int i,j,flag; for(i = 0;i<n;i++) { flag = i; //当前元素 for(j = i+1;j<n;j++) { if(a[j]<a[flag]) flag = j; //在剩下未排序的数组中找到最小元素的下标 } int temp = a[i]; //交换当前元素和最小元素. a[i] =

排序算法-冒泡、插入、归并、希尔、快速、选择--代码总结

冒泡排序代码: #include <iostream> #include <string> using namespace std; template<class ItemType> void bubbleSort(ItemType theArray[], int n) { bool sorted = false; // False when swaps occur int pass = 1; while (!sorted && (pass < n

python 数据结构与算法之排序(冒泡,选择,插入)

目录 数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 数据结构与算法: 算法: 数据结构 冒泡排序法 选择排序法 插入排序法 数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 计算机重要的几门课: 1.数据结构和算法 2.网络 3.操作系统 4.计算组成原理 数据结构与算法: 算法: 衡量算法的标准: 时间复杂度:就是程序代码执行的大概次数 小结: 时间复杂度是用来估计算法运行时间的一个式子(单位) 一般来说,时间复杂度高的算法比复杂度低的算法慢 常见的

基础排序算法—冒泡,插入,选择

前言 冒泡,插入,选择这三种基础的排序算法,比较简单效率不高,工作中一般不会使用,但是当做算法来研究还是能了解一些知识的,本文以<数据结构与算法之美>为基础,详细解析一下. 正文 首先要引入几个概念 稳定性 如果待排序数组中有相同的元素,排序过后它们的相对顺序不发生变化. 比如 2,9,3,4,8,3 排序过后为2, 3 , 3, 4, 8, 9 这两个3的相对顺序不变.这样就是具有稳定性. 稳定性可以保证复杂数据结构排序时的相对有序性. 比如我们要对一笔订单先按金额排列,金额相同的再按时间排

“《算法》第4版第2章‘排序’”:初级排序算法(选择、冒泡、插入、希尔)

<算法>第4版作者是Robert Sedgewick 和 Kevin Wayne. 1. 选择排序 选择排序可以说是最简单的排序方法.首先,找到数组中最小的那个元素:其次,将它与数组的第一个元素交换位置(如果第一个元素就是最小元素,那么它就和自己交换):再次,在剩下的元素中找到最小的元素,将它与数组的第二个元素交换位置.如此往复,直到将整个数组排序. 该书中提出一个命题:对于长度为N的数组,选择排序需要大约N2/2次比较和N次交换.  程序如下: 1 void SelectionSort::s

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

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

冒泡 选择排序

算法一直是编程的基础,而排序算法是学习算法的开始,排序也是数据处理的重要内容.所谓排序是指将一个无序列整理成按非递减顺序排列的有序序列.排列的方法有很多,根据待排序序列的规模以及对数据的处理的要求,可以采用不同的排序方法.那么就整理下网上搜索的资料,按自己的理解,把C语言的8大排序算法列出来. 普通意义上,排序算法可以分为三大类: 1 交换类排序法2 插入类排序法3 选择类排序法 一.交换类排序法 所谓交换排序法是指借助数据元素之间互相交换进行排序的方法.冒泡排序与快速排序法都属于交换类排序方法

数据结构--排序(上)--简单排序(冒泡,插入)

简单排序(冒泡,插入) 介绍两大类算法,一类是排序,一类是查找 前提:X是排序的算法 void X_sort( ElementType A[],int N) . N是正整数,只讨论基于比较的排序(< = >有定义) 只讨论内部排序(所有数据都可以导入内部空间) 稳定性:任意两个相等的数据,排序前后的相对位置不发生改变. 没有一种排序是任何情况下都表现最好的. 冒泡排序 第一次冒泡最大的泡泡一定在最下面. void Bubble_sort(ElementType A[], int N){ for