java 算法

为什么80%的码农都做不了架构师？>>>   

排序算法

1 冒泡排序

长度为i的数组元素两两比较，不符合顺序，就交换两个元素的位置：

/**
 *  冒泡排序
 */
public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 4, 10, 5, 3, 2, 19, 23, 11};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }


    /**
     * 升序
     * @param arr
     */
    private static void sort(int[] arr){
        int temp;
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<i; j++){
                if(arr[i] < arr[j]){
                    temp = arr[i];
                    arr[i] =arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

}

2 快速排序

• 令索引 i从数列左方往右方查找，知道找到小于base的数
• 令索引 j从数列右方往左方查找，知道找到大于base的数
• 如果i<=j则交换i和j两处的值，如果i>j离开循环
• 如果start<j，对基数左边轴递归
• 如果end>i，对基数右边轴递归

package com.cary.serial;

import java.util.ArrayList;
import java.util.Arrays;

/**
 *  快速排序
 */
public class QuickSort {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 4, 10, 5, 3, 2, 19, 23, 11};
        sort(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 升序
     * @param arr
     */
    private static void sort(int[] arr, int start, int end){
        if(start < end){
            int base = arr[start];//以第一个元素为基准
            int i = start;
            int j = end;
            int temp;

            do{
                while(arr[i]<base && i<end)
                    i++;
                while(arr[j]>base && j>start)
                    j--;
                if(i <= j){
                    temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                    i++;
                    j--;
                }
            }while (i <= j);

            if(start < j){
                sort(arr, start, j);
            }
            if(i < end){
                sort(arr, i, end);
            }
        }
    }

}

3.选择排序

• 每次循环都遍历出数组中最小元素，记录索引值
• 通过索引值，将最小元素放到数组的最左边
• 对剩余未排序的元素数组再执行上述两个步骤

package com.cary.serial;

import java.util.Arrays;

/**
 *  选择排序
 */
public class SelectSort {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 4, 10, 5, 3, 2, 19, 23, 11};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 升序
     * @param arr
     */
    private static void sort(int[] arr){
        for(int i=0; i<arr.length; i++){
            int min = i;
            for(int j=i+1; j<arr.length; j++){
                if(arr[j] < arr[min]){
                    min = j;
                }
            }
            if(min != i){
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
    }

}

4 插入排序

/**  
     * 插入排序
     * 
     * 从第一个元素开始，该元素可以认为已经被排序
     * 取出下一个元素，在已经排序的元素序列中从后向前扫描 
     * 如果该元素（已排序）大于新元素，将该元素移到下一位置  
     * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置  
     * 将新元素插入到该位置中  
     * 重复步骤2  
     * @param numbers  待排序数组
     */  
    public static void insertSort(int[] numbers)
    {
    int size = numbers.length;
    int temp = 0 ;
    int j =  0;
    
    for(int i = 0 ; i < size ; i++)
    {
        temp = numbers[i];
        //假如temp比前面的值小，则将前面的值后移
        for(j = i ; j > 0 && temp < numbers[j-1] ; j --)
        {
        numbers[j] = numbers[j-1];
        }
        numbers[j] = temp;
    }
    }

 

查找算法

1.二分非递归查找

算法思想：又叫折半查找，要求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。

package com.cary.serial;

import java.util.Arrays;

/**
 *  二分查找
 */
public class BinarySearch {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 11, 15, 17, 18, 19, 23, 29};
        System.out.println(search(arr, 15));
    }

    private static int search(int[] arr, int number){
        int start = 0;
        int end = arr.length-1;
        while(start<=end){
            int middle = (start+end)/2;
            if(number==arr[middle]){
                return middle+1;
            } else if(number < arr[middle]){
                end = middle-1;
            } else {
                start = middle+1;
            }
        }
        return -1;
    }
}

2.二分递归查找

package com.cary.serial;

import java.util.Arrays;

/**
 *  二分查找
 */
public class BinarySearch {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 11, 15, 17, 18, 19, 23, 29};
        System.out.println(search(arr, 0, arr.length-1, 15));
    }


    private static int search(int[] arr,int start, int end, int number){
        if(start <= end){
            int middle = (start+end)/2;

            if(number == arr[middle]){
                return middle+1;
            } else if(number<arr[middle]){
                return search(arr, start, middle-1, number);
            } else {
                return search(arr, middle+1, end, number);
            }
        }
        return -1;
    }
}

转载于:https://my.oschina.net/kun123/blog/875587