选择排序、归并排序和希尔排序算法的JAVA实现
[b]归并排序算法的JAVA实现[/b]
package Utils.Sort;
/**
*归并排序,要求待排序的数组必须实现Comparable接口
*/
public class MergeSort implements SortStrategy
{ private Comparable[] bridge;
/**
*利用归并排序算法对数组obj进行排序
*/
public void sort(Comparable[] obj)
{ if (obj == null)
{ throw new NullPointerException("The param can not be null!");
}
bridge = new Comparable[obj.length]; //初始化中间数组
mergeSort(obj, 0, obj.length - 1); //归并排序
bridge = null;
}
/**
*将下标从left到right的数组进行归并排序
*@param obj 要排序的数组的句柄
*@param left 要排序的数组的第一个元素下标
*@param right 要排序的数组的最后一个元素的下标
*/
private void mergeSort(Comparable[] obj, int left, int right)
{ if (left
{ int center = (left + right)/2;
mergeSort(obj, left, center);
mergeSort(obj, center + 1, right);
merge(obj, left, center, right);
}
}
/**
*将两个对象数组进行归并,并使归并后为升序。归并前两个数组分别有序
*@param obj 对象数组的句柄
*@param left 左数组的第一个元素的下标
*@param center 左数组的最后一个元素的下标
*@param right 右数组的最后一个元素的下标
*/
private void merge(Comparable[] obj, int left, int center, int right)
{ int mid = center + 1;
int third = left;
int tmp = left;
while (left
{ //从两个数组中取出小的放入中间数组
if (obj[left].compareTo(obj[mid])
{ bridge[third++] = obj[left++];
} else
bridge[third++] = obj[mid++];
}
//剩余部分依次置入中间数组
while (mid
{ bridge[third++] = obj[mid++];
}
while (left
{ bridge[third++] = obj[left++];
}
//将中间数组的内容拷贝回原数组
copy(obj, tmp, right);
}
/**
*将中间数组bridge中的内容拷贝到原数组中
*@param obj 原数组的句柄
*@param left 要拷贝的第一个元素的下标
*@param right 要拷贝的最后一个元素的下标
*/
private void copy(Comparable[] obj, int left, int right)
{ while (left
{ obj[left] = bridge[left];
left++;
} }
}
[b]选择排序算法的JAVA实现[/b]
package Utils.Sort;
/**
*@author Linyco
*利用选择排序法对数组排序,数组中元素必须实现了Comparable接口。
*/
public class ChooseSort implements SortStrategy
{ /**
*对数组obj中的元素以选择排序算法进行排序
*/
public void sort(Comparable[] obj)
{ if (obj == null)
{ throw new NullPointerException("The argument can not be null!");
}
Comparable tmp = null;
int index = 0;
for (int i = 0 ;i
{ index = i;
tmp = obj[i];
for (int j = i + 1 ;j
{ //对邻接的元素进行比较,如果后面的小,就记下它的位置
if (tmp.compareTo(obj[j]) > 0)
{ tmp = obj[j]; //要每次比较都记录下当前小的这个值!
index = j;
}
}
//将最小的元素交换到前面
tmp = obj[i];
obj[i] = obj[index];
obj[index] = tmp;
} } }
[b]希尔排序算法的JAVA实现[/b]
package Utils.Sort;
/**
*希尔排序,要求待排序的数组必须实现Comparable接口
*/
public class ShellSort implements SortStrategy
{ private int[] increment;
/**
*利用希尔排序算法对数组obj进行排序
*/
public void sort(Comparable[] obj)
{ if (obj == null)
{ throw new NullPointerException("The argument can not be null!");
}
//初始化步长
initGap(obj);
//步长依次变化(递减)
for (int i = increment.length - 1 ;i >= 0 ;i-- )
{ int step = increment[i];
//由步长位置开始
for (int j = step ;j
{ Comparable tmp;
//如果后面的小于前面的(相隔step),则与前面的交换
for (int m = j ;m >= step ;m = m - step )
{ if (obj[m].compareTo(obj[m - step])
{ tmp = obj[m - step];
obj[m - step] = obj[m];
obj[m] = tmp;
}
//因为之前的位置必定已经比较过,所以这里直接退出循环
else
{ break;
} } } }
}
/**
*根据数组的长度确定求增量的公式的最大指数,公式为pow(4, i) - 3 * pow(2, i) + 1和9 * pow(4, i) - 9 * pow(2, i) + 1
*@return int[] 两个公式的最大指数
*@param length 数组的长度
*/
private int[] initExponent(int length)
{ int[] exp = new int[2];
exp[0] = 1;
exp[1] = -1;
int[] gap = new int[2];
gap[0] = gap[1] = 0;
//确定两个公式的最大指数
while (gap[0]
{ exp[0]++;
gap[0] = (int)(Math.pow(4, exp[0]) - 3 * Math.pow(2, exp[0]) + 1);
}
exp[0]--;
while (gap[1]
{
exp[1]++;
gap[1] = (int)(9 * Math.pow(4, exp[1]) - 9 * Math.pow(2, exp[1]) + 1);
}
exp[1]--;
return exp;
}
private void initGap(Comparable[] obj)
{ //利用公式初始化增量序列
int exp[] = initExponent(obj.length);
int[] gap = new int[2];
increment = new int[exp[0] + exp[1]];
//将增量数组由大到小赋值
for (int i = exp[0] + exp[1] - 1 ;i >= 0 ;i-- )
{ gap[0] = (int)(Math.pow(4, exp[0]) - 3 * Math.pow(2, exp[0]) + 1);
gap[1] = (int)(9 * Math.pow(4, exp[1]) - 9 * Math.pow(2, exp[1]) + 1);
//将大的增量先放入增量数组,这里实际上是一个归并排序
//不需要考虑gap[0] == gap[1]的情况,因为不可能出现相等。
if (gap[0] > gap[1])
{ increment[i] = gap[0];
exp[0]--;
} else
{ increment[i] = gap[1];
exp[1]--;
} } } }
作者:Linyco
来源:
[url=http://blog.csdn.net/Linyco/]
[color=#003366]http://blog.csdn.net/Linyco/[/color]
[/url] |