java 算法

排序算法
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;
  

  }
  }