各排序算法的Java实现及简单分析
一,直接插入排序
//直接插入排序的算法时间复杂度分析:
//如果输入为正序,则每次比较一次就可以找到元素最终位置,复杂度为O(n)
//如果输入为反序,则每次要比较i个元素,复杂度为O(n2)
//平均时间复杂度为O(n2)
public static void straigthInsertSort(int[] num)
{
int n = num.length;
for(int i = 1;i < n;i++)//从第二个开始向前插入
{
int x = num[i];
int j;
for(j = i - 1;j >= 0&&num[j] > x;j--)
{
num[j + 1] = num[j];
}
num[j + 1] = x;
print(num);
}
}
// 5 2 2 3 6 2 0 8 9 9
// 2 5 2 3 6 2 0 8 9 9
// 2 2 5 3 6 2 0 8 9 9
// 2 2 3 5 6 2 0 8 9 9
// 2 2 3 5 6 2 0 8 9 9
// 2 2 2 3 5 6 0 8 9 9
// 0 2 2 2 3 5 6 8 9 9
// 0 2 2 2 3 5 6 8 9 9
// 0 2 2 2 3 5 6 8 9 9
// 0 2 2 2 3 5 6 8 9 9
二,希尔排序
//希尔排序的时间负责度与增量的选取有关,每次折半的增量选取时间复杂度为O(n2),最佳时间复杂度为O(nlogn)
//希尔排序没有快排快,中等规模条件下表现较好,大规模情况下不如快排
//快排在最坏情况下表现极差,而希尔在最坏情况下和平均情况表现差不多
//希尔每趟排序会让序列变得更加有序,虽然下一趟元素个数增多,但是需要移动的增加并不是很多,因此效率比直接插入高很多
//希尔排序适合于大多数情况
public static void ShellSort(int[] num)
{
int n = num.length;
int d = n;
while(d != 1)
{
d = d / 2;
for(int x = 0;x < d;x++)
{
for(int i = x + d;i < n;i = i + d)
{
int tmp = num[i];
int j;
for(j = i - d;j >= 0&&num[j] > tmp;j = j - d)
num[j + d] = num[j];
num[j + d] = tmp;
}
}
print(num);
}
}
// 6 8 8 5 5 1 1 2 0 8
// 1 1 2 0 5 6 8 8 5 8
// 1 0 2 1 5 6 5 8 8 8
// 0 1 1 2 5 5 6 8 8 8
三,选择排序
//选择排序的时间复杂度是O(n2)
//因为需要进行数据的交换操作,所以选择排序算法是不稳定的
//选择排序每趟结束都有一个元素在最终位置上
public static void selectSort(int[] num)
{
int n = num.length;
for(int i = 0;i < n;i++)
{
int cur = num[i];
int key = i;//最小值的索引
for(int j = i + 1;j < n;j++)
if(num[j] < num[key])
key = j;
if(key != i)
{
num[i] = num[key];
num[key] = cur;
}
print(num);
}
}
// 0 6 1 0 9 4 8 0 2 3
// 0 6 1 0 9 4 8 0 2 3
// 0 0 1 6 9 4 8 0 2 3
// 0 0 0 6 9 4 8 1 2 3
// 0 0 0 1 9 4 8 6 2 3
// 0 0 0 1 2 4 8 6 9 3
// 0 0 0 1 2 3 8 6 9 4
// 0 0 0 1 2 3 4 6 9 8
// 0 0 0 1 2 3 4 6 9 8
// 0 0 0 1 2 3 4 6 8 9
// 0 0 0 1 2 3 4 6 8 9
四,冒泡排序
//冒泡排序的时间复杂度为O(n2)
//冒泡排序上稳定的算法
//每趟结束都有一个元素在最终位置上
public static void bubbleSort(int[] num)
{
int n = num.length;
for(int i = 0;i < n - 1;i++)
{
for(int j = 0;j < n - i - 1;j++)
{
if(num[j] > num[j + 1])
{
int tmp = num[j];
num[j] = num[j + 1];
num[j + 1] = tmp;
}
}
print(num);
}
}
// 4 0 8 3 4 2 9 7 8 4
// 0 4 3 4 2 8 7 8 4 9
// 0 3 4 2 4 7 8 4 8 9
// 0 3 2 4 4 7 4 8 8 9
// 0 2 3 4 4 4 7 8 8 9
// 0 2 3 4 4 4 7 8 8 9
// 0 2 3 4 4 4 7 8 8 9
// 0 2 3 4 4 4 7 8 8 9
// 0 2 3 4 4 4 7 8 8 9
// 0 2 3 4 4 4 7 8 8 9
五,快速排序
//快排的时间复杂度为O(nlogn)
//当n较大时用快排比较好,当序列基本有序时,用快排反而不太好
//快排是不稳定的
//快排被认为是相同时间复杂度下平均性能最好的排序算法
public static void quickSort(int[] num)
{
quick(num,0,num.length - 1);
} private static void quick(int[] num,int low,int high)
{
if(low < high)//!
{
int mid = partition(num, low, high);
print(num);
quick(num,low,mid - 1);
quick(num,mid + 1,high);
}
} private static int partition(int[] num,int low,int high)
{
int temp = num[low];
while(low < high)
{
while(num[high] >= temp&&high > low)
high--;
num[low] = num[high];
while(num[low] <= temp&&high > low)
low++;
num[high] = num[low];
}
num[low] = temp;
return low;
}
// 3 2 6 5 8 4 6 9 2 2
// 2 2 2 3 8 4 6 9 5 6
// 2 2 2 3 8 4 6 9 5 6
// 2 2 2 3 8 4 6 9 5 6
// 2 2 2 3 6 4 6 5 8 9
// 2 2 2 3 5 4 6 6 8 9
// 2 2 2 3 4 5 6 6 8 9
六,堆排序
//堆排序的时间复杂度是O(nlogn)
//堆排序是不稳定的排序算法
//由于初始建堆时比较的次数较多,所以堆排序不适合于记录较少的情况
public static void heapSort(int[] num)
{
int n = num.length;
for(int i = (n - 1) / 2;i >= 0;i--)
heapAdjust(num, i, n);
for(int i = 0;i < n;i++)
{
int tmp = num[0];
num[0] = num[n - 1 - i];
num[n - 1 - i] = tmp;
print(num);
heapAdjust(num, 0, n - 1 - i);
}
} private static void heapAdjust(int[] num,int s,int size)
{
int tmp = num[s];
int child;
while(s < size)
{
child = s * 2 + 1;
if(child < size - 1&&num[child] < num[child + 1])
child++;
if(child >= size||num[s] > num[child])
break;
num[s] = num[child];
s = child;
num[child] = tmp;
}
}
// 5 7 7 6 0 6 4 0 1 4
// 0 6 7 5 4 6 4 0 1 7
// 1 6 6 5 4 0 4 0 7 7
// 0 5 6 1 4 0 4 6 7 7
// 0 5 4 1 4 0 6 6 7 7
// 0 4 4 1 0 5 6 6 7 7
// 0 1 4 0 4 5 6 6 7 7
// 0 1 0 4 4 5 6 6 7 7
// 0 0 1 4 4 5 6 6 7 7
// 0 0 1 4 4 5 6 6 7 7
// 0 0 1 4 4 5 6 6 7 7
七,归并排序
//归并排序是稳定的排序算法
//归并排序的时间复杂度是O(nlogn)
//归并排序的速度仅次于快速排序,适用于总体无序但个子项相对有序的情况
public static void mergeSort(int[] num)
{
int n = num.length - 1;
mergeRecursive(num, 0, n);
} private static void mergeRecursive(int[] num,int left,int right)
{
if(left < right)
{
int middle = (left + right) / 2;
mergeRecursive(num, left, middle);
mergeRecursive(num, middle + 1, right);
merge(num,left,middle,right);
}
} private static void merge(int[] num,int left,int middle,int right)
{
int[] tmp = new int[num.length];
int mid = middle + 1;
int index = left;
int originLeft = left;
while(left <= middle&&mid <= right)
{
if(num[left] < num[mid])
tmp[index++] = num[left++];
else
tmp[index++] = num[mid++];
}
while(left <= middle)
tmp[index++] = num[left++];
while(mid <= right)
tmp[index++] = num[mid++];
while(originLeft <= right)
num[originLeft] = tmp[originLeft++];
print(num);
}
// 5 7 7 8 2 0 5 0 3 4
// 5 7 7 8 2 0 5 0 3 4
// 5 7 7 8 2 0 5 0 3 4
// 5 7 7 2 8 0 5 0 3 4
// 2 5 7 7 8 0 5 0 3 4
// 2 5 7 7 8 0 5 0 3 4
// 2 5 7 7 8 0 0 5 3 4
// 2 5 7 7 8 0 0 5 3 4
// 2 5 7 7 8 0 0 3 4 5
// 0 0 2 3 4 5 5 7 7 8
各排序算法的Java实现及简单分析的更多相关文章
- 几种简单的排序算法(JAVA)
几种排序算法(JAVA) 一.代码 package com.hdwang; import java.util.Arrays; /** * Created by admin on 2017/1/20. ...
- 常见排序算法总结 -- java实现
常见排序算法总结 -- java实现 排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序. 线性时间 ...
- 十大经典排序算法(java实现、配图解,附源码)
前言: 本文章主要是讲解我个人在学习Java开发环境的排序算法时做的一些准备,以及个人的心得体会,汇集成本篇文章,作为自己对排序算法理解的总结与笔记. 内容主要是关于十大经典排序算法的简介.原理.动静 ...
- 常见排序算法(附java代码)
常见排序算法与java实现 一.选择排序(SelectSort) 基本原理:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录与第一个记录的位置进行交换:接着对不包括第一个记录以外的其他 ...
- 几大排序算法的Java实现
很多的面试题都问到了排序算法,中间的算法和思想比较重要,这边我选择了5种常用排序算法并用Java进行了实现.自己写一个模板已防以后面试用到.大家可以看过算法之后,自己去实现一下. 1.冒泡排序:大数向 ...
- 7种基本排序算法的Java实现
7种基本排序算法的Java实现 转自我的Github 以下为7种基本排序算法的Java实现,以及复杂度和稳定性的相关信息. 以下为代码片段,完整的代码见Sort.java 插入排序 /** * 直接插 ...
- 几大排序算法的Java实现(原创)
几大排序算法的Java实现 更新中... 注: 该类中附有随机生成[min, max)范围不重复整数的方法,如果各位看官对此方法有什么更好的建议,欢迎提出交流. 各个算法的思路都写在该类的注释中了,同 ...
- 常用排序算法的python实现和性能分析
常用排序算法的python实现和性能分析 一年一度的换工作高峰又到了,HR大概每天都塞几份简历过来,基本上一天安排两个面试的话,当天就只能加班干活了.趁着面试别人的机会,自己也把一些基础算法和一些面试 ...
- Java之OutOfMemoryError简单分析
Java之OutOfMemoryError简单分析 最近编码遇到了Java内存溢出的问题,所以就想顺便总结一下几种导致Java内存溢出的栗子,以及碰到Java内存溢出要如何去解决. Java堆溢出 J ...
随机推荐
- Ubuntu16.04双网卡配置,内网外网同时访问
Ubuntu16.04双网卡配置,内网外网同时访问 配置:vim/etc/network/interface auto lo iface lo inet loopback auto eno1 ifac ...
- selenium实现excel文件数据的读、写
在进行软件测试或设计自动化测试框架时,一个不可避免的过程就是: 参数 化,在利用 python 进行自动化测试开发时,通常会使用 excel 来做数据管 理,利用 xlrd.xlwt 开源包来读写 e ...
- bat调用exe文件并且传递参数
bat调用exe文件并且传递参数 bat调用exe,并且传递日期参数,代码: @echo off cd "E:\SublimeWorks\exe" start xyzj_shrjj ...
- 20145321 《Java程序设计》第8周学习总结
20145321 <Java程序设计>第8周学习总结 教材学习内容总结 第十五章 时间与日期 15.1 日志 1.使用日志的起点是Logger类,要取得Logger类,必须使用Logger ...
- 20145324 《Java程序设计》第1周学习总结
20145324 <Java程序设计>第1周学习总结 教材学习内容总结 1.Java是程序语言.标准规范.代表解决问题的平台 2.三大平台:Java SE(JVM.JRE.JDK与Java ...
- [OpenCV]OpenCV常用语法函数与坑点
目录 1. 加载图像(cv::imread) 2. 显示图像(cv::nameWindows与cv::imshow) 3. 修改图像(cv::cvtColor) 4. 保存图像(cv::imwrite ...
- Generator 函数的异步应用
异步编程对 JavaScript 语言太重要.Javascript 语言的执行环境是“单线程”的,如果没有异步编程,根本没法用,非卡死不可.本章主要介绍 Generator 函数如何完成异步操作. 传 ...
- SSH两种验证方式原理
本帖转自 http://www.cnblogs.com/hukey/p/6248468.html SSH验证方式有两种,分别为用户密码认证以及密钥认证. 1.用户密码认证方式 说明: (1) 当客户端 ...
- 【三小时学会Kubernetes!(二) 】Kubernetes 简介及Pod实践
Kubernetes 简介 我向你保证我没有夸大其词,读完本文你会问“为什么我们不称它为 Supernetes?” Kubernetes 是什么? 从容器启动微服务后,我们有一个问题,让我们通过如下问 ...
- 又是新动作!微信小程序专属二维码出炉
又到了晚上,微信又给我们带来了惊喜,并这次不是新的能力,而是把大家再熟悉不过的二维码换了新的造型. 正式揭晓:微信特制的小程序码.扫一扫新二维码 只要你的微信升级到了 6.5.7 版本,就可以扫码或者 ...