冒泡排序：
public static void bubbleSort(int [] arr){
boolean flag=false;
for (int i =0; i < arr.length; i++) {
for (int j =1; j < arr.length-i; j++) {
if(arr[i]>arr[j]){
swap(arr[i],arr[j]);
flag=true;
}
}
if(flag==false){
return;
}
}
}
归并排序
publicstaticint[] MergeSort(int[] array) {
if(array.length < 2)return array;
intmid = array.length / 2;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.copyOfRange(array, mid, array.length);
return merge(MergeSort(left), MergeSort(right));
}
publicstaticint[] merge(int[] left,int[] right) {
int[] result =newint[left.length + right.length];
for(intindex = 0, i = 0, j = 0; index < result.length; index++) {
if(i >= left.length)
result[index] = right[j++];
elseif(j >= right.length)
result[index] = left[i++];
elseif(left[i] > right[j])
result[index] = right[j++];
else result[index] = left[i++];
}
return result;
}
快速排序
public static void sort(int data[],int start,int end) {
if (end - start <=0) {
return;
}
int smallindex = start;
for (int i = start +1; i < end; i++) {
if (data[i] < data[start]) {
smallindex++;
swap(data,i,smallindex);
}
}
swap(data,start,smallindex);
sort(data, start, smallindex -1);
sort(data, smallindex+1, end);
}
public void swap(int[] nums,int i,int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
堆排序：保证每一次移动一个节点，该节点的作为树根的树，都是最小堆（理解while循环）
public static void headSort(int[] list) {
for (int i = (list.length) /2 -1; i >=0; i--) {
headAdjust(list, list.length, i);
}
for (int i = list.length -1; i >=1; i--) {
swap(list,0,i);
headAdjust(list, i,0);
}
}
private static void headAdjust(int[] list,int len,int parent) {
//k是父亲临时位置，temp是父节点的临时值
int k = parent, temp = list[parent], child =2 * k +1;
while (child < len) {
if (child +1 < len) {
if (list[child] < list[child +1]) {
child = child +1;
}
}
if (list[child] > temp) {
list[k] = list[child];
k = child;
child =2 * k +1;
}else {
break;
}
}
list[k] = temp;
}
