排序算法动手研究

这段时间研究了一下排序算法，动手的感觉真好，学习算法也提高了兴趣。

public abstract class MySort {
public int[] array;

public abstract void sort();

public MySort(int[] array) {
this.array = array;
}

public void printArray(String desp, int[] array){
System.out.println(desp);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}

public void exChangeElement(int[] array,int index,int largest){
int value = array[index];
array[index] = array[largest];
array[largest] = value;
}

public static void main(String[] args) {
int[] array = new int[]{9,8,2,53,23,2,321,232,467,54,78,54,34,3,998};
//        MySort algo = new HeapSort(array);
//        MySort algo = new InsertSort(array);
//        MySort algo = new MergeSort(array);
//        MySort algo = new MergeSortNonRecursive(array);
MySort algo = new QuickSort(array);
algo.printArray("original:",array);
algo.sort();
algo.printArray("after:",array);
}

}

快速排序

public class QuickSort extends MySort {

public QuickSort(int[] array) {
super(array);
}

@Override
public void sort() {
quickSort(array, 0, array.length - 1);
}

private void quickSort(int[] array, int start, int end) {
if (array == null || end <= start) {
return;
}
int lastChangePos = splitCompare(array, start, end);
if (lastChangePos == start) {
//后面元素都比基准元素大
quickSort(array, lastChangePos + 1, end);
} else if (lastChangePos == end) {
//后面元素都比基准元素小
quickSort(array, start, lastChangePos - 1);
} else {
//基准元素处于中间
quickSort(array, start, lastChangePos - 1);
quickSort(array, lastChangePos + 1, end);
}
}

private int splitCompare(int[] array, int start, int end) {
int quickElement = array[end];

int exChangePos = start - 1;
for (int currPos = start; currPos < end; currPos++) {
if (array[currPos] < quickElement) {
exChangePos++;//理解这个是关键:指示的是最近的一个小于基准元素值的索引
if (exChangePos != currPos) {
exChangeElement(array, exChangePos, currPos);
}
}
}

if (exChangePos + 1 != end) {
exChangeElement(array, exChangePos + 1, end);
}

printArray(String.format("after splitCompare:(from %d to %d)", start, end), array);
return exChangePos + 1;
}
}

堆排序

public class HeapSort extends MySort {
public HeapSort(int[] array) {
super(array);
}

@Override
public void sort() {
if(array == null && array.length <= 1){
return;
}

buildMaxHeap(array);
printArray("after buildMaxHeap:",array);
for (int size = array.length - 1; size >=1 ; size--) {
moveMaxElement(array,0,size);//移走最大值元素
printArray(size + " after moveMaxElement:",array);
adjustHeap(array,0,size);//从0号开始
printArray(size + " after adjustHeap:",array);
}
}

private void buildMaxHeap(int[] array) {
if(array == null && array.length <= 1){
return;
}
//从最后一个非叶子节点元素开始排序
for (int adjustIndex = array.length/2 ; adjustIndex >= 0; adjustIndex--) {
adjustHeap(array,adjustIndex,array.length);
}
}

private void moveMaxElement(int[] array, int fisrtIndex, int lastIndex) {
exChangeElement(array,fisrtIndex,lastIndex);
}

private void adjustHeap(int[] array, int adjustIndex, int heapSize) {
int largest = adjustIndex;
int left = adjustIndex * 2 + 1;//左子元素不一定存在
int right = adjustIndex * 2 + 2;//右子元素不一定存在
if(left < heapSize && array[left] > array[largest]){
largest = left;
}
if(right < heapSize && array[right] > array[largest]){
largest = right;
}
if(largest != adjustIndex){
exChangeElement(array,adjustIndex,largest);//父子交换
adjustHeap(array,largest,heapSize);//递归的建立大顶堆
}
}

}

插入排序

public class InsertSort extends MySort {

public InsertSort(int[] array) {
super(array);
}

@Override
public void sort() {
for (int cur = 0; cur < array.length; cur++) {
insertSortedArray(array,cur,array[cur]);
}
}

private void insertSortedArray(int[] array, int sortedSize, int value) {
if(sortedSize == 0){
array[0] = value;
}else{
int cur = sortedSize - 1;
while(cur >= 0 && array[cur] > value){
array[cur+1] = array[cur];
cur--;
}
array[cur+1] = value;
}
}
}

归并排序

public class MergeSort extends MySort {

public MergeSort(int[] array) {
super(array);
}

@Override
public void sort() {
mergeSort(array, 0, array.length - 1);
}

private void mergeSort(int[] array, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
mergeSort(array, low, mid);//左侧继续merge排序
mergeSort(array, mid + 1, high);//右侧继续merge排序
merge(array, low, mid, high);//左右侧整合,这个是核心
}
}

