八种排序算法的运行时间比较（附代码）

最新推荐文章于 2021-05-22 17:40:29 发布

北岸长风

最新推荐文章于 2021-05-22 17:40:29 发布

阅读量4.8k

点赞数 2

文章标签：排序算法算法

本文链接：https://blog.csdn.net/qq_36070644/article/details/104376814

版权

算法的运行时间与cpu的性能相关，且存在误差，运行时长会有波动。
在这里插入图片描述
冒泡排序：

package sort;

import java.util.Arrays;
import java.util.Random;

public class 冒泡排序 {
 public static void main(String[] args) {
  System.out.println("冒泡排序算法");
  int array[] = rand();
  long start = System.currentTimeMillis();
  sort(array);
  long end = System.currentTimeMillis();
  System.out.print("运行时间:");
  System.out.println(end - start + "ms");
  System.out.println("算法时间复杂度:n^2");
 }
 
 public static int[] rand() {
  int n = new Random().nextInt(1) + 500000;
  System.out.println("数组长度:" + n);
  int a[] = new int[n];
  for (int i = 0; i < n; i++) {
   a[i] = new Random().nextInt(100) + 1;
  }
  return a;
 }
 
 public static void sort(int[] arr) {
  for (int i = arr.length - 1; i > 0; i--) {
   for (int j = 0; j < i; j++) {
    // 冒泡排序
    if (arr[j] > arr[j + 1]) {
     Swap(j, j + 1, arr);
    }
   }
  }
 }
 
 public static void Swap(int a, int b, int list[]) {
  int temp = list[a];
  list[a] = list[b];
  list[b] = temp;
 }
}

选择排序：


