爱学记
Java排序算法 java的各种排序算法
java的各种排序算法
Java代码
插入排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class InsertSort implements SortUtil Sort{
/* (non Javadoc)
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
int temp;
for(int i= ;i<data length;i++){
for(int j=i;(j> )&&(data[j]<data[j ]);j ){
SortUtil swap(data j j );
}
}
}
}
冒泡排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class BubbleSort implements SortUtil Sort{
/* (non Javadoc)
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
int temp;
for(int i= ;i<data length;i++){
for(int j=data length ;j>i;j ){
if(data[j]<data[j ]){
SortUtil swap(data j j );
}
}
}
}
}
选择排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class SelectionSort implements SortUtil Sort {
/*
* (non Javadoc)
*
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
int temp;
for (int i = ; i < data length; i++) {
int lowIndex = i;
for (int j = data length ; j > i; j ) {
if (data[j] < data[lowIndex]) {
lowIndex = j;
}
}
SortUtil swap(data i lowIndex);
}
}
}
Shell排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class ShellSort implements SortUtil Sort{
/* (non Javadoc)
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
for(int i=data length/ ;i> ;i/= ){
for(int j= ;j<i;j++){
insertSort(data j i);
}
}
insertSort(data );
}
/**
* @param data
* @param j
* @param i
*/
private void insertSort(int[] data int start int inc) {
int temp;
for(int i=start+inc;i<data length;i+=inc){
for(int j=i;(j>=inc)&&(data[j]<data[j inc]);j =inc){
SortUtil swap(data j j inc);
}
}
}
}
快速排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class QuickSort implements SortUtil Sort{
/* (non Javadoc)
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
quickSort(data data length );
}
private void quickSort(int[] data int i int j){
int pivotIndex=(i+j)/ ;
//swap SortUtil swap(data pivotIndex j);
int k=partition(data i j data[j]);
SortUtil swap(data k j);
if((k i)> ) quickSort(data i k );
if((j k)> ) quickSort(data k+ j);
}
/**
* @param data
* @param i
* @param j
* @return
*/
private int partition(int[] data int l int r int pivot) {
do{
while(data[++l]<pivot);
while((r!= )&&data[ r]>pivot);
SortUtil swap(data l r);
}
while(l<r);
SortUtil swap(data l r);
return l;
}
}
改进后的快速排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class ImprovedQuickSort implements SortUtil Sort {
private static int MAX_STACK_SIZE= ;
private static int THRESHOLD= ;
/* (non Javadoc)
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
int[] stack=new int[MAX_STACK_SIZE];
int top= ;
int pivot;
int pivotIndex l r;
stack[++top]= ;
stack[++top]=data length ;
while(top> ){
int j=stack[top ];
int i=stack[top ];
pivotIndex=(i+j)/ ;
pivot=data[pivotIndex];
SortUtil swap(data pivotIndex j);
//partition l=i ;
r=j;
do{
while(data[++l]<pivot);
while((r!= )&&(data[ r]>pivot));
SortUtil swap(data l r);
}
while(l<r);
SortUtil swap(data l r);
SortUtil swap(data l j);
if((l i)>THRESHOLD){
stack[++top]=i;
stack[++top]=l ;
}
if((j l)>THRESHOLD){
stack[++top]=l+ ;
stack[++top]=j;
}
}
//new InsertSort() sort(data); insertSort(data);
}
/**
* @param data
*/
private void insertSort(int[] data) {
int temp;
for(int i= ;i<data length;i++){
for(int j=i;(j> )&&(data[j]<data[j ]);j ){
SortUtil swap(data j j );
}
}
}
}
归并排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class MergeSort implements SortUtil Sort{
/* (non Javadoc)
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
int[] temp=new int[data length];
mergeSort(data temp data length );
}
private void mergeSort(int[] data int[] temp int l int r){
int mid=(l+r)/ ;
if(l==r) return ;
mergeSort(data temp l mid);
mergeSort(data temp mid+ r);
for(int i=l;i<=r;i++){
temp[i]=data[i];
}
int i =l;
int i =mid+ ;
for(int cur=l;cur<=r;cur++){
if(i ==mid+ )
data[cur]=temp[i ++];
else if(i >r)
data[cur]=temp[i ++];
else if(temp[i ]<temp[i ])
data[cur]=temp[i ++];
else
data[cur]=temp[i ++];
}
}
}
改进后的归并排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class ImprovedMergeSort implements SortUtil Sort {
private static final int THRESHOLD = ;
/*
* (non Javadoc)
*
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
int[] temp=new int[data length];
mergeSort(data temp data length );
}
private void mergeSort(int[] data int[] temp int l int r) {
int i j k;
int mid = (l + r) / ;
if (l == r)
return;
if ((mid l) >= THRESHOLD)
mergeSort(data temp l mid);
else
insertSort(data l mid l + );
if ((r mid) > THRESHOLD)
mergeSort(data temp mid + r);
else
insertSort(data mid + r mid);
for (i = l; i <= mid; i++) {
temp[i] = data[i];
}
for (j = ; j <= r mid; j++) {
temp[r j + ] = 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[i];
} else {
data[k] = temp[j ];
b = temp[j];
}
}
}
/**
* @param data
* @param l
* @param i
*/
private void insertSort(int[] data int start int len) {
for(int i=start+ ;i<start+len;i++){
for(int j=i;(j>start) && data[j]<data[j ];j ){
SortUtil swap(data j j );
}
}
}
}
堆排序:
package rut util algorithm support;
import rut util algorithm SortUtil;
public class HeapSort implements SortUtil Sort{
/* (non Javadoc)
* @see rut util algorithm SortUtil Sort#sort(int[])
*/
public void sort(int[] data) {
MaxHeap h=new MaxHeap();
h init(data);
for(int i= ;i<data length;i++)
h remove();
System arraycopy(h queue data data length);
}
private static class MaxHeap{
void init(int[] data){
this queue=new int[data length+ ];
for(int i= ;i<data length;i++){
queue[++size]=data[i];
fixUp(size);
}
}
private int size= ;
private int[] queue;
public int get() {
return queue[ ];
}
public void remove() {
SortUtil swap(queue size );
fixDown( );
}
//fixdown private void fixDown(int k) {
int j;
while ((j = k << ) <= size) {
if (j < size && queue[j]<queue[j+ ])
j++;
if (queue[k]>queue[j]) //不用交换 break;
SortUtil swap(queue j k);
k = j;
}
}
private void fixUp(int k) {
while (k > ) {
int j = k >> ;
if (queue[j]>queue[k])
break;
SortUtil swap(queue j k);
k = j;
}
}
}
}
SortUtil:
package rut util algorithm;
import rut util algorithm support BubbleSort;
import rut util algorithm support HeapSort;
import rut util algorithm support ImprovedMergeSort;
import rut util algorithm support ImprovedQuickSort;
import rut util algorithm support InsertSort;
import rut util algorithm support MergeSort;
import rut util algorithm support QuickSort;
import rut util algorithm support SelectionSort;
import rut util algorithm support ShellSort;
public class SortUtil {
public final static int INSERT = ;
public final static int BUBBLE = ;
public final static int SELECTION = ;
public final static int SHELL = ;
public final static int QUICK = ;
public final static int IMPROVED_QUICK = ;
public final static int MERGE = ;
public final static int IMPROVED_MERGE = ;
public final static int HEAP = ;
public static void sort(int[] data) {
sort(data IMPROVED_QUICK);
}
private static String[] name={
insert bubble selection shell quick improved_quick merge improved_merge heap
};
private static Sort[] impl=new Sort[]{
new InsertSort()
new BubbleSort()
new SelectionSort()
new ShellSort()
new QuickSort()
new ImprovedQuickSort()
new MergeSort()
new ImprovedMergeSort()
new HeapSort()
};
public static String toString(int algorithm){
return name[algorithm ];
}
public static void sort(int[] data int algorithm) {
impl[algorithm ] sort(data);
}
public static interface Sort {
public void sort(int[] data);
}
public static void swap(int[] data int i int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
lishixinzhi/Article/program/Java/hx/201311/25756
微信收款码
支付宝收款码