1/*插入排序 平均速度为O(n^2)
* 1.将数组前两个数据进行从小到达的排序
* 2.将第3个数据和排好序的连个数据进行比较,将第3个数据插入合适的位置
* 3.将第4个数据插入已经排好序的前3个数据中,不断重复以上过程,直到把最后一个数据插入到合适的位置
*/
* 1.将数组前两个数据进行从小到达的排序
* 2.将第3个数据和排好序的连个数据进行比较,将第3个数据插入合适的位置
* 3.将第4个数据插入已经排好序的前3个数据中,不断重复以上过程,直到把最后一个数据插入到合适的位置
*/
2*shell排序 平均速度为O(n^(3/2))
* 1.将有n个元素的数组分成n/2个数组序列,第一个数据和第n/2+1个数据为一对,......
* 2.一次循环使每个序列对都拍好顺序
* 3.将序列变为n/4个序列,再次排序
* 4.不断重复上诉过程,随着序列减少,最后变为一个,完成排序
*/
* 1.将有n个元素的数组分成n/2个数组序列,第一个数据和第n/2+1个数据为一对,......
* 2.一次循环使每个序列对都拍好顺序
* 3.将序列变为n/4个序列,再次排序
* 4.不断重复上诉过程,随着序列减少,最后变为一个,完成排序
*/
3/*快速排序 平均速度为O(nlogn)
* 1.首先设定一个分界值,通过分界值将数组分成左右两个部分
* 2。将大于分界值的数组放到分界值的右边,将小于分界值的数组放到分界值左边
* 3.左边和右边可以独立排序,左边则又可取分界值,将左边数组分成两边,右边同理
* 4.重复以上 过程,是递归原理
*/
* 1.首先设定一个分界值,通过分界值将数组分成左右两个部分
* 2。将大于分界值的数组放到分界值的右边,将小于分界值的数组放到分界值左边
* 3.左边和右边可以独立排序,左边则又可取分界值,将左边数组分成两边,右边同理
* 4.重复以上 过程,是递归原理
*/
4/*冒泡排序 平均速度为O(n^2)
* 1.依次比较相邻元素的大小
* 2.如果前面的元素大于后面的元素,就交换这两个数据,经过第一轮比较可将最小的放最前面
* 3.用同样方法把所有元素拍好//
*/
* 1.依次比较相邻元素的大小
* 2.如果前面的元素大于后面的元素,就交换这两个数据,经过第一轮比较可将最小的放最前面
* 3.用同样方法把所有元素拍好//
*/
5/*选择排序 平均速度为O(n^2)
* 1.首先从数组中找到最小的数,将其和第一个位置的数据交换
* 2.从剩下的n-1个数据中选择次小的1个数据,将其和第二个位置的数据交换
*/
* 1.首先从数组中找到最小的数,将其和第一个位置的数据交换
* 2.从剩下的n-1个数据中选择次小的1个数据,将其和第二个位置的数据交换
*/
6*合并排序 平均速度为O(nlogn)
* 1。将含有n个节点的待排序数据序列看作由n个长度为1的有序子表组成,然后两两合并,得到长度为2的若干个有序子表
* 2.再对子表进行两两合并,得到长度为4的若干有序子表
* 3.重复直到子表长度为n,完成排序过程
*
* 1。将含有n个节点的待排序数据序列看作由n个长度为1的有序子表组成,然后两两合并,得到长度为2的若干个有序子表
* 2.再对子表进行两两合并,得到长度为4的若干有序子表
* 3.重复直到子表长度为n,完成排序过程
*
堆排序后续
public class Testsort {
static final int size = 30;
// 插入排序
public static void insertSort(int[] a) {
int i, j, t, h;
for (i = 1; i < a.length; i++) {
t = a[i];
j = i - 1;
while (j >= 0 && t < a[j]) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = t;
System.out.println("第" + i + "步排序结果");
for (int k = 0; k < a.length; k++) {
System.out.print(" " + a[k]);
}
System.out.print("\n");
}
}
// shell排序
public static void shellSort(int[] arr) {
int i, j, h;
int r, temp;
int x = 0;
for (r = arr.length / 2; r >= 1; r /= 2) {
for (i = r; i < arr.length; i++) {
temp = arr[i];
j = i - r;
while (j >= 0 && temp < arr[j]) {
arr[j + r] = arr[j];
j -= r;
}
arr[j + r] = temp;
}
x++;
System.out.println("第" + x + "步排序结果");
for (int k = 0; k < arr.length; k++) {
System.out.print(" " + arr[k]);
}
System.out.print("\n");
}
}
// 合并排序
static void mergeOne(int a[], int b[], int n, int len) {
int i, j, k, s, e;
s = 0;
while (s + len < n) {
e = s + 2 * len - 1;
if (e >= n) {
e = n - 1;
}
k = s;
i = s;
j = s + len;
while (i < s + len && j <= e) {
if (a[i] <= a[j]) {
b[k++] = a[i++];
} else {
b[k++] = a[j++];
}
}
while (i < s + len) {
b[k++] = a[i++];
}
while (j <= e) {
b[k++] = a[j++];
}
s = e + 1;
}
if (s < n) {
for (; s < n; s++) {
b[s] = a[s];
}
}
}
static void mergeSort(int a[], int n) {
int h, count, len, f;
count = 0;
len = 1;
f = 0;
int[] p = new int[n];
while (len < n) {
if (f == 1) {
mergeOne(p, a, n, len);
} else {
mergeOne(a, p, n, len);
}
len = len * 2;
f = 1 - f;
count++;
System.out.println("第" + count + "步排序结果");
for (int k = 0; k < a.length; k++) {
System.out.print(" " + a[k]);
}
System.out.print("\n");
}
}
// 快速排序
static void quickSort(int[] arr, int left, int right) {
int f, t;
int rtemp, ltemp;
ltemp = left;
rtemp = right;
f = arr[(left + right) / 2];// 分界值
while (ltemp < rtemp) {
while (arr[ltemp] < f) {
++ltemp;
}
while (arr[rtemp] > f) {
--rtemp;
}
if (ltemp <= rtemp) {
t = arr[ltemp];
arr[ltemp] = arr[rtemp];
arr[rtemp] = t;
--rtemp;
++ltemp;
}
}
if (ltemp == rtemp) {
ltemp++;
}
if (left < rtemp) {
quickSort(arr, left, ltemp - 1);
}
if (ltemp > right) {
quickSort(arr, rtemp + 1, right);
}
}
// 冒泡排序
static void bubbleSort(int[] a) {
int temp;
for (int i = 1; i < a.length; i++) {
for (int j = 0; j < a.length - i; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
System.out.println("第" + i + "步排序结果");
for (int k = 0; k < a.length; k++) {
System.out.print(" " + a[k]);
}
System.out.print("\n");
}
}
// 选择排序
static void selectSort(int[] a) {
int index, temp;
for (int i = 0; i < a.length - 1; i++) {
index = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[index]) {
index = j;// 记录最小值
}
}
if (index != i) {
temp = a[i];
a[i] = a[index];
a[index] = temp;
}
System.out.print("第" + i + "步排序结果:");
for (int k = 0; k < a.length; k++) {
System.out.print(" " + a[k]);
}
System.out.print("\n");
}
}
// 输出
static void print(int arr[]) {
System.out.println("排序后的数组为:");
for (int i = 0; i < size; i++) {
System.out.print(arr[i] + " ");
}
}
public static void main(String[] args) {
int shuzu[]=new int[size];
int i;
for( i=0;i<size;i++){
shuzu[i]=(int)(100+Math.random()*(100+1));
}
System.out.println("输出排序前的数组");
for(i=0;i<size;i++){
System.out.print(shuzu[i]+" ");
}
System.out.print("\n");
System.out.println("---------------------插入排序-----------------");
long start1Time=System.currentTimeMillis();
insertSort(shuzu);
print(shuzu);
long end1Time=System.currentTimeMillis();
System.out.println("运行时间:"+(end1Time-start1Time)+"ms");
System.out.println("---------------------shell排序---------------");
long start2Time=System.currentTimeMillis();
shellSort(shuzu);
print(shuzu);
long end2Time=System.currentTimeMillis();
System.out.println("运行时间:"+(end2Time-start2Time)+"ms");
System.out.println("-----------------------合并排序---------------");
long start3Time=System.currentTimeMillis();
mergeSort(shuzu,size);
print(shuzu);
long end3Time=System.currentTimeMillis();
System.out.println("运行时间:"+(end3Time-start3Time)+"ms");
System.out.println("---------------------快速排序---------------");
long start4Time=System.currentTimeMillis();
quickSort(shuzu,0,size-1);
print(shuzu);
long end4Time=System.currentTimeMillis();
System.out.println("运行时间:"+(end4Time-start4Time)+"ms");
System.out.println("---------------------冒泡排序---------------");
long start5Time=System.currentTimeMillis();
bubbleSort(shuzu);
print(shuzu);
long end5Time=System.currentTimeMillis();
System.out.println("运行时间:"+(end5Time-start5Time)+"ms");
System.out.println("---------------------选择排序---------------");
long start6Time=System.currentTimeMillis();
selectSort(shuzu);
print(shuzu);
long end6Time=System.currentTimeMillis();
System.out.println("运行时间:"+(end6Time-start6Time)+"ms");
}
}
其中的size可自行确定,当然数据越大,其运行时间长短越明显