剑指offer题解26-30(Java)

26.二叉搜索树与双向链表*

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

代码

public class Solution {
    TreeNode head = null;
    TreeNode realHead = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        ConvertSub(pRootOfTree);
        return realHead;
    }
     
    private void ConvertSub(TreeNode pRootOfTree) {
        if(pRootOfTree==null) return;
        ConvertSub(pRootOfTree.left);
        if (head == null) {
            head = pRootOfTree;
            realHead = pRootOfTree;
        } else {
            head.right = pRootOfTree;
            pRootOfTree.left = head;
            head = pRootOfTree;
        }
        ConvertSub(pRootOfTree.right);
    }
}

27.字符串排列

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

输入描述:

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

代码

典型的dfs

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

public class Solution {
    ArrayList<String> ans;
    int[] vis;
    char[] res;
    int len;
    char[] c;

    public void dfs(int cur) {
        if (cur == len) {
            if (!ans.contains(String.valueOf(res))) {
              //为了避免重复，先判断是否有相同的字符串
                ans.add(String.valueOf(res));
            }
            return;
        }
        for (int i = 0; i < len; i++) {
            if (vis[i] == 0 && res[cur] == '1') {
                vis[i] = 1;
                res[cur] = c[i];
                dfs(cur + 1);
                vis[i] = 0;
                res[cur] = '1';
            }
        }
    }

    public ArrayList<String> Permutation(String str) {
        ans = new ArrayList<String>();
        len = str.length();
        if (len == 0) {
          //空字符串，直接返回空
            return ans;
        }
        c = str.toCharArray();
        vis = new int[len];
        res = new char[len];
        Arrays.fill(res, '1');
        dfs(0);
        return ans;


    }
}

28.数组中出现次数超过一半的数字

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

代码

import java.util.TreeMap;

public class Solution {
    public int MoreThanHalfNum_Solution(int[] array) {
        int len = array.length;
        int ans = 0;
        TreeMap<Integer, Integer> treeMap = new TreeMap<Integer, Integer>();

        for (int i = 0; i < len; i++) {
            if (treeMap.containsKey(array[i])) {
                treeMap.put(array[i], treeMap.get(array[i]) + 1);

            } else {
                treeMap.put(array[i], 1);
            }
            if ((treeMap.get(array[i])) > (len / 2)) {
                ans = array[i];
                break;
            }
        }
        return ans;
    }
}

29.最小的k个数

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

代码

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
        ArrayList<Integer> ans = new ArrayList<Integer>();

        int len = input.length;
        if (k > len || k <= 0) {
            //不在范围内，直接返回空
            return ans;
        }
        //选择排序，但是只选出前k个
        for (int i = 0; i < k; i++) {
            int min = Integer.MAX_VALUE;
            int index = 0;
            // 选出当前范围内最小的
            for (int j = 0; j < len - i; j++) {
                if (input[j] <= min) {
                    min = input[j];
                    index = j;

                }
            }
            //将最小值放在最后
            int temp = input[index];
            input[index] = input[len - i - 1];
            input[len - i - 1] = temp;
            //加入到ans
            ans.add(min);
        }
        return ans;
    }
}

30.连续子数组的最大和

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

代码

dp典型题

public class Solution {
    public static int FindGreatestSumOfSubArray(int[] array) {
        int len = array.length;
        int[][] mat = new int[len + 1][len + 1];
        int max = Integer.MIN_VALUE;
        for (int i = 1; i < len + 1; i++) {
            for (int j = i; j < len + 1; j++) {
                mat[j][i] = mat[j - 1][i] + array[j - 1];
                if (mat[j][i] > max) {
                    max = mat[j][i];
                }
            }
        }   
        return max;
    }
}