zoukankan      html  css  js  c++  java
  • Basic Sort Algorithms

    1. Bubble Sort

    public void bubbleSort(int[] arr) {
      boolean swapped = true;
      int j = 0;
      int tmp;
      while (swapped) {
        swapped = false;
        j++;
        for (int i = 0; i < arr.length - j; i++) {
          if (arr[i] > arr[i + 1]) {
          tmp = arr[i];
          arr[i] = arr[i + 1];
          arr[i + 1] = tmp;
          swapped = true;
          }
        }
     }
    }

    Performance

    Worst case performance O(n^2)
    Best case performance O(n)
    Average case performance O(n^2)
    Worst case space complexity O(1) auxiliary

    2. Selection Sort

      public void doSelectionSort(int[] arr){ 
        for (int i = 0; i < arr.length - 1; i++){
          int index = i;
          for (int j = i + 1; j < arr.length; j++){
             if (arr[j] < arr[index]){
                index = j;
             }
          }
          int smallerNumber = arr[index]; 
          arr[index] = arr[i];
          arr[i] = smallerNumber;
       }
      }

    Performance

    Worst case performance О(n2)
    Best case performance О(n2)
    Average case performance О(n2)
    Worst case space complexity О(n) total, O(1) auxiliary

    3. Insertion Sort

    public static void insertionSort(int array[]) {
      int n = array.length;
      for (int j = 1; j < n; j++) {
        int key = array[j];
        int i = j-1;
        while ( (i > -1) && ( array [i] > key ) ) {
          array [i+1] = array [i];
          i--;
        }
        array[i+1] = key;
      }
    }

    Performance

    Worst case performance О(n2) comparisons, swaps
    Best case performance O(n) comparisons, O(1) swaps
    Average case performance О(n2) comparisons, swaps
    Worst case space complexity О(n) total, O(1) auxiliary

    Comparison:

    There’s probably no point in using the bubble sort, unless you don’t have your algorithm book handy. The bubble sort is so simple that you can write it from memory. Even so, it’s practical only if the amount of data is small.

    The selection sort minimizes the number of swaps, but the number of comparisons is still high. This sort might be useful when the amount of data is small and swapping data items is very time-consuming compared with comparing them. The insertion sort is the most versatile of the three and is the best bet in most situa- tions, assuming the amount of data is small or the data is almost sorted. For larger amounts of data, quicksort is generally considered the fastest approach.

    It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. However, insertion sort provides several advantages:

    We’ve compared the sorting algorithms in terms of speed. Another consideration for any algorithm is how much memory space it needs. All three of the algorithms in this chapter carry out their sort in place, meaning that, besides the initial array, very little extra memory is required. All the sorts require an extra variable to store an item temporarily while it’s being swapped.

  • 相关阅读:
    反射(五)之动态代理的作用
    反射(四)之反射在开发中的适用场景及利弊
    反射(三)之通过反射获取构造方法, 成员变量, 成员方法
    反射(二)之反射机制
    反射(一)之初探反射
    java多线程(五)之总结(转)
    java多线程(四)之同步机制
    java多线程(三)之售票案例
    java多线程(二)之实现Runnable接口
    java多线程(一)之继承Thread类
  • 原文地址:https://www.cnblogs.com/codingforum/p/6209330.html
Copyright © 2011-2022 走看看