剑指offer(四)

概述

　　继续刷题，本篇算法主要偏向字符串和数组部分

第二十五题

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

解题思路

　　第一种思路：下面的思路为牛客网上以为朋友给出的，这个思路挺好，不过不容易想到，我也没有想到，我是通过使用map实现的。

 　　第二种思路：把链表中每一个节点都保存在map中，做好源节点和拷贝节点的映射，就很容易解决。

代码

import java.util.Map;
import java.util.HashMap;
public class Solution {
    public RandomListNode Clone(RandomListNode pHead){
        
        RandomListNode node = pHead;
        Map<RandomListNode,RandomListNode> map = new HashMap();
        while(node != null){
            RandomListNode newNode = new RandomListNode(node.label);
            map.put(node,newNode);
            node = node.next;
        }
        
        RandomListNode node1 = pHead;
        while(node1 != null){
            RandomListNode newNode = map.get(node1);
            newNode.next = map.get(node1.next);
            newNode.random = map.get(node1.random);
            node1 = node1.next;
        }
        return map.get(pHead);
    }
}

第二十六题

　　

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

解题思路：这个题其实通过中序遍历这颗二叉树，就可以实现题中要求的排序功能，因为这个二叉树是一个二叉搜索树，至于改成一个双向链表，这个只要改一下指针的方向就可以了。

代码

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
import java.util.Stack;
public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null){
            return null;
        }
        Stack<TreeNode> stack = new Stack();
        stack.add(pRootOfTree);
        
        TreeNode temp = pRootOfTree;
        TreeNode temp1 = null;
        TreeNode root = null;
        TreeNode temp2 = null;
        
        while(!stack.isEmpty()){
            if(temp != null && temp.left != null){
                stack.push(temp.left);
                temp = temp.left;
            }else{
                temp = stack.pop();
                temp.left = temp1;
                //temp2 = temp;
                if(temp1 != null){
                    temp1.right = temp;
                }else{
　　　　　　　　　　　　//记录头结点
                    root = temp;
                }
                
                temp1 = temp;
                if(temp.right != null){
                    stack.push(temp.right);
                    temp = temp.right;
                }else{
                    temp = null;
                }
            }
        }
        return root;
    }
}

 第二十七题

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

解题思路：这个题其实要做出来很容易，难的是怎么使用最低的时间复杂度做出来，我之前想过一种思路，具体的做法如下：

第一步：从头开始，让a，分别和b,c交换，结果为bac,bca

第二步：依然从头开始，这时的字符串是bca,经过交换之后可以获得cba,cab

第三步：重复以上过程获得acb,abc，大家可以发现经过上面的过程abc又变成了abc，是不是很神奇

第二种思路，这个思路来自于牛客网，使用递归来实现

 这个思路的递归是怎么用的呢？如下

第一步：先固定好第一个字母，比如字符串中有5个不同的字符，那第一次就要把字符串分成5中情况

第二步：有了第一步之后，相当于第一个字母已经搞定了，那就搞定第二个字母，让他也有这么多种的排列组合

。。。

第n步：直到最后一个字母

总结：通过递归的方式思路很容易明白，但是代码写起来没有那么容易，通过我想的那种方式我觉得挺好，时间复杂度也挺好。

代码

public class AllCombinationString {

    public static String str = "abcd";

    public static void allCombination(){
        char[] chars = str.toCharArray();
        //防止字符串中有重复字符导致相同的组合
        Set<String> set = new HashSet<>();
        //思路就是每次从头开始交换，第一个元素和第二个，然后和第三个元素交换
        //当所有的交换一遍之后，就把所有可能的结果拿到了
        for (int i = 0; i < chars.length; i++) {
            int j=0;
            while(j+1 < chars.length){
                swap(chars,j,j+1);
                set.add(String.valueOf(chars));
                j++;
            }
        }
        for (String s:set) {
            System.out.println(s);
        }
    }

    public static void swap(char[] array, int i, int j){
        if (i == j){
            return;
        }
        char temp = array[i];
        array[i] = array[j];
        array[j] = temp;

    }

    public static void main(String[] args) {
        allCombination();
    }
}

第二十八题

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

解题思路：这个题我是使用了最简单的实现方式，就是统计每个数字出现的次数，然后看哪个超过一半，有点原始，不过我觉得思路很清晰。

代码

import java.util.Map;
import java.util.HashMap;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if (array.length == 1){
            return array[0];
        }
        Map<Integer,Integer> map = new HashMap();
    
        
        Integer temp;
        for(int i = 0;i< array.length;i++){
            temp = map.get(array[i]);
            if(temp == null){
                map.put(array[i],1);
            }else{
                if(temp+1 > array.length/2){
                    return array[i];
                }
                map.put(array[i],temp+1);
            }
        }
        return 0;
    
    }
}

第二十九题

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

解题思路：看牛客网上思路最多的就是把k个数放到list中，然后遍历数据，每次和list中的最大的数进行比较，如果大于这个数，不处理，如果小于list中的最大数，那就需要把最大的数给替换掉，这个思路最大的开销就是每次都要找list中的最大数，时间复杂度相当于O(nk),我使用了一种优化的方式，先把list排好序，list中采用二分查找法，把每个数字放到list中的正确位置，保证list一直是有序的

