剑指Offer---简单算法

原来极客学院已经有了

  • two-sum
    给定一个整数数组,找到2个数字,这样他们就可以添加到一个特定的目标号。功能twosum应该返回两个数字,他们总计达目标数,其中index1必须小于index2。请注意,你的答案返回(包括指数和指数)不为零的基础。你可以假设每个输入都有一个解决方案。 输入数字numbers= { 2,7,11,15 },目标= 9输出:index1 = 1,index2= 2
 public int[] twoSum(int[] numbers, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < numbers.length; i++){
            //发现target的另一个加数
            if(map.get(numbers[i]) != null){
                int[] result = {map.get(numbers[i]) + 1, i+1};//index+1
                return result;
            }else {
               //numbers[i]为第一个加数,map的key为target的另一个加数,value为数组的index
                map.put(target - numbers[i], i);
            }
        }
        int[] result = {};
        return result;
    }
结果输出:result=1//2
  • 二维数组查找
    在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
    public boolean find(int[][] array,int target){
        int rows=array.length;
        int columns=array[0].length;
        if(rows> 0 && columns > 0){
            int row=0;
            int column=columns-1;
            while(row >= 0){
                int value=array[row][column];
                if(value == target){
                    return true;
                }else if(value < target){
                    row++;
                }else if(value > target){
                    column--;
                }
            }
        }
        return false;
    }
查找结果:
int[][] nums={{1,2,3},{4,5,6},{7,8,9}};
int target=8;
result=true;
  • 打印1到最大的n位数
    输入数字n,按顺序打印出从1最大的n位十进制数。比如输入3,则打印出1、2、3一直到最大的3位数即999。
/** 
     * 输入数字n,按顺序打印出从1最大的n位十进制数。比如输入3,则打印出1、2、3 一直到最大的3位数即999。 
     * 
     * @param n 数字的最大位数 
     */  
    public static void printOneToNthDigits(int n) {  
        // 输入的数字不能为小于1  
        if (n < 1) {  
            throw new RuntimeException("The input number must larger than 0");  
        }  
        // 创建一个数组用于打存放值  
        int[] arr = new int[n];  
        printOneToNthDigits(0, arr);  
    }  
    /** 
     * 输入数字n,按顺序打印出从1最大的n位十进制数。 
     * 
     * @param n   当前处理的是第个元素,从0开始计数 
     * @param arr 存放结果的数组 
     */  
    public static void printOneToNthDigits(int n, int[] arr) {  
        // 说明所有的数据排列选择已经处理完了  
        if (n >= arr.length) {  
            // 可以输入数组的值  
            printArray(arr);  
        } else {  
            // 对  
            for (int i = 0; i <= 9; i++) {  
                arr[n] = i;  
                printOneToNthDigits(n + 1, arr);  
            }  
        }  
    }  
    /** 
     * 输入数组的元素,从左到右,从第一个非0值到开始输出到最后的元素。 
     * 
     * @param arr 要输出的数组 
     */  
    public static void printArray(int[] arr) {  
        // 找第一个非0的元素  
        int index = 0;  
        while (index < arr.length && arr[index] == 0) {  
            index++;  
        }  
        // 从第一个非0值到开始输出到最后的元素。  
        for (int i = index; i < arr.length; i++) {  
            System.out.print(arr[i]);  
        }  
        // 条件成立说明数组中有非零元素,所以需要换行  
        if (index < arr.length) {  
            System.out.println();  
        }  
    }  
  • 查找字符串第一个不重复字符 abbcdd-----> c
public void getCharByStr(String str){
        LinkedHashMap<Character,Integer> map=new LinkedHashMap<>(str.length());//保证插入顺序和输出顺序一致
        for(char c:str.toCharArray()){
            map.put(c,map.containsKey(c)?map.get(c)+1:1);
        }
        for(Map.Entry<Character,Integer> entry : map.entrySet()){
            if(entry.getValue() == 1){
                System.out.print(entry.getKey());
            }
        }
    }
  • 快速排序
    算法规则: 本质来说,快速排序的过程就是不断地将无序元素集递归分割,一直到所有的分区只包含一个元素为止。
    由于快速排序是一种分治算法,我们可以用分治思想将快排分为三个步骤:
    1.分:设定一个分割值,并根据它将数据分为两部分
    2.治:分别在两部分用递归的方式,继续使用快速排序法
    3.合:对分割的部分排序直到完成
 public int dividerAndChange(int[] args, int start, int end) {
//一般以数组第一个元素为分割值start=0
        int key = args[start];
        while (start < end) {
            //从后往前找,小于分割值的索引
            while (start < end && args[end] >= key) {
                end--;
            }
           //然后进行交换
            if (start < end) {
                swap(args, start, end);
            }
            //从前往后找,大于分割值的索引
            while (start < end && args[start] < key) {
                start++;
            }
            if (start < end) {
                swap(args, start, end);
            }
        }
       //此时start应非0,将数组分割成两部分
        args[start] = key;
        return start;
    }
    
    private void swap(int[] args, int start, int end) {
        //交换
        int temp = args[start];
        args[start] = args[end];
        args[end] = temp;
    }
    
    public void sort(int[] args, int start, int end) {
        if (end - start > 1) {//分治的元素大于1才有意义
            int mid = dividerAndChange(args, start, end);
            sort(args, start, mid);//前半部分
            sort(args, mid + 1, end);//后半部分
        }
    }

推荐阅读更多精彩内容

  • 回溯算法 回溯法:也称为试探法,它并不考虑问题规模的大小,而是从问题的最明显的最小规模开始逐步求解出可能的答案,并...
    fredal阅读 11,702评论 0 87
  • 背景 一年多以前我在知乎上答了有关LeetCode的问题, 分享了一些自己做题目的经验。 张土汪:刷leetcod...
    土汪阅读 11,306评论 0 33
  • Java经典问题算法大全 /*【程序1】 题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子...
    江湖宇阅读 1,187评论 0 2
  • 打开此篇文章的人先回答我一个问题:“你被暧昧过吗?” 那些突如其来的关怀,那些适时的提携帮衬,那些有意无意的试探,...
    沉默的陌生人阅读 376评论 0 2
  • 一年前的那天,他們又在旅道上遭遇衝著狩雲霄而來的殺手。 自從半是強硬跟著狩雲霄後,吃個飯突然有人翻桌這種奇遇也成為...
    燁烆es阅读 69评论 0 0