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. 7z命令行 极限压缩指令

    摘抄自http://www.cnblogs.com/qanholas/archive/2011/10/03/2198487.html 7za a -t7z bag.7z "/home/fil ...

  2. showfm练习小项目总结

    Showfm 项目总结: 有一个主页面, 有一个service,启动和结束一般在主页面里面完成. OnCreate启动service OnDestroy关闭service EventBus 信息传递 ...

  3. js中+号的另外一种用法

    JavaScript中可以在某个元素前使用 ‘+’ 号,这个操作是将该元素转换成Number类型,如果转换失败,那么将得到 NaN. 所以 +new Date 将会调用 Date.prototype ...

  4. http content-type accept的区别

    1.Accept属于请求头, Content-Type属于实体头. Http报头分为通用报头,请求报头,响应报头和实体报头. 请求方的http报头结构:通用报头|请求报头|实体报头 响应方的http报 ...

  5. TCP/IP(七)之玩转HTTP协议

    前言 前面一篇的博文简单的介绍了一下属于应用层的HTTP协议,这一篇我将详细的学习HTTP协议,这也是做Web开发中一定要用到的协议.虽然我是做大数据的,但是多学习一点肯定是 没有坏处的.国庆放假7天 ...

  6. ThreadLocal的理解与应用场景分析

    对于Java ThreadLocal的理解与应用场景分析 一.对ThreadLocal理解 ThreadLocal提供一个方便的方式,可以根据不同的线程存放一些不同的特征属性,可以方便的在线程中进行存 ...

  7. hdu4686 Arc of Dream 2013 Multi-University Training Contest 9矩阵快速幂

    Arc of Dream Time Limit: 2000/2000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Tot ...

  8. bzoj1027 [HNOI2004]打鼹鼠

    [HNOI2004]打鼹鼠 2014年5月2日2,8605 Description 鼹鼠是一种很喜欢挖洞的动物,但每过一定的时间,它还是喜欢把头探出到地面上来透透气的.根据这个特点阿Q编写了一个打鼹鼠 ...

  9. SQLServer中重建聚集索引之后会影响到非聚集索引的索引碎片吗

    本文出处:http://www.cnblogs.com/wy123/p/7650215.html (保留出处并非什么原创作品权利,本人拙作还远远达不到,仅仅是为了链接到原文,因为后续对可能存在的一些错 ...

  10. 【转】Python装饰器与面向切面编程

    原文请参考: http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html 今天来讨论一下装饰器.装饰器是一个很著名的设计模式,经常被用于有切 ...