java排序算法(二)

二、改进排序算法

2.1希尔排序

定义:希尔排序(ShellSort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

常用的h序列(增量)由Knuth提出,该序列从1开始,通过如下公式产生:h = 3 * h +1

反过来程序需要反向计算h序列,应该使用h=(h-1)/3

2.2快速排序

定义:快速排序(Quicksort)是对冒泡排序的一种改进,是一种非稳定排序。

快速排序通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列

2.3归并排序

定义:归并排序(MergeSort)是建立在归并操作上的一种有效的排序算法,该算法是分治法的典型应用。是稳定排序。

归并排序假设初始序列(数据)有n个记录,看作n个子序列,每个子序列长度为一,然后进行两两归并,得到n/2个长度为2的子序列;让后再两两归并,...,重复操作,最后得到一个长度为n的有序序列,这种方法称为2路归并排序。

代码如下

 public class Sort
{
//实现从小到大排序
public static void main(String[] args)
{
int[] arr1 = {9,1,5,8,3,7,4,6,2};
//quickSort(arr1,0,8);
mergeSort(arr1);
//shellSort(arr1);
for(int i=0;i<arr1.length;i++)
{
System.out.println(arr1[i]);
}
}
/*---------------------------------希尔排序---------------------------------------------
*希尔排序(缩小增量排序),对直接插入排序的改进
*通过加大插入排序中元素之间的间隔,并在这些有间隔的元素中进行插入排序,从而使数据项大框度的移动
*当这些数据项排过一趟序之后,希尔排序算法见效数据项的间隔再进行排序,依次进行下去
*哦爱心时的数据项之间的间隔被称为增量,习惯上用h表示
*常用h序列由Knuth剔除,序列从1开始,通过公式产生h=3*h+1;
*反过来程序反向计算h=(h-1)/3
---------------------------------------------------------------------------------------*/
public static void shellSort(int[] data)
{
int h=1;
while(h<=data.length/3)
{
h=h*3+1;
}
while(h>0)
{
for (int i = h; i < data.length; i += h)
{
if (data[i] < data[i - h])
{
int tmp = data[i];
int j = i - h;
while (j >= 0 && data[j] > tmp)
{
data[j + h] = data[j];
j -= h;
}
data[j + h] = tmp;
//print(data);
}
}
// 计算出下一个h值(增量)
h = (h - 1) / 3;
}
}
/*---------------------------------快速排序---------------------------------------------
-----------------------------------------------------------------------------------*/
public static void quickSort(int[] arr,int low,int high)
{
if(low<high)
{
int mid = getMid(arr,low,high);
quickSort(arr,0,mid-1); //递归排序
quickSort(arr,mid+1,high);
}
}
//取中值
public static int getMid(int[] arr,int low,int high)
{
int key = arr[low]; //基准元素
while(low<high)
{
while(low<high&&arr[high]>=key) //从high开始找比基准小的元素,如果找到,则互换位置
{
high--;
}
arr[low] = arr[high];
while(high>low&&arr[low]<=key) //从low开始找比基准大的,放到之前high空出的位置上
{
low++;
}
arr[high]=arr[low];
}
arr[low]=key; //此时low=high是基准元素的位置,也是空出来的那个位置
return low;
} /*--------------------------------归并排序------------------------------------
-------------------------------------------------------------------------------*/
public static void mergeSort(int[] data)
{
sort(data,0,data.length-1);
}
public static void sort(int[] data,int left,int right)
{
if(left>=right)
{
return;
}
int center = (left + right) / 2; // 找出中间索引
sort(data, left, center); // 对左边数组进行递归
sort(data, center + 1, right); // 对右边数组进行递归
merge(data, left, center, right); // 合并
}
/**
* 将两个数组进行归并,归并前面2个数组已有序,归并后依然有序
*
* @param data 数组对象
* @param left 左数组的第一个元素的索引
* @param center 左数组的最后一个元素的索引,center+1是右数组第一个元素的索引
* @param right 右数组最后一个元素的索引
*/
public static void merge(int[] data, int left, int center, int right) {
// 临时数组
int[] tmpArr = new int[data.length];
// 右数组第一个元素索引
int mid = center + 1;
// third 记录临时数组的索引
int third = left;
// 缓存左数组第一个元素的索引
int tmp = left;
while (left <= center && mid <= right) {
// 从两个数组中取出最小的放入临时数组
if (data[left] <= data[mid]) {
tmpArr[third++] = data[left++];
} else {
tmpArr[third++] = data[mid++];
}
}
// 剩余部分依次放入临时数组(实际上两个while只会执行其中一个)
while (mid <= right) {
tmpArr[third++] = data[mid++];
}
while (left <= center) {
tmpArr[third++] = data[left++];
}
// 将临时数组中的内容拷贝回原数组中
// (原left-right范围的内容被复制回原数组)
while (tmp <= right) {
data[tmp] = tmpArr[tmp++];
}
}
}

Java排序算法(二)的更多相关文章

  1. Java排序算法(二):简单选择排序

    [基本思想] 在要排序的一组数中.选出最小的一个数与第一个位置的数交换:然后在剩下的数中再找出最小的与第二个位置的数交换,如此循环至倒数第二个数和最后一个数比較为止. 算法关键:找到最小的那个数.并用 ...

  2. java排序算法(二):直接选择排序

    java排序算法(二) 直接选择排序 直接选择排序排序的基本操作就是每一趟从待排序的数据元素中选出最小的(或最大的)一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完,它需要经过n- ...

  3. java排序算法(一):概述

    java排序算法(一)概述 排序是程序开发中一种非常常见的操作,对一组任意的数据元素(活记录)经过排序操作后,就可以把它们变成一组按关键字排序的一组有序序列 对一个排序的算法来说,一般从下面三个方面来 ...

  4. Java排序算法之快速排序

    Java排序算法之快速排序 快速排序(Quicksort)是对冒泡排序的一种改进. 快速排序由C. A. R. Hoare在1962年提出.它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分 ...

  5. java排序算法之冒泡排序和快速排序

    总结一下Java排序算法,以便记忆. 各类排序的时间复杂度: 排序方法 时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性 复杂性 直接插入排序 O(n2)O(n2) O( ...

  6. Java排序算法(四)希尔排序2

    Java排序算法(四)希尔排序2 希尔排序移步法:分组+直接插入排序组合 一.测试类SortTest import java.util.Arrays; public class SortTest { ...

  7. 常用Java排序算法

    常用Java排序算法 冒泡排序 .选择排序.快速排序 package com.javaee.corejava; public class DataSort { public DataSort() { ...

  8. Java排序算法之直接选择排序

    Java排序算法之直接选择排序 基本过程:假设一序列为R[0]~R[n-1],第一次用R[0]和R[1]~R[n-1]相比较,若小于R[0],则交换至R[0]位置上.第二次从R[1]~R[n-1]中选 ...

  9. java排序算法(十):桶式排序

    java排序算法(十):桶式排序 桶式排序不再是一种基于比较的排序方法,它是一种比较巧妙的排序方式,但这种排序方式需要待排序的序列满足以下两个特征: 待排序列所有的值处于一个可枚举的范围之类: 待排序 ...

随机推荐

  1. for循环及break和continue的区别

    1.For循环 格式: for( 初始语句 ; 执行条件 ; 增量 ){ 循环体 } 执行顺序:1.初始语句  2.执行条件是否符合 3.循环体  4.增加增量 初始化语句只在循环开始前执行一次,每次 ...

  2. delphi 线程教学第一节:初识多线程

    第一节:初识多线程   1.为什么要学习多线程编程?   多线程(多个线程同时运行)编程,亦可称之为异步编程. 有了多线程,主界面才不会因为耗时代码而造成“假死“状态. 有了多线程,才能使多个任务同时 ...

  3. js中的函数易忽略的点小节

    1.Function()属性和方法 属性: prototype 2.Function对象实例属性和方法 实例属性:(例如var Function=function(x,y,z){}; myFuncti ...

  4. 0008_Python变量

    1.变量名:数字,字母,下划线组成,不能以数字开头,不能是Python内部关键字. 2.变量类型:数字,字符串,布尔值(首字母大写) 3.内存与变量: 4. =    赋值 ==   比较 is == ...

  5. RN控件之DrawerLayoutAndroid导航栏

    /** * Sample React Native App * https://github.com/facebook/react-native */ 'use strict'; import Rea ...

  6. R: 缺失值 & 查看变量类型

    ################################################### 问题:缺失值   18.5.2 有关处理缺失值的各种方法有什么?各自的适用场景. 解决方案: n ...

  7. p2279&bzoj1217 消防局的设立

    传送门(洛谷) 传送门(bzoj) 题目 2020年,人类在火星上建立了一个庞大的基地群,总共有n个基地.起初为了节约材料,人类只修建了n-1条道路来 连接这些基地,并且每两个基地都能够通过道路到达, ...

  8. storm定时器timer源码分析-timer.clj

    storm定时器与java.util.Timer定时器比较相似.java.util.Timer定时器实际上是个线程,定时调度所拥有的TimerTasks:storm定时器也有一个线程负责调度所拥有的& ...

  9. 2.HTTP头注入

    重新认识被人遗忘的HTTP头注入 前言 注入类漏洞经久不衰,多年保持在owasp Top 10的首位.今天就聊聊那些被人遗忘的http头注入.用简单的实际代码进行演示,让每个人更深刻的去认识该漏洞. ...

  10. 《鸟哥的Linux私房菜》读书笔记2

    1. 压缩后缀与压缩程序: *.Z compress 程序压缩的档案; *.bz2 bzip2 程序压缩的档案; *.gz gzip 程序压缩的档案; *.tar tar 程序打包的数据,并没有压缩过 ...