算法二

//快速排序
    public void sort(int arr[], int low, int high) {
        int l = low;    //游标处在的位置是不稳定的位置 即不能够确定此处与标记的比较  l-1 必小于标记
        int h = high;   //游标处在的位置是不稳定的位置 即不能够确定此处与标记的比较  h+1 必大于标记
        int povit = arr[low];   //取出序列中头一个作为标记
        while (l < h) {                             //左右游标不断靠近，每次靠近一点就是将值按时候大于标记分开到两边，直到相等，说明这个位置就是这个标记的位置了。
            while (l < h && arr[h] >= povit) {       //右边游标开始向左查找，大于标记的的跳过，游标-1
                h--;
            }
            if (l < h) {                            //找到第一个小于的换到左边，并游标+1
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                l++;
            }
            while (l < h && arr[l] <= povit) {       //左侧游标向右查找，小于跳过，游标+1
                l++;
            }
            if (l < h) {                           //找到一个大于的就交换到右边。
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                h--;
            }
        }
        //最终l==h就是标记为所应该在的位置
        if (l > low) sort(arr, low, l - 1);     //递归左边
        if (h < high) sort(arr, l + 1, high);   //递归右边
    }

冒泡排序

public void popsort(int[] arr){
        for(int i= arr.length-1;i>0;i--){
                for(int j=0;j<i;j++){
                    if (arr[j] > arr[j+1]) {
                        int temp =arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
        }
    }

二分查找

int index;
    private int findNumber(int[] arr,int a,int b,int target){
            if(a>b){
                return -1;
            }
            int mid=(a+b)/2;
            if(arr[mid]<target){
                findNumber(arr,mid+1,b,target);
            }else if(arr[mid]>target){
                findNumber(arr,a,mid-1,target);
            }else if(arr[mid]==target){
                index = mid;
            }
            return index;
    }

字符串翻转

public static char[] ReverseByCharBuffer(char[] array, int start, int end) {
        for (int i = start; i < (end + start) / 2; i++) {
            char t = array[i];
            array[i] = array[start + end - i - 1];
            array[start + end - i - 1] = t;
        }
        return array;
    }

字符串由空格隔开翻转

public static char[] Reverse(char[] array) {
        ReverseByCharBuffer(array, 0, array.length);
        Log.i(TAG, "new String(array) =" + new String(array));
        int start = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == ' ') {
                ReverseByCharBuffer(array, start, i);
                start = i + 1;
            }
        }
        ReverseByCharBuffer(array, start, array.length);
        return array;
    }

查找只出现一次的字符的第一次出现的位置

分析：

第一次遍历字符串：将字符作为数组脚标，出现次数作为数组值，统计

第二次遍历字符串：找到第一个统计次数为 1的字符。

public int FirstNotRepeatingChar(String str) {
       char[] array = str.toCharArray();
        int[] counts = new int[256];
        //初始化计数数组
        for (int i = 0; i < 256; i++) {
            counts[i] = 0;
        }
        //第一次遍历，将每一个字符的出现次数统计
        for (int i = 0; i < array.length; i++) {
            ++counts[array[i]];
        }
        //第二次遍历，找到最先出现1次的字符
        for (int i = 0; i < array.length; i++) {
            //当前字符统计数为1
            if (counts[array[i]] == 1) {
                return i;
            }
        }
        return -1;
    }