package sort;
public class Data {
public int number;
public String tag = "";
public Data(int data, String tag) {
this.number = data;
this.tag = tag;
}
public Data(int data) {
this.number = data;
}
public static Data[] getArr() {
return new Data[] {new Data(750),new Data(666),new Data(128),new Data(985),new Data(863,"A"),
new Data(10),new Data(400),new Data(863,"B"),new Data(211),new Data(233),};
}
public static void print(Data[] data) {
for(int i=0;i<data.length-1;i++) {
System.out.print(data[i]!=null?(data[i].number+data[i].tag+"\t"):"-\t");
}
System.out.println(data[data.length-1]!=null?(data[data.length-1].number+data[data.length-1].tag+"\t"):"-\t");
}
public static void exchange(Data[] datas,int i1,int i2) {
Data temp = datas[i1];
datas[i1] = datas[i2];
datas[i2] = temp;
}
@Override
public String toString() {
return ""+number;
}
}
package sort;
public class SelectSort {
public static void main(String[] args) {
Data[] arr = Data.getArr();
Data.print(arr);
System.out.println("-----------------");
sort(arr);
}
/**
* 選擇排序
*/
private static void sort(Data[] arr) {
for(int i=0;i<arr.length;i++) {
int minIndex = i;
for(int k=i;k<arr.length;k++) {
if(arr[k].number<arr[minIndex].number) {
minIndex = k;
}
}
if(minIndex!=i) {
Data.exchange(arr, minIndex, i);
}
Data.print(arr);
}
}
}
package sort;
public class HeapSort {
public static void main(String[] args) {
Data[] arr = Data.getArr();
Data.print(arr);
System.out.println("-----------------");
sort(arr);
}
/**
* 堆排序
*/
private static void sort(Data[] arr) {
for(int i=0;i<arr.length;i++) {
int len = arr.length-i;
createBigRootHeap(arr,len);
Data.exchange(arr, 0, len-1);
Data.print(arr);
}
}
/**
* @param arr 母數組
* @param length 子數組長度
*/
private static void createBigRootHeap(Data[] arr, int length) {
for(int i=length/2-1;i>=0;i--) {
int lastNotLeafIndex = i;
exchangeRoot(arr,length,lastNotLeafIndex);
}
}
/**
* 從某個節點開始,遞歸往下構建大根堆
* @param arr 母數組
* @param length 子數組長度
* @param lastNotLeafIndex 最後一個非葉子節點
*/
private static void exchangeRoot(Data[] arr,int length, int lastNotLeafIndex) {
int leftChildIndex = 2*lastNotLeafIndex+1;
int rightChildIndex = 2*lastNotLeafIndex+2;
int maxValueIndex = lastNotLeafIndex;
if(rightChildIndex<length&&arr[maxValueIndex].number<arr[rightChildIndex].number) {
maxValueIndex = rightChildIndex;
}
if(leftChildIndex<length&&arr[maxValueIndex].number<arr[leftChildIndex].number) {
maxValueIndex = leftChildIndex;
}
if(maxValueIndex!=lastNotLeafIndex) {
Data.exchange(arr, maxValueIndex, lastNotLeafIndex);
exchangeRoot(arr,length,maxValueIndex);
}
}
}
package sort;
public class MergeSort {
private static Data[] temp;
private static int index = 0;
public static void main(String[] args) {
Data[] arr = Data.getArr();
temp = new Data[arr.length];
Data.print(arr);
System.out.println("-----------------");
sort(arr);
}
/**
* 歸併排序
*/
private static void sort(Data[] arr) {
partSort(arr,1);
}
private static void partSort(Data[] arr, int len) {
if(len>=arr.length) {
return;
}
for(int i=0,k=i+len;i<arr.length;i+=2*len,k=i+len) {
int indexI=i;
int indexK=k;
int endI = (i+len-1);
if(endI>=arr.length) {
endI = arr.length-1;
}
int endK = (k+len-1);
if(endK>=arr.length) {
endK = arr.length-1;
}
while(indexI<=endI && indexK<=endK) {
if(arr[indexI].number>arr[indexK].number) {
temp[index++] = arr[indexK++];
}else if(arr[indexI].number<arr[indexK].number){
temp[index++] = arr[indexI++];
}else {
temp[index++] = arr[indexI++];
temp[index++] = arr[indexK++];
}
}
while(indexI<=endI) {
temp[index++] = arr[indexI++];
}
while(indexK<=endK) {
temp[index++] = arr[indexK++];
}
Data.print(temp);
}
System.out.println();
index = 0;
Data[] d = arr;
arr = temp;
temp = d;
for(int i=0;i<temp.length;i++)temp[i] = null;
partSort(arr, len*2);
}
}