冒泡排序,时间复杂度O(n^2):
public static void bubbleSort(int[] array) {
int temp;
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
插入排序,时间复杂度O(n^2):
public static void insertSort(int[] array) {
int temp;
int j;
for (int i = 1; i < array.length; i++) {
temp = array[i];
j = i - 1;
while ( j >= 0 && temp > array[j]) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp;
}
}
快速排序,时间复杂度O(nlogn):
public static void quickSort(int[] array, int left, int right) {
if (left < right) {
int position = partition(array, left, right);
quickSort(array, left, position - 1);
quickSort(array, position + 1, right);
}
}
private static int partition(int[] array, int left, int right) {
int pivot = array[left];
while (left < right) {
while (left < right && array[right] < pivot) {
right--;
}
array[left] = array[right];
while (left < right && array[left] >= pivot) {
left++;
}
array[right] = array[left];
}
array[left] = pivot;
return left;
}
合并两个已排序数组:
public static int[] mergeArray(int[] array1, int[] array2) {
int length = array1.length + array2.length;
int[] arrayMerged = new int[length];
int i = 0;
int j = 0;
int k = 0;
int length1 = array1.length;
int length2 = array2.length;
while (i< length1 && j < length2) {
if (array1[i] < array2[j]) { //拷贝值较小的元素,填充合并数组
arrayMerged[k++] = array1[i++];
} else if (array1[i] > array2[j]) {
arrayMerged[k++] = array2[j++];
} else {
arrayMerged[k++] = array1[i++];
arrayMerged[k++] = array1[j++];
}
}
if (i >= length1) {
while (j < length2) {
arrayMerged[k++] = array2[j++];
}
} else {
while (i < length1) {
arrayMerged[k++] = array1[i++];
}
}
return arrayMerged;
}
不用中间变量,交换两个数:
public static void swap(int[] array, int n, int m, int method) {
switch (method) {
case 0:
array[n] = array[n] + array[m];
array[m] = array[n] - array[m];
array[n] = array[n] - array[m];
break;
case 1:
array[n] = array[n] * array[m];
array[m] = array[n] / array[m];
array[n] = array[n] / array[m];
default:
break;
}
}