一,直接插入排序

    //直接插入排序的算法时间复杂度分析:
//如果输入为正序,则每次比较一次就可以找到元素最终位置,复杂度为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实现及简单分析的更多相关文章

  1. 几种简单的排序算法(JAVA)

    几种排序算法(JAVA) 一.代码 package com.hdwang; import java.util.Arrays; /** * Created by admin on 2017/1/20. ...

  2. 常见排序算法总结 -- java实现

    常见排序算法总结 -- java实现 排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序. 线性时间 ...

  3. 十大经典排序算法(java实现、配图解,附源码)

    前言: 本文章主要是讲解我个人在学习Java开发环境的排序算法时做的一些准备,以及个人的心得体会,汇集成本篇文章,作为自己对排序算法理解的总结与笔记. 内容主要是关于十大经典排序算法的简介.原理.动静 ...

  4. 常见排序算法(附java代码)

    常见排序算法与java实现 一.选择排序(SelectSort) 基本原理:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录与第一个记录的位置进行交换:接着对不包括第一个记录以外的其他 ...

  5. 几大排序算法的Java实现

    很多的面试题都问到了排序算法,中间的算法和思想比较重要,这边我选择了5种常用排序算法并用Java进行了实现.自己写一个模板已防以后面试用到.大家可以看过算法之后,自己去实现一下. 1.冒泡排序:大数向 ...

  6. 7种基本排序算法的Java实现

    7种基本排序算法的Java实现 转自我的Github 以下为7种基本排序算法的Java实现,以及复杂度和稳定性的相关信息. 以下为代码片段,完整的代码见Sort.java 插入排序 /** * 直接插 ...

  7. 几大排序算法的Java实现(原创)

    几大排序算法的Java实现 更新中... 注: 该类中附有随机生成[min, max)范围不重复整数的方法,如果各位看官对此方法有什么更好的建议,欢迎提出交流. 各个算法的思路都写在该类的注释中了,同 ...

  8. 常用排序算法的python实现和性能分析

    常用排序算法的python实现和性能分析 一年一度的换工作高峰又到了,HR大概每天都塞几份简历过来,基本上一天安排两个面试的话,当天就只能加班干活了.趁着面试别人的机会,自己也把一些基础算法和一些面试 ...

  9. Java之OutOfMemoryError简单分析

    Java之OutOfMemoryError简单分析 最近编码遇到了Java内存溢出的问题,所以就想顺便总结一下几种导致Java内存溢出的栗子,以及碰到Java内存溢出要如何去解决. Java堆溢出 J ...

随机推荐

  1. spark[源码]-sparkContext详解[一]

    spark简述 sparkContext在Spark应用程序的执行过程中起着主导作用,它负责与程序和spark集群进行交互,包括申请集群资源.创建RDD.accumulators及广播变量等.spar ...

  2. UI自动化测试框架之Selenium关键字驱动 (转)

    摘要 自动化测试框架demo,用关键字的形式将测试逻辑封装在数据文件中,测试工具解释这些关键字即可对其应用自动化 一.原理及特点 1.   关键字驱动测试是数据驱动测试的一种改进类型 2.    主要 ...

  3. windows AD域安装及必要设置

    一.安装AD域 运行dcpromo命令,安装AD域. 步骤: 1.win+R 2.dcpromo 图例: 百度百科关于“dcpromo”解释: dcpromo命令是一个“开关”命令.如果Windows ...

  4. bat调用exe文件并且传递参数

    bat调用exe文件并且传递参数 bat调用exe,并且传递日期参数,代码: @echo off cd "E:\SublimeWorks\exe" start xyzj_shrjj ...

  5. 20145215《Java程序设计》第二周学习总结

    教材内容总结 类型.变量与运算符 *基本类型 整数(short.int.long) 字节(byte) 浮点数(float/double) 字符(char)将一个数字字母或者符号用单引号标识,字符串用双 ...

  6. 20145314郑凯杰《信息安全系统设计基础》第6周学习总结 part A

    第4章 处理器体系结构 part 1 本部分对改章节的知识点进行总结: 一个处理器支持的指令和指令的字节级编码称为它的指令集体系结构(ISA). 不同的出路器有不同的ISA. ISA模型看上去应该是顺 ...

  7. iOS日常学习 - 每个Xcode开发者应该知道的七个使用技巧

    本文为转载学习使用原文链接 工欲善其事,必先利其器.对一个iOS开发者来说,这就意味着对Xcode的熟练掌握程度.Xcode是一个学习起来有点难度的软件,下面的这些技巧或许可以显著的提高你的编程效率. ...

  8. CommonLang3 --StringUtils使用指南

    转载自(http://blog.csdn.net/xuxiaoxie/article/details/52095930)public static boolean isEmpty(CharSequen ...

  9. hdu5727

    Necklace SJX has 2*N magic gems. N of them have Yin energy inside while others have Yang energy. SJX ...

  10. Covariance and Contravariance (C#)

    Covariance and Contravariance (C#) https://docs.microsoft.com/en-us/dotnet/articles/csharp/programmi ...