代码

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
         ArrayList<Integer> list = new ArrayList();
        if(k <= 0 || k > input.length){
            return list;
        }
        
        for(int i = 0;i < k;i++){
            list.add(i,input[i]);
        }
        list.sort((o1,o2)-> o1-o2);
        
        for(int j = k;j<input.length;j++){
            if(input[j] >= list.get(k-1)){
                continue;
            }else{
　　　　　　　　　　//使用二分查找法找到这个数在列表中的相对位置
                int result = binarySearch(list,input[j]);
　　　　　　　　　//把列表中的最后一个元素移除，最后一个是最大的元素
                list.remove(k-1);
                list.add(result,input[j]);
            }
        }
        
        return list;
    }
    //这段代码写的太长了，其实二分查找发一般由于判断在数组中是否存在这个数，判断位置就比较麻烦了
    public static int binarySearch(ArrayList<Integer> list, int value){
        int start = 0;
        int end = list.size()-1;
        int mid = end/2;
        while(end>=start){
            if(end == start){
                if (list.get(start) < value){
                    return start+1;
                }
                return start;
            }
            if(value > list.get(mid)){
                start = mid + 1;
                if (start > end){
                    return end;
                }
            }else if(value < list.get(mid)){
                end = mid - 1;
                if (end < start){
                    return start;
                }
            }else{
                return mid;
            }
            mid = (start + end)/2;
        }

        return -1;
    }
}

第三十题

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,
问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。
给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

解题思路：这道题是求数组的子数组元素的最大和，在牛客网上看到一个牛逼的解决办法，就是如果遇见的是负数，就找负数中最大的，如果是正数就加和，其实我自己的实现也是这个思路，不过我的实现太过复杂。

代码

大佬的实现

链接：https://www.nowcoder.com/questionTerminal/459bd355da1549fa8a49e350bf3df484
来源：牛客网

public class Solution {
     public int FindGreatestSumOfSubArray(int[] array) {
         if (array.length==0 || array==null) {
             return 0;
         }
         int curSum=0;
         int greatestSum=0x80000000;
         for (int i = 0; i < array.length; i++) {
             if (curSum<=0) {
                 curSum=array[i]; //记录当前最大值
             }else {
                 curSum+=array[i]; //当array[i]为正数时，加上之前的最大值并更新最大值。
             }
             if (curSum>greatestSum) {
                 greatestSum=curSum; 
             }
         }
         return greatestSum;
     }
 }

我的实现

import java.util.ArrayList;
public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        if(array == null || array.length == 0){
            return 0;
        }

        ArrayList<Integer> list = new ArrayList();
        int sum = 0;
        int z = 0;
        int f = 0;

        int fMin = array[0];
        for(int i = 0;i < array.length;i++){
            //标记从正数开始还是从负数开始
            if(z == 0 && f == 0){
                if(array[i] < 0){
                    if (array[i] > fMin){
                        fMin = array[i];
                    }
                    if (i == array.length-1){
                        list.add(fMin);
                    }
                    continue;
                }
            }
            if(array[i] > 0){
                if( f == 0){
                    z = z + array[i];
                    if (i == array.length-1){
                    list.add(sum + z);
                    }
                }else{
                    list.add(sum+z);

                    if(z + f > 0){
                        sum = sum + z + f;
                    }else{
                        sum = 0;
                    }
                    z = array[i];
                    f = 0;
                }
            }else{
                f = f + array[i];
                if (i == array.length-1){
                    list.add(sum + z);
                }
            }
        }

        Integer max = list.get(0);
        for(int i = 0;i < list.size();i++){
            if(list.get(i) > max){
                max = list.get(i);
            }
        }
        return max;
    }
}

第三十一题

求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。
ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

解题思路：这个题很简单，就不说了

代码

import java.lang.String;
public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
        int count = 0;
        char flag = '1';
        for(int i = 1;i <= n;i++){
            for(char c:String.valueOf(i).toCharArray()){
                if(c == flag){
                    count++;
                    }
            }
        }
        return count;
    }
}

第三十二题

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

解题思路：这个题在牛客上看到一个很强的解题思路，一开始我想这个的时候，觉得要自己写一个while循环，一个一个元素互相比较，找出字符排列中最符合要求的，然后这样就可以实现最小的组合，但是这样一轮循环只能找到一个合适的元素，这个时间复杂度是n*(n-1)*(n-2)...1,然后我看到牛客上有人通过使用List集合自带的排序方法sort来实现的，其实排序也是两两比较，时间复杂度是nlog(n)

代码

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public static String PrintMinNumber(int [] numbers) {
        StringBuilder result = new StringBuilder();
        String[] str = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            str[i] = String.valueOf(numbers[i]);
        }

        Arrays.sort(str,(o1,o2)->{
            String temp1 = o1 + "" + o2;
            String temp2 = o2 + "" + o1;
　　　　　　　//String实现了compareTo方法，会比较对应字符的大小
            return temp1.compareTo(temp2);
        });

        for (int i = 0; i < str.length; i++) {
            result.append(str[i]);
        }

        return result.toString();
    }
}

总结

　　链表和树部分的题感觉偏难，数组和字符串部分的题觉得相对来说容易一些