选择 冒泡 快速 插入排序

/**
* 演示各种排序法
*/
package com.test1;
import java.util.*;
public class Demo5_3 {
public static void main(String[] args) {
// TODO Auto-generated method stub

int len=8;
int arr1[]=new int[len];
for(int i=0;i<len;i++)
{
//让程序随机产生一个1-10000的数
//Math.random()会随机产生一个0-1的数
int t=(int)(Math.random()*10000);
arr1[i]=t;
}
int arr[]={1,6,0,-1,9,4,34,2};
//创建一个bubble类
//Bubble bubble=new Bubble();
//bubble.sort(arr);

//创建一个select类
//Select select=new Select();
Bubble bubble=new Bubble();
QuickSort qs=new QuickSort();

//在排序前打印系统时间
Calendar cal=Calendar.getInstance();
System.out.println("排序前"+cal.getTime());
//bubble.sort(arr1);
qs.sort(0, arr1.length-1, arr1);
//重新得到实例
cal=Calendar.getInstance();
System.out.println("排序后"+cal.getTime());

InsertSort insertsort=new InsertSort();
insertsort.sort(arr);

//输出排序后的结果
for(int i=0;i<arr1.length;i++)
{
System.out.print(arr1[i]+" ");
}
}

}

//快速排序
class QuickSort{

public void sort(int left,int right,int array[]){
int l=left;
int r=right;
int pivot=array[(left+right)/2];
int temp=0;

while(l<r){
while(array[l]<pivot) l++;
while(array[r]>pivot) r--;

if(l>=r) break;

temp=array[l];
array[l]=array[r];
array[r]=temp;

if(array[l]==pivot) --r;
if(array[r]==pivot) ++l;

}
if(l==r)
{
l++;
r--;
}
if(left<r) sort(left,r,array);
if(right>l) sort(l,right,array);
}
}

//插入排序
class InsertSort
{
public void sort(int arr[])
{
for(int i=1;i<arr.length;i++)
{
int insertVal=arr[i];
//insertVal准备和前一个数比较
int index=i-1;
while(index>=0&&insertVal<arr[index])
{
//将把arr[index]向后移动
arr[index+1]=arr[index];
index--;
}
//将insertVal插入适当位置
arr[index+1]=insertVal;

}
}
}

class Select
{
//选择排序
public void sort(int arr[])
{
int temp=0;
for(int j=0;j<arr.length-1;j++)
{
//认为第一个数最小
int min=arr[j];
//记录最小数的下标
int minIndex=j;
for(int k=j+1;k<arr.length;k++)
{
if(min>arr[k])
{
//修改最小
min=arr[k];
minIndex=k;
}
}
//交换
temp=arr[j];
arr[j]=arr[minIndex];
arr[minIndex]=temp;
}
}
}

class Bubble{
//排序方法
public void sort(int arr[])
{
int temp=0;
//排序
//外层循环,决定一共走几趟
for(int i=0;i<arr.length-1;i++)
{
//内层循环,开始逐个比较,如果发现前一个数后一个数大,则交换
for(int j=0;j<arr.length-1-i;j++)
{
if(arr[j]>arr[j+1])
{
//交换位置
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;

}
}
}
}
}

时间: 2024-10-26 12:19:05

选择 冒泡 快速 插入排序的相关文章

【技术宅2】插入选择冒泡快速交换排序算法

//插入排序(一维数组) //插入排序(Insertion Sort)的基本思想是:每次将一个待排序的记录,按其关键字大小插入到前面已经排好序的子文件中的适当位置,直到全部记录插入完成为止. function insert_sort($arr){ $count=count($arr); for($i=1;$i<$count;$i++){ $tem=$arr[$i];// 获得当前值 $j=$i-1;// 获得当前值的前一个位置 while($arr[$j]>$tem){// 如果当前值小于前一

八大内部排序算法(上)-冒泡、直接插入、简单选择、快速

八大内部排序算法(上)冒泡.直接插入.简单选择.快速 排序分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 1.直接插入排序 将一个记录插入到已排序好的有序表中,从而得到一个新,记录数增1的有序表.即:先将序列的第1个记录看成是一个有序的子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止. 要点:设立哨兵,作为临时存储和判断数组边界之用. 直接插入实现如下:

