几种常见排序算法(JAVA实现)

System.out.println(s[i]);
}
}
}
快速排序:
思想: 基于冒泡排序,取第一个作为关键值 a,用 a 与后面开始往前比较,遇到比 a 小 的则交换,依然乘此关键值为 a,再用 a 与第一个数开始向后比较,遇到比 a 大的则 交换,最终的关键值将依然是最初的第一个元素的值,用此值将此无序序列分成两 部分,比它小的都在它前面,大的都在后面,然后用递归将前面和后面的分别用快 速排序进行处理,得到最终的有序序列. java 代码实现:
// 程序还有问题.比如当数据为49,38, 65, 97, 76, 13, 27,12,11 // 的时候,第一次就把最小一位放到第一位,,而出现问题 QuickSort.method2(arry);
// Arrays.sort(arry, 0, arry.length);
Summary by Leon Liu
Summary by Leon Liu
排序算法
冒泡排序:
思想: n 个数,将第一个和第二个进行比较,将大的放在第二个位置,再将第二个和第 三比较,大的放在第三个位置,依次向后比较,比较 n-1 次,将最大的放在最后(n 的位 置),然后再从第一个开始比较,比较 n-2 次,这次把最大的放到第 n-1 个位置,然后再 来回比较.遵循第 i 次遍历就从第一个数开始比较 n-i 次,将最后的值放在第 n-i+1 的位置. java 代码实现: // 冒泡排序
System.out.println("i2: " + i + "; " + "j2: " + j + "; " + "k2: "
+ k + "; f2: " + f); for (int a = 0; a < array.length; a++) {
System.out.print(array[a] + ","); } System.out.println(); // [27, 38, 65, 97, 76, 13, 49] //[27, 38, 49, 97, 76, 13, 49] // [27, 38, 49, 97, 76, 13, 65] //[27, 38, 13, 97, 76, 49, 65] // [27, 38, 13, 49, 76, 49, 65] //[27, 38, 13, 49, 76, 97, 65] System.out.println(array[i] + " " + array[j]); if (array[i] == array[j]) {
public class BubbleSort { public static void sort(Comparable[] data) { // 数组长度 int len = data.length; for (int i = 0; i < len - 1; i++) { // 临时变量 Comparable temp = null; // 交换标志，false表示未交换 boolean isExchanged = false; for (int j = len - 1; j > i; j--) { // 如果data[j]小于data[j - 1]，交换 if (data[j].compareTo(data[j - 1]) < 0) { temp = data[j]; data[j] = data[j - 1]; data[j - 1] = temp; // 发生了交换，故将交换标志置为真 isExchanged = true; }// end if }// end for // 本趟排序未发生交换，提前终止算法，提高效率 if (!isExchanged) { break; }// end if }// end for }// end sort
x++; if (x > (array.length / 2 + 1)) {
check = true; } } if (i == j || check) { k = array[0]; // 获取数组第一位 if (i == j && i == 0) {
k = array[1]; } i = 0; j = array.length - 1; // 获取数组最后一位 check = false; x = 0; if (f > (array.length / 2 Baidu Nhomakorabea 1)) {
"
+ k + "; f0: " + f);
int temp = k;
k = array[j];
array[j] = temp;
// [49, 38, 65, 97, 76, 13, 49] //[27, 38, 65, 97, 76, 13, 49]
// [27, 38, 49, 97, 76, 13, 65] //[27, 38, 49, 97, 76, 49, 65]
} }
选择排序:
思想: 与冒泡不同的是:冒泡是大的与小的交换,而选择是用下标来作为标记,记录哪 个是最小的,一次遍历后交换一次,两种算法比较的次数一样,但是交换的次数不 同. java 代码实现:
public class SelectSort {
Summary by Leon Liu
public static void main(String[] args) { int[] arr = { 2, 345, 111, 1, 34, 5 }; sort(arr); System.out.println("选择排序后: "); for(int i = 0; i<arr.length; i++){ System.out.print(arr[i] + ", "); }
// [27, 38, 13, 97, 76, 49, 65] //[27, 38, 13, 49, 76, 97, 65]
// [27, 38, 13, 49, 76, 97, 65]
// 4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key
的A[I]，与key交换；
while (array[i] < k) {
while (i != j) {
// 3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key
的值A[J]，并与key交换；
while (array[j] > k) {
j--;
}
System.out.println("i0: " + i + "; " + "j0: " + j + "; " + "k0:
public static void main(String[] args) { // 在JDK1.5版本以上，基本数据类型可以自动装箱 // int,double等基本类型的包装类已实现了Comparable接口 Comparable[] c = { 4, 9, 23, 1, 45, 27, 5, 2 }; sort(c);
public class QuickSort {
public static void main(String[] args) {
// int [] arry={49, 38, 65, 97, 76, 13, 27};
int[] arry = { 27, 38, 65, 97, 76, 48, 49 };
int i = 0;
int j = array.length - 1;
// 获取数组最后一位
// 2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0];
int k = array[0];
// 获取数组第一位
int f = 0;
boolean check = false;
int x = 0;
先将无序序列中的第一个值去除作为关键值,然后将其放入有序序列(即作为 新序列的第一个值),然后取第二个值作为关键值,将关键值放入有序序列,并与第 一个值进行比较,若小于第一个值,则将这个关键值插入到第一个值前面(交换),后 面依次取值然后和前面的有序序列中的值进行比较,插入到合适位置 java 代码实现:
//
}
}
}// 简单示例
public class Test_Ordination {
public static void main(String args[]) {
int[] s = { 23, 5, 12, 59, 78, 21, 100, 79, 66 };
for (int j = 1; j <= s.length; j++) {
for (int i = 0; i < arry.length; i++) { System.out.println("结果:" + arry[i]);
} }
/** * 快速排序 * @param arry
*/
public static void method2(int[] array) {
// 1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
public class InsertSort { public static void sort(Comparable[] data) { // 数组长度 int len = data.length; // 从下标为1开始依次插入 for (int i = 1; i < len; i++) { // 当前待插入的数据 Comparable currentData = data[i]; int temp = i; while (temp > 0 && data[temp - 1].compareTo(currentData) > 0)
} public static void sort(int[] arr){
int temp = 0; int min = 0; for (int i = 0; i < arr.length - 1; i++) {
for (int i = 0; i < s.length - 1; i++) {
if (s[i] > s[i + 1]) {
int temp;
temp = s[i];
s[i] = s[i + 1];
s[i + 1] = temp;
}
}
}
for (int i = 0; i < s.length; i++) {
{ // 向右移动 data[temp] = data[temp - 1]; temp--;
} // end while data[temp] = currentData; }// end for }// end sort
public static void main(String[] args) { // 在JDK1.5版本以上,基本数据类型可以自动装箱 // int,double等基本类型的包装类已实现了Comparable接口 Comparable[] c = { 4, 9, 23, 1, 45, 27, 5, 2 }; sort(c); System.out.println("插入排序后: "); for(int i = 0; i<c.length; i++){ System.out.print(c[i] + ", "); }
i++;
}
System.out.println("i1: " + i + "; " + "j1: " + j + "; " + "k1:
"
+ k + "; f1: " + f);
int temp1 = k;
k = array[i];
array[i] = temp1;
Summary by Leon Liu
Summary by Leon Liu
System.out.println("冒泡排序后: ");
for(int i = 0; i<c.length; i++){
System.out.print(c[i] + ", ");
}
//
for (Comparable data : c) {
//
System.out.println(data);
k = array[j]; } if (f == array.length) {
break; } f++; }// [27, 38, 13, 49, 76, 97, 65] //[13, 27, 38, 49, 76, 97, 65] } // } } } }
插入排序(直接插入排序):
思想:
Summary by Leon Liu