算法实战java实现插入排序，堆排序，归并排序

插入排序

直接插入排序

原理

每一个元素插入它前面排序好的元素中

java实现

//直接插入排序，由小到大
void inserSort( int[] list) {
int j;

for( int p = 1; p < list.length; p++ ) {

int temp = list[p];
//比较当前位置与前面一个的大小， 如果当前位置较小与前一个交换。
for ( j = p;  j > 0 && temp - list[ j - 1] < 0; j--)
list[j] = list[j-1];
list[j] = temp;
}

}

希尔排序（缩减增量排序）

原理

对间隔中的数进行直接插入排序排序，间隔慢慢减低，最后到1.

java实现

//希尔排序。（缩减增量排序）
void shellsort( int [] a) {
int j;

for (int gap = a.length /2; gap > 0; gap /= 2)
//对每个gap间隔的数组进行直接插入排序
for( int i = gap; i < a.length; i++) {

int temp = a[i];
for( j = i; j >= gap &&
temp - a[j-gap] < 0; j-=gap)
a[j] = a[j-gap];
a[j] = temp;
}

}

堆排序

原理

在本人之前的二叉堆这种数据结构的基础上，进行排序。

java实现

public class HeapSort {

//构建小顶堆
public HeapSort( int [] items ) {

currentSize = items.length;
//确定array'数组'的大小
array =  new int[(currentSize + 2) * 11 /10];
sorted = new int[currentSize];

int i = 1;
// for xx in list :

for( int item : items)
//第一个空位留下
array[ i++ ] = item;
buildHeap();

}
//按由小到大的顺序。排列
public void heapsort() {
int i =0;
while ( currentSize > 0 ) {
sorted[i] = this.deleteMin();
i++;
}

System.out.println("排序完成");
}

public int deleteMin() {

int minVal = array[1];
array[1] = array[ currentSize];
currentSize--;
percolateDown( 1 );
return minVal;
}

private int currentSize;
private int[] array;
//存放排序好的数组
private int[] sorted;
// 对于数组任一位置i的元素， 左儿子在2i，右儿子在2i+1， 父在 i/2
private void buildHeap() {
for( int i = currentSize /2; i > 0; i-- )
percolateDown( i );

}

private void percolateDown( int hole) {
int child;
int temp = array[ hole ];

for (  ; hole * 2 <= currentSize; hole = child) {

child = hole * 2;
if ( child != currentSize &&
array[child + 1] - (array[child]) < 0)
child++;
if ( array[child]-  temp < 0)
array[hole] = array[child];
else
break;

}
array[hole] = temp;

}
}

归并排序

原理

A,B为排序的列表

c为排序好的列表

x,y指向的数进行对比，小的数保存在c中。z和小的个指针更新自己。若A或B那个先用完，将另一个剩下直接放在c中。

java实现

public class MergeSort {

public MergeSort(int[] list) {

sort(list, 0, list.length - 1);

}
//递归的将一个大数组转变为小数组
void sort( int[] list, int left, int right) {
//递归退出条件
if (left >= right)
return;
//找出中间索引值
int center = (left + right) /2;
sort(list,left, center );
sort(list, center + 1, right );
//合并排序好的数组
merge( list, left, center, right);
}
//归并,
void merge( int[] list, int left, int center, int right ) {
int[] tempArray = new int[list.length];
//右数组第一个元素索引
int rightStart = center + 1;
//左数组第一个元素的索引
int leftStart = left;
// third 记录临时数组的索引
int third = left;

while( leftStart <= center && rightStart <= right )
//如果leftPos 处的数《= rightPos处的数， 将leftPos 处的数保存在tempArray中
if (list[leftStart] - list[rightStart] <= 0)
tempArray[third++] = list[leftStart++];
else
tempArray[third++] = list[rightStart++];
//如果左右俩组数组哪一组先用完
//左组未用完
while ( leftStart <= center )
tempArray[third++] = list[leftStart++];

//右组未用完
while ( rightStart <= right )
tempArray[third++] = list[rightStart++];

//将排序好的数组覆盖原数组
while( left <= right)
list[ left ] = tempArray[ left++ ];

}

}