## 常见算法

常见算法

二分查找算法

• 查找索引

 int[] num = new int[20];
        int target;
       //查找索引
        int left = 0,right =num.length-1;
        while(left <= right){
            int mid = left +(right-left)/2;
            if(num[mid] == target){
                return mid;
            }
            else if(num[mid] < target){
                left = mid +1;
            }
            else if(num[mid] > target){
                right = mid-1;
            }
        }
        return -1;

• 查找左边界

 int[] num = new int[20];
        int target;
       //查找左边界
        int left = 0,right =num.length;
        while(left < right){
            int mid = left +(right-left)/2;
            if(num[mid] == target){
                right = mid;
            }
            else if(num[mid] < target){
                left = mid +1;
            }
            else if(num[mid] > target){
                right = mid;
            }
        }
        return left;

• 查找右边界

 int[] num = new int[20];
        int target;
       //查找右边界
        int left = 0,right =num.length;
        while(left < right){
            int mid = left +(right-left)/2;
            if(num[mid] == target){
                left = mid+1;
            }
            else if(num[mid] < target){
                left = mid +1;
            }
            else if(num[mid] > target){
                right = mid;
            }
        }
        return left-1;

冒泡排序算法

• 依次比较相邻的两个元素，如果左边的元素大于右边的，就交换，直到没有相邻的元素需要交换位置

 private int[] array(int[] arr){
        int len = arr.length;
        for (int i = 1; i <arr.length ; i++) {
            for (int j = 0;j<arr.length;j++){
                int temp;
                if(arr[j]>arr[j+1]){
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

插入排序算法

• 讲一个数据插入已经排序好的序列中，从而得到一个新的有序数据

  public static int[] arrs(int[] arr){
        int len = arr.length;
        for (int i = 1;i<len;i++){
            int temp = arr[i];
            int j ;
            for( j = i-1;j>=0;j--){
                if(temp>arr[j]){
                    break;
                }else{
                    arr[j+1] = arr[j];
                }
            }
            arr[j+1] = temp;
        }
        return arr;
    }

快速排序算法

• 设定一个基准值，通常为第一个数，然后从右边开始扫描，找出第一个小于基准值的数，交换位置，然后从左边开始，找到第一个大于基准值的数，交换位置，知道左右指针相遇。然后递归排序基准值前的数组和基准值后的数组。

 public static int[] arrs(int[] arr,int left,int right){
        int begin = left,end = right;
        int mid = arr[left];
        while(left<right){
            while (left<right && arr[right]>=mid)right--;
            if(arr[right]<mid){
                int temp1 = arr[right];
                arr[right] = arr[left];
                arr[left] = temp1;
            }
            while(left<right&& arr[left]<=mid)left++;
            if(arr[left]>mid){
                int temp2 = arr[left];
                arr[left] = arr[right];
                arr[right] = temp2;
            }

            if(left>begin)arrs(arr, begin, left-1);
            if(right<end)arrs(arr, right+1, end);

        }
        return arr;
    }