1、冒泡排序

package lizicong;

import java.util.Scanner;

public class BubbleSort {
/*
* 属于交换排序;稳定
* 排序原理:相邻的两个元素依次比较,相互交换
* 时间复杂度:最好o(n),最差o(n^2),平均o(n^2)
* 辅助空间:o(1)
*
*/
public void bubbleSort(int[] a){
int n = a.length;
for(int i = 0; i < n; i++){
for(int j = 0; j < n-i-1; j++){
if(a[j] > a[j+1]){
int tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
}
public void print(int[] a){
for( int i = 0; i < a.length; i++){
System.out.print(a[i] + " ");
}
} public static void main(String[] args){
Scanner in = new Scanner(System.in);
BubbleSort b = new BubbleSort();
int[] a = new int[5];
while(in.hasNextInt()){
for( int i = 0; i < a.length; i++){
a[i] = in.nextInt();
}
b.bubbleSort(a);
b.print(a);
}
}
}

2、插入排序

package lizicong;

import java.util.Scanner;

public class InsertSort {
/*属于插入排序类,稳定
* 插入排序思想:假设前面的元素是排好序的,找到一个元素,依次与前面的元素相比较直到找到一个比它小的数为止,
* 保存当前元素,然后元素依次后移,然后插入这个元素.
* 时间复杂度:最坏o(n^2),最好O(n)已排好序,平均O(n^2)
* 辅助空间:o(1)
* */
public static void sort(int[] arr){
int i,j;
int tmp;
int len = arr.length;
for(i = 1; i < len; i++){
j = i;
tmp = arr[i];
while(j > 0 && arr[j-1] > tmp ){
arr[j] = arr[j-1];
j--;
}
arr[j] = tmp;
}
} public static void resvert_sort(int[] arr){
int i,j;
int tmp;
int len = arr.length;
for(i = 1; i < len; i++){
j = i;
tmp = arr[i];
while(j > 0 && arr[j-1] < tmp){
arr[j] = arr[j-1];
j--;
}
arr[j] = tmp;
} }
public static void main(String[] args){
//int[] arr = {23,43,3,12,13,124,2344,231,12,1};
Scanner in = new Scanner(System.in);
in.useDelimiter(" |,");
int[] arr;
while(in.hasNextInt()){
arr = new int[6];
for(int i = 0; i < 6; i++){
arr[i] = in.nextInt();
}
sort(arr);
for(int i = 0; i < 6; i++){
System.out.printf("%d,",arr[i]);
}
System.out.println();
resvert_sort(arr);
for(int i = 0; i < 6; i++){
System.out.printf("%d,",arr[i]);
}
} System.out.println("223"); }
}

3、希尔排序

package lizicong;

import java.util.Scanner;

public class ShellSort {

	/*属于插入排序,不稳定
* 排序原理:将数组按指定的增量dk分成几小段,然后分别对这几小段进行排序,重复该步奏直到增量为1的时候再进行最后一次直接插入排序。
* 时间复杂度,没有一个公认的定论,估测:最好O(n^1.3),最坏o(n^2),平均o(nlogn)~O(n^2)
* 辅助空间o(1)
*
* */
private void shellInsertSort(int[] arr, int dk){
for(int i = dk; i < arr.length; i++){
if(arr[i] < arr[i-dk]){
int j;
int tmp = arr[i];
for( j = i-dk; j >= 0 && tmp < arr[j]; j-=dk ){
arr[j+dk] = arr[j];
}
arr[j+dk] = tmp;
}
}
} private void shellSort(int[] arr){
int dk = arr.length/2;
while(dk >= 1){
shellInsertSort(arr, dk);
dk /=2;
}
} public void print(int[] arr){
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
}
public static void main(String[] args){
ShellSort shell = new ShellSort();
Scanner in = new Scanner(System.in);
int[] a = new int[5];
while(in.hasNextInt()){
for(int i = 0; i < a.length; i++){
a[i] = in.nextInt();
}
shell.shellSort(a);
shell.print(a);
}
}
}

4、简单选择排序

package lizicong;

import java.util.Scanner;

public class SimpleSelectSort {
/*属于选择排序,稳定
* 排序原理:从第一个元素开始,一次与后面的元素比较,找出最小值,然后与开始的元素交换
* 时间复杂度:最好o(n^2),最坏:o(n^2),平均o(n^2)
* 辅助空间复杂度o(1)
*
* */
public void selectSort(int[] a){
for(int i = 0; i < a.length; i++){
int k = i;
for(int j = i+1; j < a.length; j++){
if(a[k] > a[j]){
k = j;
}
}
swap(a, i, k);
}
} private void swap(int[] a,int i, int j){
if(i == j){
return;
}
a[i] = a[i] + a[j];
a[j] = a[i] - a[j];
a[i] = a[i] - a[j];
} public void print(int[] a){
for(int i = 0; i < a.length; i++){
System.out.print(a[i] + " ");
}
} public static void main(String[] args){
Scanner in = new Scanner(System.in);
SimpleSelectSort s = new SimpleSelectSort();
int[] a = new int[5]; while(in.hasNextInt()){
for(int i = 0; i < a.length; i++){
a[i] = in.nextInt();
}
s.selectSort(a);
s.print(a);
}
}
}

5、快速排序

package lizicong;

import java.util.Scanner;

public class QuickSort {
/*属于交换排序,不稳定
* 排序算法:选一个元素,将小于该元素的放在该元素左边,大于该元素的放在该元素右边,递归
* 时间复杂度:最好o(nlog2n),最坏o(n2),平均o(nlog2n)
* 空间复杂度o(nlog2n)
*
* */ public static int getMiddle(int[] numbers, int low, int high){
int temp = numbers[low];
while(low < high){
while(low < high && numbers[high] > temp){
high--;
}
numbers[low] = numbers[high];
while(low < high && numbers[low] < temp){
low++;
}
numbers[high] = numbers[low];
}
numbers[low] = temp;
return low;
} public static void quickSort(int[] numbers, int low, int high){
if(low < high){
int middle = getMiddle(numbers, low, high);
quickSort(numbers, low, middle - 1);
quickSort(numbers, middle + 1, high);
}
}
public static void print(int[] a){
for( int i = 0; i < a.length; i++){
System.out.print(a[i] + " ");
}
}
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int[] a = new int[5];
while(in.hasNextInt()){
for(int i = 0; i < a.length; i++){
a[i] = in.nextInt();
}
quickSort(a, 0, a.length - 1);
print(a);
} }
}

6、归并排序

package lizicong;

import java.util.Scanner;

public class MergeSort {
/*
* 属于归并排序,稳定
* 算法:将两个(或两个以上)有序表合并成一个新的有序表 即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列
* 时间复杂度:都是o(nlog2n)
* 辅助空间:o(1);
* */
public static void sort(int[] nums, int low, int high){
int mid = (low + high) / 2;
if(low < high){
sort(nums, low, mid);
sort(nums, mid + 1, high);
merge(nums, low, mid, high);
} }
public static void merge(int[] nums, int low, int mid, int high){
int[] temp = new int[high - low + 1];
int i = low;
int j = mid + 1;
int k = 0; while(i <= mid && j <= high){
if(nums[i] < nums[j]){
temp[k++] = nums[i++];
}else{
temp[k++] = nums[j++];
}
}
while(i <= mid){
temp[k++] = nums[i++];
}
while(j <= high){
temp[k++] = nums[j++];
}
for(int k2 = 0; k2 < temp.length; k2++){
nums[k2 + low] = temp[k2];
}
}
public static void print(int[] a){
for( int i = 0; i < a.length; i++){
System.out.print(a[i] + " ");
}
} public static void main(String[] args){
Scanner in = new Scanner(System.in);
int[] a= new int[5];
while(in.hasNextInt()){
for(int i = 0; i < a.length; i++){
a[i] = in.nextInt();
}
sort(a, 0, a.length - 1);
print(a);
}
}
}

7、堆排序

package lizicong;

import java.util.Arrays;
import java.util.Scanner; public class HeapSort {
/* 属于选择排序,不稳定
* 算法::初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个 堆,这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆
* 时间复杂度: 都是o(nlog2n)
* 辅助空间:o(1)
* */
public static void sort(int[] a){
int len = a.length;
for(int i = 0; i < len; i++){
bulidMaxHeap(a, len-1-i);
swap(a, 0, len-1-i);
}
System.out.println(Arrays.toString(a));
}
public static void bulidMaxHeap(int[] data, int lastIndex){
for(int i = (lastIndex - 1)/2; i >= 0; i--){
int k = i;
while(k*2 + 1 <= lastIndex){
//如果当前k节点的子节点存在
int biggerIndex = 2 * k + 1;
//如果biggerIndex小于lastIndex,即biggerIndex+1代表的k节点的右子节点存在
if(biggerIndex < lastIndex){
if(data[biggerIndex] < data[biggerIndex + 1]){
//biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
//如果k节点的值小于其较大的子节点的值 ,交换他们
if(data[k] < data[biggerIndex]){
swap(data, k, biggerIndex);
k = biggerIndex;
}else{
break;
}
}
}
}
private static void swap(int[] data, int i, int j) {
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int[] a= new int[5];
while(in.hasNextInt()){
for(int i = 0; i < a.length; i++){
a[i] = in.nextInt();
}
sort(a);
}
}
}





java7大排序算法的更多相关文章

  1. Java常用排序算法+程序员必须掌握的8大排序算法+二分法查找法

    Java 常用排序算法/程序员必须掌握的 8大排序算法 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排 ...

  2. Java 常用排序算法/程序员必须掌握的 8大排序算法

    Java 常用排序算法/程序员必须掌握的 8大排序算法 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配 ...

  3. Algorithm --> 十大排序算法

    十大排序算法 主要排序法有:  一.冒泡( Bubble)排序—— 相邻交换  二.选择排序 ——每次最小/ 大排在相应的位置  三.插入排序 ——将下一个插入已排好的序列中  四.壳( Shell) ...

  4. [ 转载 ] js十大排序算法:冒泡排序

    js十大排序算法:冒泡排序  http://www.cnblogs.com/beli/p/6297741.html

  5. 九大排序算法Java实现

    之前学习数据结构与算法时花了三天时间整理九大排序算法,并采用Java语言来实现,今天第一次写博客,刚好可以把这些东西从总结的文档中拿出来与大家分享一下,同时作为自己以后的备忘录. 1.排序算法时间复杂 ...

  6. 十大排序算法JavaScript实现总结

    花费了几周的时间断断续续的练习和模仿与使用JavaScript代码实现了十大排序算法. 里面有每种算法的动图和静态图片演示,看到图片可以自己先按照图片的思路实现一下. github中正文链接,点击查看 ...

  7. 十大排序算法总结(Python3实现)

    十大排序算法总结(Python3实现) 本文链接:https://blog.csdn.net/aiya_aiya_/article/details/79846380 目录 一.概述 二.算法简介及代码 ...

  8. 一篇夯实一个知识点系列--python实现十大排序算法

    写在前面 排序是查找是算法中最重要的两个概念,我们大多数情况下都在进行查找和排序.科学家们穷尽努力,想使得排序和查找能够更加快速.本篇文章用Python实现十大排序算法. 干货儿 排序算法从不同维度可 ...

  9. C语言实现九大排序算法

    C语言实现九大排序算法 直接插入排序 折半插入排序 希尔排序 冒泡排序 快速排序 直接选择排序 堆排序 归并排序 基数排序 C语言实现九大排序算法 直接插入排序 将数组分为两个部分,一个是有序部分,一 ...

随机推荐

  1. SQL三类语句

    1. DDL (Data Definition Language, 数据定义语言) CREATE: 创建数据库和表等对象 DROP: 删除数据库和表等对象 ALTER: 修改数据库和表等对象的结构 2 ...

  2. JVM菜鸟进阶高手之路六(JVM每隔一小时执行一次Full GC)

    转载请注明原创出处,谢谢! 上次分析详细地址在:http://www.jianshu.com/p/a6236cd39e2d 以为上次问题是rmi的问题就此结束了,但是问题并没有结束,其实本次问题不是r ...

  3. EntityFramework 6.x多个上下文迁移实现分布式事务

    前言 自从项目上了.NET Core平台用上了EntityFramework Core就再没碰过EntityFramework 6.x版本,目前而言EntityFramework 6.x是用的最多,无 ...

  4. 一个基于Asp.net MVC的博客类网站开源了!

    背景说明: 大学时毕业设计作品,一直闲置在硬盘了,倒想着不如开源出来,也许会对一些人有帮助呢,而且个人觉得这个网站做得还是不错了,毕竟是花了不少心思,希望对你有所帮助. github地址:https: ...

  5. js中判断对象数据类型的方法

    对js中不同数据的布尔值类型总结:false:空字符串:null:undefined:0:NaN.true:除了上面的false的情况其他都为true: 如下: var o = { 'name':'l ...

  6. 【JVM命令系列】jmap

    命令基本概述 Jmap是一个可以输出所有内存中对象的工具,甚至可以将VM 中的heap,以二进制输出成文本.打印出某个java进程(使用pid)内存内的,所有'对象'的情况(如:产生那些对象,及其数量 ...

  7. Ubuntu 普通用户提升到root权限

    方法一.修改passwd文件 1.编辑passwd文件 sudo vim /etc/passwd 2.找到你想提权的用户(比如test),将用户名后面的数字改成0 找到用户test test:x::: ...

  8. PHP中 HTTP_HOST 和 SERVER_NAME 的区别

    最近在开发站群软件,用到了根据访问域名判断子站点的相关问题.PHP获取当前域名有两个变量 HTTP_HOST 和 SERVER_NAME,我想知道两者的区别以及哪个更加可靠. 首先我想说,百度上那些转 ...

  9. libsvn_subr-1.so.0: undefined symbol: apr_atomic_xchgptr 故障解决

    源码编译安装完成之后,查看svn的安装版本会报以下错误 svn: symbol lookup error: /usr/local/subversion/lib/libsvn_subr-.so.: un ...

  10. 监控利器 sysdig - 每天5分钟玩转 Docker 容器技术(79)

    sysdig 是一个轻量级的系统监控工具,同时它还原生支持容器.通过 sysdig 我们可以近距离观察 linux 操作系统和容器的行为. Linux 上有很多常用的监控工具,比如 strace,tc ...