```java
package sort;

import java.util.Arrays;
import java.util.Random;

public class 选择排序 {
 public static void main(String[] args) {
  System.out.println("选择排序算法");
  int array[] = rand();
  long start = System.currentTimeMillis();
  sort(array);
  long end = System.currentTimeMillis();
  System.out.print("运行时间:");
  System.out.println(end - start + "ms");
  System.out.println("算法时间复杂度:n^2");
 }
 
 public static int[] rand() {
  int n = new Random().nextInt(1) + 500000;
  System.out.println("数组长度:" + n);
  int a[] = new int[n];
  for (int i = 0; i < n; i++) {
   a[i] = new Random().nextInt(100) + 1;
  }
  return a;
 }
 
 public static void sort(int[] arr) {
  for (int i = 0; i < arr.length; i++) {
   for (int j = i+1; j < arr.length; j++) {
       if(arr[j]<arr[i]){
        Swap(j,i,arr);
       }
   }
  }
 }
 
 public static void Swap(int a, int b, int list[]) {
  int temp = list[a];
  list[a] = list[b];
  list[b] = temp;
 }
}

插入排序：

package sort;

import java.util.Arrays;
import java.util.Random;

public class 插入排序 {
 public static void main(String[] args) {
  System.out.println("插入排序算法");
  int[] a = rand();
  System.out.print("运行时间:");
  long start=System.currentTimeMillis();
  insertsort(a);
  long end=System.currentTimeMillis();
  System.out.println(end-start+"ms");
  System.out.println("算法时间复杂度:n^2");
 }
 
 public static int[] rand() {
  int n = new Random().nextInt(1) + 500000;
  System.out.println("数组长度:" + n);
  int a[] = new int[n];
  for (int i = 0; i < n; i++) {
   a[i] = new Random().nextInt(100) + 1;
  }
  return a;
 }
 
 private static void insertsort(int[] arr) {
  int temp;
  for (int i = 1; i < arr.length; i++) {
   // 待排元素小于有序序列的最后一个元素时，向前插入
   if (arr[i] < arr[i - 1]) {
    temp = arr[i];
    for (int j = i; j >= 0; j--) {
     if (j > 0 && arr[j - 1] > temp) {
      arr[j] = arr[j - 1];
     } else {
      arr[j] = temp;
      break;
     }
    }
   }
  }
 }
}

快速排序：

package sort;

import java.util.Arrays;
import java.util.Random;

public class 快速排序 {
 public static void main(String[] args) {
  System.out.println("快速排序算法");
  int array[] = rand();
  long start = System.currentTimeMillis();
  quickSort(array, 0, array.length - 1);
  long end = System.currentTimeMillis();
  System.out.print("运行时间:");
  System.out.println(end - start + "ms");
  System.out.println("算法时间复杂度:nlogn");
  //System.out.println(Arrays.toString(array));
 }
 
 public static void quickSort(int[] a, int p, int r) {
  if (p < r) {
   int q = Partition(a, p, r);
   quickSort(a, p, q - 1);// 对左半段排序
   quickSort(a, q + 1, r);// 对右半段排序
  }
 }
 
 public static int Partition(int[] a, int p, int r) {
  int x = a[p];
  int i = p;
  int j = r + 1;
  // 将小于x的交换到左边区域，将大于x的交换到右边区域
  while (true) {
   while (a[++i] < x && i < r)
    ;
   while (a[--j] > x)
    ;
   if (i >= j) {
    break;
   }
   Swap(i, j, a);
   //System.out.println(Arrays.toString(a));
  }
  a[p] = a[j];
  a[j] = x;
  //System.out.println(Arrays.toString(a));
  return j;
 }
 
 public static void Swap(int a, int b, int list[]) {
  int temp = list[a];
  list[a] = list[b];
  list[b] = temp;
 }
 
 public static int[] rand() {
  int n = new Random().nextInt(1) + 500000;
  System.out.println("数组长度:" + n);
  int a[] = new int[n];
  for (int i = 0; i < n; i++) {
   a[i] = new Random().nextInt(100) + 1;
  }
  //System.out.println(Arrays.toString(a));
  return a;
 }
}

合并排序：

package sort;

import java.util.Arrays;
import java.util.Random;

public class 合并排序 {
 static int a[] = rand();
 static int b[] = new int[a.length];
 public static void main(String[] args) {
  long start = System.currentTimeMillis();
  Mergesort(a, 0, a.length - 1);
  long end = System.currentTimeMillis();
  System.out.print("运行时间:");
  System.out.println(end - start + "ms");
  System.out.println("算法时间复杂度:nlogn");
 }
 
 public static void Mergesort(int[] a, int left, int right) {
  if (left < right) {
   int mid = (left + right) / 2;
   Mergesort(a, left, mid);
   Mergesort(a, mid + 1, right);
   Merge(a, b, left, mid, right);
   copy(a, b, left, right);
   System.out.println(Arrays.toString(a));
  }
 }
 
 public static void Merge(int[] c, int[] d, int l, int m, int r) {
  int i = l;
  int j = m + 1;
  int k = l;
  while ((i <= m) && (j <= r)) {
   if (c[i] < c[j]) {
    d[k++] = c[i++];
   } else {
    d[k++] = c[j++];
   }
  }
  if (i > m) {
   for (int q = j; q <= r; q++) {
    d[k++] = c[q];
   }
  } else {
   for (int q = i; q <= m; q++) {
    d[k++] = c[q];
   }
  }
 }
 
 public static void copy(int[] c, int[] d, int l, int r) {
  for (int i = l; i <= r; i++) {
   c[i] = d[i];
  }
 }
 
 public static int[] rand() {
  int n = new Random().nextInt(1) + 10;
  System.out.println("合并排序算法");
  System.out.println("数组长度:" + n);
  int a[] = new int[n];
  for (int i = 0; i < n; i++) {
   a[i] = new Random().nextInt(20) + 1;
  }
  System.out.println(Arrays.toString(a)+"---原数组");
  return a;
 }
}

希尔排序：

package sort;
import java.util.Arrays;
import java.util.Random;
public class 希尔排序 {
 public static void main(String[] args) {
  System.out.println("希尔排序算法");
  int[] a = rand();
  long start = System.currentTimeMillis();
  shellsort(a, a.length);
  long end = System.currentTimeMillis();
  System.out.print("运行时间:");
  System.out.println(end - start + "ms");
  System.out.println("算法时间复杂度:nlogn");
 }
 public static int[] rand() {
  int n = new Random().nextInt(1) + 500000;
  System.out.println("数组长度:" + n);
  int a[] = new int[n];
  for (int i = 0; i < n; i++) {
   a[i] = new Random().nextInt(100) + 1;
  }
  return a;
 }
 private static void swap(int i, int j, int[] a) {
  int temp = a[i];
  a[i] = a[j];
  a[j] = temp;
 }
 public static void shellsort(int a[], int size) {
  int i, j, gap;
  for (gap = size / 2; gap > 0; gap /= 2) {
   for (i = gap; i < size; i++)
    for (j = i; j - gap >= 0 && a[j - gap] > a[j]; j -= gap)
     swap(j - gap, j, a);
  }
 }

堆排序：

package sort;

import java.util.Arrays;
import java.util.Random;

public class 堆排序 {
 public static void main(String[] args) {
  System.out.println("堆排序算法");
  int[] a = rand();
  long start=System.currentTimeMillis();
  heapSort(a);
  long end=System.currentTimeMillis();
  System.out.print("运行时间:");
  System.out.println(end-start+"ms");
  System.out.println("算法时间复杂度:nlogn");
 }
 
 public static int[] rand() {
  int n = new Random().nextInt(1) + 500000;
  System.out.println("数组长度:"+n);
  int a[] = new int[n];
  for (int i = 0; i < n; i++) {
   a[i] = new Random().nextInt(100) + 1;
  }
  //System.out.println(Arrays.toString(a));
  return a;
 }
 
 public static void heapSort(int[] arr) {
  int len = arr.length;
  buildMaxHeap(arr, len);
  for (int i = len - 1; i > 0; i--) {
   swap(arr, 0, i);
   len--;
   heapify(arr, 0, len);
  }
 }
 
 private static void buildMaxHeap(int[] arr, int len) {
  for (int i = (int) Math.floor(len / 2) - 1; i >= 0; i--) {
   heapify(arr, i, len);
  }
 }
 
 private static void heapify(int[] arr, int i, int len) {
  int left = 2 * i + 1;
  int right = 2 * i + 2;
  int largestIndex = i;
  if (left < len && arr[left] > arr[largestIndex]) {
   largestIndex = left;
  }
  if (right < len && arr[right] > arr[largestIndex]) {
   largestIndex = right;
  }
  if (largestIndex != i) {
   swap(arr, i, largestIndex);
   heapify(arr, largestIndex, len);
  }
 }
 
 private static void swap(int[] arr, int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
 }
}