private void merge(int[] array, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int leftIndex = low;
int rightIndex = mid + 1;
int tempIndex = 0;
while (leftIndex <= mid && rightIndex <= high) {
if (array[leftIndex] < array[rightIndex]) {
temp[tempIndex++] = array[leftIndex++];
} else {
temp[tempIndex++] = array[rightIndex++];
}
}

//左侧有多余的
while (leftIndex <= mid) {
temp[tempIndex++] = array[leftIndex++];
}

//右侧有多余的
while (rightIndex <= high) {
temp[tempIndex++] = array[rightIndex++];
}

//将临时排序好的何如到原来的数组当中
for (int i = 0; i < temp.length; i++) {
array[low + i] = temp[i];
}
}
}

非递归的归并排序

public class MergeSortNonRecursive extends MySort {

public MergeSortNonRecursive(int[] array) {
super(array);
}

@Override
public void sort() {
nrMergeSort(array, array.length);
}

private void nrMergeSort(int[] array, int size) {
//直接申请n长度的数组空间
int[] temp = new int[size];

int stepLength = 1;
//以2的次幂为步长进行归并排序
while (stepLength < size) {
//每次合并到temp中时,都需要会写到array中,然后进行下一轮的合并
mergeSort(array, temp, stepLength, size);
stepLength *= 2;
}
}

//循环建立以2*stepLength为长度的子数组进行归并排序
private void mergeSort(int[] array, int[] temp, int stepLength, int size) {
final int SUB_ARRAY_SIZE = 2 * stepLength;
int i = 0;
while (i + SUB_ARRAY_SIZE <= size - 1) {
int subArrayBegin = i;
int subArrayMiddle = i + stepLength - 1;
int subArrayEnd = i + 2 * stepLength - 1;
merge(array, temp, subArrayBegin, subArrayMiddle, subArrayEnd);
i += SUB_ARRAY_SIZE;
}
//剩下的元素长度大于一个stepLength,但是小于2*stepLength,还需要进行一次归并
if (size - i + 1 > stepLength) {
merge(array, temp, i, i + stepLength - 1, size - 1);
}else{
//剩下的元素不足一个stepLength
for (int j = i; j < size; j++) {
temp[j] = array[j];
}
}

//回写到原来的数组当中
for (int s = 0; s < size; s++) {
array[s] = temp[s];
}
}

//核心:merge一段子数组
private void merge(int[] array, int[] temp, int begin, int mid, int end) {
int array1Index = begin;
int array2Index = mid + 1;
int pos;
for (pos = array1Index; array1Index <= mid && array2Index <= end; pos++) {
if(array[array1Index] < array[array2Index]){
temp[pos] = array[array1Index++];
}else{
temp[pos] = array[array2Index++];
}
}
if(array1Index <= mid){
for (int h = 0; h <= mid - array1Index; h++) {
temp[pos + h] = array[array1Index + h];
}
}else{
for (int h = 0; h <= end - array2Index; h++) {
temp[pos + h] = array[array2Index + h];
}
}
}
}

冒泡排序

public class BubbleSort extends MySort {
public BubbleSort(int[] array) {
super(array);
}

@Override
public void sort() {
for (int cur = 0; cur < array.length - 1; cur++) {
for (int next = 0; next < array.length - 1 - cur; next++) {
if(array[next] > array[next+1]){
exChangeElement(array,next,next+1);
}
}
}
}
}

public class MarkedBubbleSort extends MySort {
public MarkedBubbleSort(int[] array) {
super(array);
}

@Override
public void sort() {
//设置一个标志位,记录上次交换的位置，后面的为交换的元素则代表了已经排序好了
int lastExchangePos = array.length - 1;
for (int cur = 0; cur < array.length - 1; cur++) {

int exChangePos = lastExchangePos;
for (int next = 0; next < lastExchangePos; next++) {
if(array[next] > array[next+1]){
exChangeElement(array,next,next+1);
exChangePos = next;
}
}

lastExchangePos = exChangePos;
}
}
}

public class MaxMinBubbleSort extends MySort {
public MaxMinBubbleSort(int[] array) {
super(array);
}

@Override
public void sort() {
int low = 0;
int high = array.length - 1;
while (low < high) {
for (int j = low; j < high; j++) {//正向冒泡
if (array[j] > array[j + 1]) {
exChangeElement(array, j, j + 1);
}
}
--high;
for (int j = high; j > low; j--) {//反向冒泡
if (array[j] < array[j - 1]) {
exChangeElement(array, j, j - 1);
}
}
++low;
}
}
}