java經常使用算法

1. 快速排序

平均時間複雜度爲O（n×log（n））

package com.young4j.sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int i;
        int a[] = { 30, 40, 60, 10, 20, 50 };

        System.out.printf("before sort:");
        for (i = 0; i < a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");

        quickSort(a, 0, a.length - 1);

        System.out.printf("after  sort:");
        for (i = 0; i < a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");
    }


    /*
     * 快速排序
     *
     * 參數說明： a -- 待排序的數組 l -- 數組的左邊界(例如，從起始位置開始排序，則l=0) r --
     * 數組的右邊界(例如，排序截至到數組末尾，則r=a.length-1)
     */
    public static void quickSort(int[] a, int l, int r) {

        if (l < r) {
            int i, j, x;

            i = l;
            j = r;
            x = a[i];
            while (i < j) {
                while (i < j && a[j] > x)
                    j--; // 從右向左找第一個小於x的數
                if (i < j)
                    a[i++] = a[j];
                while (i < j && a[i] < x)
                    i++; // 從左向右找第一個大於x的數
                if (i < j)
                    a[j--] = a[i];
            }
            a[i] = x;
            quickSort(a, l, i - 1); /* 遞歸調用 */
            quickSort(a, i + 1, r); /* 遞歸調用 */
        }
    }
}

2. 冒泡排序

平均時間複雜度爲O(n²)

package com.young4j.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 * 
 * 依次比較相鄰的兩個數，若是第一個大於第二個，就交換他們的位置，
 * 將小數放在前邊，大數放到後邊。
 * 
 * 第一趟冒泡完畢後，最後一個數必定是數組中最大的一個數，
 * 因此最後一趟冒泡時最後一個數不參與，以此類推。
 * 
 * N個數字要排序完成，總共進行N-1趟排序，
 * 每i趟的排序次數爲(N-i)次，因此能夠用雙重循環語句，
 * 外層控制循環多少趟，內層控制每一趟的循環次數。
 * 
 * 每進行一趟排序，就會少比較一次，
 * 由於每進行一趟排序都會找出一個較大值。
 * 
 * 時間複雜度：
 * 若是咱們的數據正序，只須要走一趟便可完成排序。
 * 所需的比較次數C和記錄移動次數M均達到最小值，
 * 即：Cmin=n-1;Mmin=0;因此，
 * 冒泡排序最好的時間複雜度爲O(n)。
 * 若是很不幸咱們的數據是反序的，則須要進行n-1趟排序。
 * 每趟排序要進行n-i次比較(1≤i≤n-1)，
 * 且每次比較都必須移動記錄三次來達到交換記錄位置。
 * 在這種狀況下，比較和移動次數均達到最大值：
 * 最壞時間複雜度爲：O(n2) 
 * @author 程序員的365
 *
 */
public class BubbleSort {
    public static void main(String[] args) {
        int [] numbers = {3,4,6,1,8};
        bubbleSort(numbers);
    }
    public static void bubbleSort(int[] numbers) {
        int temp = 0;
        int size = numbers.length;
        for(int i = 0; i< size - 1; i ++) {
            for(int j = 0; j < size -1 -i; j ++) {
                if(numbers[j] > numbers[j + 1]) {
                    temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }
        Arrays.stream(numbers).forEach(n -> System.out.println(n));
    }
}

 

 

3. 插入排序

 

package com.young4j.sort;
/**
 * 直接插入排序
 * 
 * 插入排序就是將當前待排序的元素插入到一個已經排序好的列表裏。比較形象的例子就是右手抓取一張撲克，將它
 * 插入到左手拿着的排序好的一堆撲克裏邊。時間複雜度爲O(n2)，空間複雜度O(1)，並非最優的排序算法，特色爲：簡單，無需額外存儲空間。
 * 若是元素包含的內容過大，就不適合直接插入排序，由於直接插入排序須要移動元素的次數比較多.
 * 
 * 基本思想：
 * 將n哥待排序的元素當作一個有序列表和一個無序列表，開始有序列表中只有一個元素，無序列表中有n-1個元素。
 * 每次從無序列表中取出第一個元素，將它插入到有序列表中，使之成爲新的有序列表，重複n-1次完成整個排序。
 * @author YF
 *
 */

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class InsertionSort {
    Logger logger = LoggerFactory.getLogger(this.getClass());
    public static void main(String[] args) {
        int a[] = {31,25,78,12,41,19,6,1};
        new InsertionSort().insertionSort(a);
    }
    /**
     * 直接插入排序算法
     * @param args
     */
    private void insertionSort(int [] args) {
        logger.info("--------------------------直接插入排序算法--------------------------");
        int n = args.length;
        int i,j;
        for(i = 1;i < n;i ++) {
            //本次排序待插入有序列表中的元素
            int temp = args[i];
            //將temp插入有序列表中正確的位置,從後往前循環，將大於待插入的數向後移動
            for(j = i - 1;j >= 0 && args[j] > temp;j --) {
                //將待插入元素後移，爲插入temp作準備
                args[j + 1] = args[j];
            }
            //插入temp
            args[j + 1] = temp;
            print(args,n,i);
        }
         printResult(args,n);
    }
    /**
     * 打印排序的最終結果
     * @param a
     * @param n
     */
    private void printResult(int[] a, int n){
        System.out.print("最終排序結果：");
        for(int j=0;j<n;j++){
            System.out.print(" "+a[j]);
        }
        System.out.println();
    }
    /**
     * 打印排序的每次循環的結果
     * @param a
     * @param n
     * @param i
     */
    private void print(int[] a, int n, int i) {
        // TODO Auto-generated method stub
        System.out.print("第"+i+"次：");
        for(int j=0;j<n;j++){
            System.out.print(" "+a[j]);
        }
        System.out.println();
    }
    
}

 

 

4.二分查找

二分查找平均時間複雜度O(log2n)

package com.young4j.search;

import java.util.Arrays;

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr={5,3,6,1,9,8,2,4,7};
        bubleSort(arr);
        Arrays.stream(arr).forEach(n -> System.out.println(n));
        
    }
    /**
     * 冒泡排序
     * 1.若是咱們的數據正序，只須要走一趟便可完成排序。所需的比較次數C和記錄移動次數M均達到最小值，即：Cmin=n-1;Mmin=0;因此，冒泡排序最好的時間複雜度爲O(n)。
     * 2.若是很不幸咱們的數據是反序的，則須要進行n-1趟排序。每趟排序要進行n-i次比較(1≤i≤n-1)，且每次比較都必須移動記錄三次來達到交換記錄位置。在這種狀況下，比較和移動次數均達到最大值：
     * @param arr
     * @return
     */
    public static void bubleSort(int[] arr) {
        int temp = 0;
        for(int i = 0; i < arr.length - 1; i ++) {
            for(int j = 0; j < arr.length - 1 -i; j ++) {
                if(arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j]     = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    public static int binarySearch(int[] arr,int num) {
        int low = 0;
        int upper = arr.length - 1;
        while(low <= upper) {
            int mid = (low + upper) / 2;
            if(num > arr[mid]) {
                low = mid + 1;
            }else if(num < arr[mid]) {
                upper = mid - 1;
            }else {
                return arr[mid];
            }
        }
        return -1;
    }
}