内蒙古java_java中的算法
插入排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass InsertSort implements SortUtil.Sort{/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
int temp;
for(int i=1;i
for(int j=i;(j>0)&&(data[j]
SortUtil.swap(data,j,j-1);
}
}
}
}
冒泡排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass BubbleSort implements SortUtil.Sort{/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
int temp;
for(int i=0;i
for(int j=data.length-1;j>i;j--){
if(data[j]
SortUtil.swap(data,j,j-1);
}
}
}
}
}
选择排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass SelectionSort implements SortUtil.Sort {/*
* (non-Javadoc)
*
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
int temp;
for (int i = 0; i < data.length; i++) {
int lowIndex = i;
for (int j = data.length - 1; j > i; j--) {
if (data[j] < data[lowIndex]) {
lowIndex = j;
}
}
SortUtil.swap(data,i,lowIndex);
}
}
}
Shell排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass ShellSort implements SortUtil.Sort{/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
for(int i=data.length/2;i>2;i/=2){
for(int j=0;j
insertSort(data,j,i);
}
}
insertSort(data,0,1);
}/**
* @param data
* @param j
* @param i
*/privatevoid insertSort(int[] data, int start, int inc) {
int temp;
for(int i=start+inc;i
for(int j=i;(j>=inc)&&(data[j]
SortUtil.swap(data,j,j-inc);
}
}
}
}
快速排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass QuickSort implements SortUtil.Sort{/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
quickSort(data,0,data.length-1);
}
privatevoid quickSort(int[] data,int i,int j){
int pivotIndex=(i+j)/2;//swapSortUtil.swap(data,pivotIndex,j);
int k=partition(data,i-1,j,data[j]);
SortUtil.swap(data,k,j);
if((k-i)>1) quickSort(data,i,k-1);
if((j-k)>1) quickSort(data,k+1,j);
}/**
* @param data
* @param i
* @param j
* @return
*/privateint partition(int[] data, int l, int r,int pivot) {
do{
while(data[++l]
while((r!=0)&&data[--r]>pivot);
SortUtil.swap(data,l,r);
}
while(l
SortUtil.swap(data,l,r);
return l;
}
}
改进后的快速排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass ImprovedQuickSort implements SortUtil.Sort {
privatestaticint MAX_STACK_SIZE=4096;
privatestaticint THRESHOLD=10;/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
int[] stack=newint[MAX_STACK_SIZE];
int top=-1;
int pivot;
int pivotIndex,l,r;
stack[++top]=0;
stack[++top]=data.length-1;
while(top>0){
int j=stack[top--];
int i=stack[top--];
pivotIndex=(i+j)/2;
pivot=data[pivotIndex];
SortUtil.swap(data,pivotIndex,j);//partitionl=i-1;
r=j;
do{
while(data[++l]
while((r!=0)&&(data[--r]>pivot));
SortUtil.swap(data,l,r);
}
while(l
SortUtil.swap(data,l,r);
SortUtil.swap(data,l,j);
if((l-i)>THRESHOLD){
stack[++top]=i;
stack[++top]=l-1;
}
if((j-l)>THRESHOLD){
stack[++top]=l+1;
stack[++top]=j;
}
}//new InsertSort().sort(data);insertSort(data);
}/**
* @param data
*/privatevoid insertSort(int[] data) {
int temp;
for(int i=1;i
for(int j=i;(j>0)&&(data[j]
SortUtil.swap(data,j,j-1);
}
}
}
}
归并排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass MergeSort implements SortUtil.Sort{/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
int[] temp=newint[data.length];
mergeSort(data,temp,0,data.length-1);
}
privatevoid mergeSort(int[] data,int[] temp,int l,int r){
int mid=(l+r)/2;
if(l==r) return ;
mergeSort(data,temp,l,mid);
mergeSort(data,temp,mid+1,r);
for(int i=l;i<=r;i++){
temp=data;
}
int i1=l;
int i2=mid+1;
for(int cur=l;cur<=r;cur++){
if(i1==mid+1)
data[cur]=temp[i2++];
elseif(i2>r)
data[cur]=temp[i1++];
elseif(temp[i1]
data[cur]=temp[i1++];
else
data[cur]=temp[i2++];
}
}
}
改进后的归并排序:
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass ImprovedMergeSort implements SortUtil.Sort {
privatestaticfinalint THRESHOLD = 10;/*
* (non-Javadoc)
*
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
int[] temp=newint[data.length];
mergeSort(data,temp,0,data.length-1);
}
privatevoid mergeSort(int[] data, int[] temp, int l, int r) {
int i, j, k;
int mid = (l + r) / 2;
if (l == r)
return;
if ((mid - l) >= THRESHOLD)
mergeSort(data, temp, l, mid);
else
insertSort(data, l, mid - l + 1);
if ((r - mid) > THRESHOLD)
mergeSort(data, temp, mid + 1, r);
else
insertSort(data, mid + 1, r - mid);
for (i = l; i <= mid; i++) {
temp = data;
}
for (j = 1; j <= r - mid; j++) {
temp[r - j + 1] = data[j + mid];
}
int a = temp[l];
int b = temp[r];
for (i = l, j = r, k = l; k <= r; k++) {
if (a < b) {
data[k] = temp[i++];
a = temp;
} else {
data[k] = temp[j--];
b = temp[j];
}
}
}/**
* @param data
* @param l
* @param i
*/privatevoid insertSort(int[] data, int start, int len) {
for(int i=start+1;i
for(int j=i;(j>start) && data[j]
SortUtil.swap(data,j,j-1);
}
}
}
}
堆排序：
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass HeapSort implements SortUtil.Sort{/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/publicvoid sort(int[] data) {
MaxHeap h=new MaxHeap();
h.init(data);
for(int i=0;i
h.remove();
System.arraycopy(h.queue,1,data,0,data.length);
}
privatestaticclass MaxHeap{
void init(int[] data){
this.queue=newint[data.length+1];
for(int i=0;i
queue[++size]=data;
fixUp(size);
}
}
privateint size=0;
privateint[] queue;
publicint get() {
return queue[1];
}
publicvoid remove() {
SortUtil.swap(queue,1,size--);
fixDown(1);
}//fixdownprivatevoid fixDown(int k) {
int j;
while ((j = k << 1) <= size) {
if (j < size && queue[j]
j++;
if (queue[k]>queue[j])//不用交换break;
SortUtil.swap(queue,j,k);
k = j;
}
}
privatevoid fixUp(int k) {
while (k > 1) {
int j = k >> 1;
if (queue[j]>queue[k])
break;
SortUtil.swap(queue,j,k);
k = j;
}
}
}
}
SortUtil：
package org.rut.util.algorithm;
import org.rut.util.algorithm.support.BubbleSort;
import org.rut.util.algorithm.support.HeapSort;
import org.rut.util.algorithm.support.ImprovedMergeSort;
import org.rut.util.algorithm.support.ImprovedQuickSort;
import org.rut.util.algorithm.support.InsertSort;
import org.rut.util.algorithm.support.MergeSort;
import org.rut.util.algorithm.support.QuickSort;
import org.rut.util.algorithm.support.SelectionSort;
import org.rut.util.algorithm.support.ShellSort;/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/publicclass SortUtil {
publicfinalstaticint INSERT = 1;
publicfinalstaticint BUBBLE = 2;
publicfinalstaticint SELECTION = 3;
publicfinalstaticint SHELL = 4;
publicfinalstaticint QUICK = 5;
publicfinalstaticint IMPROVED_QUICK = 6;
publicfinalstaticint MERGE = 7;
publicfinalstaticint IMPROVED_MERGE = 8;
publicfinalstaticint HEAP = 9;
publicstaticvoid sort(int[] data) {
sort(data, IMPROVED_QUICK);
}
privatestaticString[] name={"insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"};
privatestatic Sort[] impl=new Sort[]{
new InsertSort(),
new BubbleSort(),
new SelectionSort(),
new ShellSort(),
new QuickSort(),
new ImprovedQuickSort(),
new MergeSort(),
new ImprovedMergeSort(),
new HeapSort()
};
publicstaticString toString(int algorithm){
return name[algorithm-1];
}
publicstaticvoid sort(int[] data, int algorithm) {
impl[algorithm-1].sort(data);
}
publicstaticinterface Sort {
publicvoid sort(int[] data);
}
publicstaticvoid swap(int[] data, int i, int j) {
int temp = data;
data = data[j];
data[j] = temp;
}
}
内蒙古java_java中的算法相关推荐
- 手写实现李航《统计学习方法》书中全部算法
点击上方"AI遇见机器学习",选择"星标"公众号 重磅干货,第一时间送达 来源:专知 [导读]Dod-o的手写实现李航<统计学习方法>书中全部算法, ...
- 计算机算法对程序设计的作用,计算机编程中数学算法的优化策略
李钰 摘要:在计算机编程中,合理地运用数学算法所拥有的优势不但可以完好地针对所拥有的问题进行总结分类归纳,还可以将其归纳作为基础从而进行针对性的统一计算,并且能够将非常复杂的问题进行整体的简化并且将其 ...
- 数据挖掘中分类算法小结
数据挖掘中分类算法小结 数据仓库,数据库或者其它信息库中隐藏着许多可以为商业.科研等活动的决策提供所需要的知识.分类与预测是两种数据分析形式,它们可以用来抽取能够描述重要数据集合或预测未来数据趋势 ...
- 浅谈网络爬虫中广度优先算法和代码实现
前几天给大家分享了网络爬虫中深度优先算法的介绍及其代码实现过程,没来得及上车的小伙伴们可以戳这篇文章--浅谈网络爬虫中深度优先算法和简单代码实现.今天小编给大家分享网络爬虫中广度优先算法的介绍及其代码 ...
- JAVA中希尔排序去的讲解_java 中基本算法之希尔排序的实例详解
java 中基本算法之希尔排序的实例详解 希尔排序(Shell Sort)是插入排序的一种.也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本.希尔排序是非稳定排序算法.该方法因DL．Shel ...
- 推荐系统中常用算法 以及优点缺点对比
推荐系统中常用算法 以及优点缺点对比 2014/09/20 [Martin导读]随着互联网特别是社会化网络的快速发展,我们正处于信息过载的时代.用户面对过量的信息很难找到自己真正感兴趣的内容,而内容提 ...
- 程序员如何快速准备面试中的算法 - 结构之法
准备面试.学习算法,特别推荐最新出版的我的新书<编程之法:面试和算法心得>,已经上架京东等各大网店 前言 我决定写篇短文,即为此文.之所以要写这篇文章,缘于微博上常有朋友询问,要毕业找工作 ...
- 【StatLearn】统计学习中knn算法实验（2）
接着统计学习中knn算法实验(1)的内容 Problem: Explore the data before classification using summary statistics orvisu ...
- JavaScript 面试中常见算法问题详解
JavaScript 面试中常见算法问题详解,翻译自 https://github.com/kennymkchan/interview-questions-in-javascript.下文提到的很多问 ...
最新文章
- php显示评委打分情况代码,评委打分表自动汇总计算得分
- TortoiseGit不同分支合并代码
- eclipse工程导入Android Studio
- mysql ndb还原数据库_ndb_restore恢复出错
- 56 - II. 数组中数字出现的次数 II
- Spring Cloud脚手架源码
- 做柱状图加数据标签_Origin绘图：如何优雅的绘制堆叠柱状图
- 分享一个在线的HTML5元素在线测验 : HTML5 Element Quiz
- K8S 通过 yaml 文件创建资源
- 【书法字识别】基于matlab余弦形状相似度书法字识别【含Matlab源码 1356期】
- SPSS时序全局主成分分析方法
- 用 Bootstrap 进行参数估计
- 气体流量与质量流率换算
- 有哪些APP小众却实用，让你相见恨晚
- Zero-Shot Deep Domain Adaptation[reading notes]
- 有感，一些与自己同龄的文字
- ZBrush教程（一）：常用笔刷安装及运用
- 设立分公司，还是子公司更省税
- js正则匹配以{开头,以}结尾怎么写？
- Ae 效果详解：湍流置换