时间/空间复杂度,基础排序算法(冒泡、选择、快速、插入)

一.时间复杂度.空间复杂度 时间复杂度:用来评估算法运行效率的一个东西,用O()来表示 举例时间复杂度计算: print('Hello World') O(1) for i in range(n): #n次循环 print('Hello World') O(n) for i in range(n): for j in range(n): #两个n嵌套循环 print('Hello World') O(n²) 以下这些代码时间复杂度呢? print('Hello World') print('He

各种常见的排序,冒泡排序,选择排序,插入排序,希尔排序,堆排序,快速排序,基数排序,桶排序

各种常见的排序 要开始找工作了,把以前学的各种小知识复习一遍,以下是各种常见的排序的简单实现(冒泡排序,选择排序,插入排序,希尔排序,堆排序,快速排序,基数排序,桶排序),至于原理就不写出来了,代码比较简单,看一下就懂,再不行可以随意找本书或百度! #include <iostream> using namespace std; // 冒泡 void BubbleSort(int data[], int length) { if(data == NULL || length <= 0)

冒泡以及插入排序算法的改进

冒泡排序 说明:此文中的排序算法数组,第一个数(即0下标)没有作为数据处理(i从1开始),arr[0]用作哨岗,部分排序算法(如插入排序)比较时需要用到 排序思想: 1.假设共有N个数,从头开始,比较相邻的两个数,如果前一个数比后一个数大,则交换位置,否则不变,继续比较. 2.按照这样的方法对数组从0到N-1进行遍历,一轮遍历完,则最后一个数为最大值. 3.N=N-1,按照1,2的思想遍历N-1轮,则数组从大到小排序成功 void Popsort(int arr[],int n)//冒泡排序 {

选择排序、插入排序、冒泡排序python实现

选择排序的时间复杂度为O(n^2),是不稳定的排序 冒泡排序的时间复杂度最好情况下为O(n),最坏情况下为O(n^2),平均情况下为O(n^2),是稳定的排序 插入排序的时间复杂度最好情况下为O(n),最坏情况下为O(n^2),,平均情况下为O(n^2),是稳定的排序 1.选择排序 def selection(lista): leng=len(lista); for i in range(0,leng): index=i; min=lista[i]; for j in range(i,leng)

Java选择排序,插入排序,快速排序

public class Test { public static void main(String[] args) { int a[] = { 1, 2, 3, 4, 5 }; // 选择排序(a); // 插入排序(a); quicksort(a, 0, a.length - 1); System.out.print("排序后:"); for (int n : a) { System.out.print(n + " "); } } static void 选择排

JavaScript算法(冒泡排序、选择排序与插入排序)

冒泡排序.选择排序与插入排序复杂度都是指数级别的,放在一起说吧. 介绍一些学习这三个排序方法的比较好的资料.冒泡排序看<学习JavaScript数据结构与算法>介绍的冒泡排序,选择排序看<计算机科学概论(第三版)>里介绍的选择排序,插入排序看<计算机科学概论(第11版)>里介绍的插入排序, 通过这三份资料弄明白实现原理之后,最后看<学习JavaScript数据结构与算法>一书里的JS实现代码. 嗯,这本书里都有现成代码,就不在这儿写了,关键是弄清楚原理,然后

算法—比较两种排序算法:选择排序和插入排序

现在我们已经实现了两种排序算法,我们很自然地想知道选择排序和插入排序哪种更快.这里我们第一次用实践说明我们解决这个问题的办法. 性质:对于随机排序的无重复主键的数组,插入排序和选择排序的运行时间是平方级别的,两者之比应该是一个较小的常数. 例证:这个结论在过去的半个世纪中已经在许多不同类型的计算机上经过了验证.在1980年本书第一版完成之时插入排序就比选择排序快一倍,现在仍然是这样,尽管那时这些算法将10万条数据排序需要几个小时而现在只需要几秒钟.在你的计算机上插入排序也比选择排序快一些吗?可以