Java算法＜2＞

-希尔排序算法
基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

1. 操作方法：选择一个增量序列 t1，t2，…，tk，其中 ti>tj，tk=1；

2. 按增量序列个数 k，对序列进行 k 趟排序；

3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

 private void shellSort(int[] a) {
int dk = a.length/2; 
while( dk >= 1 ){ 
 ShellInsertSort(a, dk); 
 dk = dk/2;
} }
private void ShellInsertSort(int[] a, int dk) {
//类似插入排序，只是插入排序增量是 1，这里增量是 dk,把 1 换成 dk 就可以了
for(int i=dk;i<a.length;i++){
if(a[i]<a[i-dk]){
int j;
int x=a[i];//x 为待插入元素
a[i]=a[i-dk];
for(j=i-dk; j>=0 && x<a[j];j=j-dk){
//通过循环，逐个后移一位找到要插入的位置。
a[j+dk]=a[j];
}
a[j+dk]=x;//插入
} } }

归并排序算法

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

 public class MergeSortTest { 
 public static void main(String[] args) { 
 int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 }; 
 print(data); 
 mergeSort(data); 
 System.out.println("排序后的数组："); 
 print(data); 
 } 
 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); 
 print(data); 
 } 
 /** 
 * 将两个数组进行归并，归并前面 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++]; 
 } 
 } 
 public static void print(int[] data) { 
 for (int i = 0; i < data.length; i++) { 
 System.out.print(data[i] + "\t"); 
 } 
 System.out.println(); 
 } 
 }

桶排序算法
桶排序的基本思想是：把数组 arr 划分为 n 个大小相同子区间（桶），每个子区间各自排序，最后合并 。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

1.找出待排序数组中的最大值 max、最小值 min。

2.我们使用 动态数组 ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(maxmin)/arr.length+1

3.遍历数组 arr，计算每个元素 arr[i] 放的桶

4.每个桶各自排序

public static void bucketSort(int[] arr){
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int i = 0; i < arr.length; i++){
max = Math.max(max, arr[i]);
min = Math.min(min, arr[i]);
}
//创建桶
int bucketNum = (max - min) / arr.length + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
for(int i = 0; i < bucketNum; i++){
bucketArr.add(new ArrayList<Integer>());
}
//将每个元素放入桶
for(int i = 0; i < arr.length; i++){
int num = (arr[i] - min) / (arr.length);
bucketArr.get(num).add(arr[i]);
}
//对每个桶进行排序
for(int i = 0; i < bucketArr.size(); i++){
Collections.sort(bucketArr.get(i));
}}

基数排序算法
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列

 public class radixSort {
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,2
5,53,51};
public radixSort(){
sort(a);
for(inti=0;i<a.length;i++){
System.out.println(a[i]);
} }
public void sort(int[] array){
//首先确定排序的趟数;
int max=array[0];
for(inti=1;i<array.length;i++){
if(array[i]>max){
max=array[i];
} }
int time=0;
//判断位数;
while(max>0){
max/=10;
time++;
}
//建立 10 个队列;
List<ArrayList> queue=newArrayList<ArrayList>();
for(int i=0;i<10;i++){
ArrayList<Integer>queue1=new ArrayList<Integer>();
queue.add(queue1);
}
//进行 time 次分配和收集;
for(int i=0;i<time;i++){
//分配数组元素;
for(intj=0;j<array.length;j++){
//得到数字的第 time+1 位数;
int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
ArrayList<Integer>queue2=queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
int count=0;//元素计数器;
//收集队列元素;
for(int k=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayList<Integer>queue3=queue.get(k);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
} } } } }

关注微信公众号“伊斯电子编程”
获取更多资源