1. //数组线性查找
    2. String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
    3. String dest = "BB";
    4. boolean isFlag = true;
    5. for(int i = 0;i < arr.length;i++){
    6.     if(dest.equals(arr[i])){
    7.         sout("找到了元素");
    8.         isFlag = false;
    9.         break;
    10.     }
    11. }
    12. if(isFlag){
    13.      sout("没找到")   
    14. }
    1. //二分法查找
    2. //前提所要查找的数组必须有序
    3. int[] arr = new int[]{-12,-1,0,2,4,8,9,12,45,78,153,952};
    4. int dest = 4;
    5. int head = 0;//初始的首索引
    6. int end = arr.length - 1;//初始的末索引
    7. boolean isFlag = true;
    8. while(head <= end){
    9.     int middle = (head + end) / 2;
    10.     if(dest == arr[middle]){
    11.         sout("找到了指定元素");
    12.         isFlag = false;
    13.         break;
    14.     }else if(arr[middle] > dest){
    15.         end = middle -1;
    16.     }else{
    17.           head = middle + 1;
    18.     }
    19. }
    1. //冒泡排序
    3. int[] arr = new int[]{56,12,45,32,6545,213,45,123,45,20};
    5. for(int i = 0;i < arr.length - 1,i++){
    6.     for(int j = 0;j < arr.length - 1 - i;j++){
    7.         if(arr[j] > arr[j + 1]){
    8.             int temp = arr[j];
    9.             arr[j] = arr[j + 1];
    10.             arr[j + 1] = temp;
    11.         }
    12.     }
    13. }
    1. //快速排序
    2. public class QuickSort {
    3.     private static void swap(int[] data, int i, int j) {
    4.         int temp = data[i];
    5.         data[i] = data[j];
    6.         data[j] = temp;
    7.     }
    9.     private static void subSort(int[] data, int start, int end) {
    10.         if (start < end) {
    11.             int base = data[start];
    12.             int low = start;
    13.             int high = end + 1;
    14.             while (true) {
    15.                 while (low < end && data[++low] - base <= 0)
    16.                     ;
    17.                 while (high > start && data[--high] - base >= 0)
    18.                     ;
    19.                 if (low < high) {
    20.                     swap(data, low, high);
    21.                 } else {
    22.                     break;
    23.                 }
    24.             }
    25.             swap(data, start, high);
    27.             subSort(data, start, high - 1);//递归调用
    28.             subSort(data, high + 1, end);
    29.         }
    30.     }
    31.     public static void quickSort(int[] data){
    32.         subSort(data,0,data.length-1);
    33.     }
    36.     public static void main(String[] args) {
    37.         int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
    38.         System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
    39.         quickSort(data);
    40.         System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    41.     }
    42. }