1、请列举常用的算法,并说明其时间复杂读,并说明排序思想?
①冒泡排序:量量比较待排序数据元素的大小,发现两个数据元素的次序相反时进行交换,直到没有反序的数据元素为止。时间复杂度是O(n*2)。稳定的。
public class bubble1 {
public static void main(String[] args) {
int[] array = { 7, 8, 3, 1, 5, 2, 9, 6, 4 };
printArray(array);
bubbleSort(array);
printArray(array);
}
private static void bubbleSort(int[] array) {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
private static void printArray(int[] array) {
if (array.length == 0 || array == null) {
return;
}
for (int i = 0; i < array.length - 1; i++) {
System.out.print(array[i] + " ");
}
System.out.println(array[array.length - 1]);
}
}
public class bubble2 {
public static void main(String[] args) {
int[] array = { 7, 8, 3, 1, 5, 2, 9, 6, 4 };
printArray(array);
bubbleSort(array);
printArray(array);
}
private static void bubbleSort(int[] array) {
for (int i = 0; i < array.length; i++) {
for (int j = array.length - 2; j >= i; j--) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
private static void printArray(int[] array) {
if (array.length == 0 || array == null) {
return;
}
for (int i = 0; i < array.length - 1; i++) {
System.out.print(array[i] + " ");
}
System.out.println(array[array.length - 1]);
}
}
②选择排序:每一趟从待排序的数据元素中选出最小(最大)的一个元素,顺序放在已经排好序的数列的最后面,
直到全部待排序的数据元素排完,算法复杂度是O(n*2)。不稳定的。
public class select {
public static void main(String[] args) {
int[] array = { 0, 8, 3, 1, 5, 2, 9, 6, 4 };
printArray(array);
selectSort(array);
printArray(array);
}
private static void selectSort(int[] array) {
int k = 0;
for (int i = 0; i < array.length; i++) {
k = i;
for (int j = i; j < array.length; j++) {
if (array[j] < array[k]) {
k = j;
}
}
int temp = array[i];
array[i] = array[k];
array[k] = temp;
}
}
private static void printArray(int[] array) {
if (array.length == 0 || array == null) {
return;
}
for (int i = 0; i < array.length - 1; i++) {
System.out.print(array[i] + " ");
}
System.out.println(array[array.length - 1]);
}
}
③插入排序:每次将一个待排序的数据元素,插入到前面已经排好序的数列中的适当位置,使数列依然有序;直到待排序数据元素全部插入完为止。
算法的时间复杂度是o(n*2)。稳定的。
public class insert {
public static void main(String[] args) {
int[] array = { 0, 8, 3, 1, 5, 2, 9, 6, 4 };
printArray(array);
insertSort(array);
printArray(array);
}
private static void insertSort(int[] array) {
int temp = 0;
for (int i = 1; i < array.length; i++) {
temp = array[i];
int j = 0;
for (j = i; j > 0; j--) {
if (array[j - 1] > temp) {
array[j] = array[j - 1];
} else {
break;
}
}
array[j] = temp;
}
}
private static void printArray(int[] array) {
if (array.length == 0 || array == null) {
return;
}
for (int i = 0; i < array.length - 1; i++) {
System.out.print(array[i] + " ");
}
System.out.println(array[array.length - 1]);
}
}
④快速排序:在当前无序区 R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为 X),用此基准将当前无序区划分为左右两个较小的无序区:R[1..I-1]和 R[I+1..H],
且左边的无序子区中数据元素均小于等于基准元素,右边的无序子区中数据元素均大于等于基准元素,而基准 X 则位于最终排序的位置上,
即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H),当 R[1..I-1]和 R[I+1..H]均非空时,分别对它们进行上述的划分过程,直至所有无序子区中的数据元素均已排序为止。
最理想情况算法时间复杂度 O(nlogn),最坏O(n^2) 。不稳定。