剑指offer/26-30

26、二叉搜索树与双向链表

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

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val,Node _left,Node _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
import java.util.*;

public class Solution {
    TreeNode pre,head;
    public TreeNode Convert(TreeNode root) {
        if(root==null) return root;
        dfs(root);
        return head;
    }
    void dfs(TreeNode root){
        if(root==null) return;
        dfs(root.left);
        root.left = pre;
        if(pre!=null) pre.right = root;
        else head = root;
        pre = root;
        dfs(root.right);
    }
}

27、字符串的排列

题目描述
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
思路：来源
回溯法：

//回溯：：
class Solution {
    List<String> rec;
    boolean[] isvisited;
    public String[] permutation(String s) {
        int n = s.length();
        if(s==null||n==0) return new String[0];
        char[] ch = s.toCharArray();
        rec = new ArrayList<>();
        isvisited = new boolean[n];
        Arrays.sort(ch);
        StringBuilder perm = new StringBuilder();
        backTrace(ch,0,n,perm);
        int size = rec.size();
        String[] ans = new String[size];
        for(int i = 0;i<size;i++){
            ans[i] = rec.get(i);
        }
        return ans;
    }
    void backTrace(char[] ch, int i, int n,StringBuilder perm){
        if(i==n){
            rec.add(perm.toString());
            return;
        }
        for(int j=0;j<n;j++){
            //我们只要在递归函数中设定一个规则，保证在填每一个空位的时候重复字符只会被填入一次。
            //具体地，我们首先对原字符串排序，保证相同的字符都相邻，在递归函数中，
            //我们限制每次填入的字符一定是这个字符所在重复字符集合中「从左往右第一个未被填入的字符」，即如下的判断条件：
            if(isvisited[j]||(j>0&&!isvisited[j-1]&&ch[j-1]== ch[j])){
                continue;
            }
            isvisited[j] = true;
            perm.append(ch[j]);
            backTrace(ch,i+1,n,perm);
            perm.deleteCharAt(perm.length()-1);
            isvisited[j] = false;
        }
    }
}

package M26TO30;

import java.util.ArrayList;
import java.util.Collections;

public class SoluPermutation {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> list = new ArrayList<>();
        if (str==null||str.length()==0) return list;
        //需要把字符串转换为字符数组，用str.toCharArray()
        fun(str.toCharArray(),list,0);
        Collections.sort(list);
        return list;
    }

    private void fun(char[] chars,ArrayList<String> list,int i){
        //这是递归的终止条件，就是i下标已经移到char数组的末尾的时候，考虑添加这一组字符串进入结果集中
        if (i==chars.length-1){
            list.add(new String(chars));
        }
        for (int j=i;j<chars.length;j++){
            //当j不等于i且两个字符相等时，跳过
            if (j!=i&&chars[j]==chars[i]){
                continue;
            }else{
                //交换
                swap(chars,i,j);
                fun(chars,list,i+1);
                //用以使得字符数组的顺序回到进入递归前的状态，这样才不会影响外部的遍历顺序。
                // 因为在第一次交换后进入递归运算的时候，字符数组的顺序改变了，例如“abc”， i = 0时
                // 对应‘a’，j = 1时对应 'b'，进行一次交换，此时的字符数组的顺序为 "bac"，从递归返回时，
                // 顺序依然是“bac”，则进行第二次交换使得 “bac” -> “abc”，这样在后续才可以进行
                // 'a'与'c'的交换，不会落下某一种情况。
                swap(chars,i,j);
            }
        }
    }
    private void swap(char[] chars, int i, int j){
        char t = chars[j];
        chars[j] = chars[i];
        chars[i] = t;
    }
}

28、数组中此数超过一半的数字

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

如果有数字次数超过一半，那么那个次数多的数必定有连续值（如1,6,2,6,3,6,6）。

则：在遍历数组时保存两个值：一是数组中一个数字，一是次数。遍历下一个数字时，若它与之前保存的数字相同，则次数加1，否则次数减1；若次数为0，则保存下一个数字，并将次数置为1
但是最后需要检查，因为当数组为（1,2,3或者1,2,2,3，返回结果并不对）

package M26TO30;

public class MoreThanHalfNum_Solution {
    public int MoreThanHalfNum(int[] array){
        int maxCountNum = array[0];
        int count = 1;
        for (int i=1;i<array.length;i++){
            count = array[i] ==maxCountNum ? count +1: count-1;
            //如果次数小于1，则换到下一个数
            if (count==0){
                maxCountNum = array[i];
                count = 1;
            }
        }
        count = 0;
        for (int val : array){
            if (val==maxCountNum) count++;
        }
        return count>array.length/2 ? maxCountNum :0;
    }
}

29、最小k个数

题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
1、大根堆
2、快速排序

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        int len = input.length;
        if(len<k||k==0) return list;
        //采用大根堆，需要重写compareTo,传进去一个新的比较器
        PriorityQueue<Integer> queue = new PriorityQueue<>(k,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1,Integer o2){
                return o2.compareTo(o1);
            }
        });
        for(int i=0;i<len;i++){
            if(queue.size()<k){
                queue.add(input[i]);
            }else{
                // 队列满了即i>=k时，需要开始判断，当前值小于堆顶时需要加入队列
                if(input[i]<queue.peek()){
                    queue.poll();
                    //删除队首元素，即堆顶元素
                    queue.offer(input[i]);
                }
            }
        }
        list.addAll(queue);
        return list;
    }
}

//自建小根堆
import java.util.*;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] nums, int k) {
        ArrayList<Integer> ans = new ArrayList<>();
        int heapSize = nums.length;
        buildMinHeap(nums,heapSize);
        for(int i=nums.length-1;i>=nums.length-k;i--){
            ans.add(nums[0]);
            swap(nums,0,i);
            --heapSize;
            minHeapify(nums,0,heapSize);
        }
        return ans;
    }
    void buildMinHeap(int[] a,int heapSize){
        for(int i=heapSize/2-1;i>=0;i--){
            minHeapify(a,i,heapSize);
        }
    }
    void minHeapify(int[] a, int i,int heapSize){
        int left = i*2+1,right = i*2+2,largest = i;
        if(left<heapSize&&a[left]<a[largest]){
            largest = left;
        }
        if(right<heapSize&&a[right]<a[largest]){
            largest = right;
        }
        if(largest!=i){
            swap(a,i,largest);
            minHeapify(a,largest,heapSize);
        }
    }
    //交换
    public void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

package M26TO30;

import java.util.ArrayList;

public class SoluGetLeastNumbers {
    ArrayList<Integer> res = new ArrayList<>();
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        if (input.length==0||input.length<k) return res;
        KuaiPai(input,0,input.length-1);
        int i=0;
        while(i<k){
            res.add(input[i++]);
        }
        return res;
    }
    private void KuaiPai(int[] arr,int left,int right){
        if (left>=right) return;
        int cur=arr[right];
        int i=left;
        int j=left;
        while (j<right){
            if (arr[j]<=cur){
                swap(arr,i,right);
                j++;
                i++;
            }else {
                j++;
            }
        }
        swap(arr,i,right);
        KuaiPai(arr,left,i-1);
        KuaiPai(arr,i+1,right);
    }
    public void swap(int[] arr,int a,int b){
        int tmp = arr[a];
        arr[a] = arr[b];
        arr[b] = tmp;
    }
}

30、连续数组最大值

题目描述

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

思路：

使用动态规划
dp[n]代表以当前元素为截止点的连续子序列的最大和，如果dp[n-1]>0，dp[n]=array[i]+dp[n-1]，因为当前数字加上一个正数一定会变大；如果dp[n-1]<0，dp[n]不变，因为当前数字加上一个负数一定会变小。使用一个变量max记录最大的dp值返回即可。

package M26TO30;

public class SoluFindGreatestSumOfSubArray {
    public static int FindGreatestSumOfSubArray(int[] array) {
        int n = array.length;
        int[] dp = new int[n+1];//包含array[i]的连续数组最大值
        dp[0] = array[0];//位置0处的最大值，即自己

        int ret = dp[0];//记录当前所有子数组的和的最大值
        for (int i=1; i<n; ++i) {
        //检查看前面的dp[i-1]是否大于0
            if(dp[i-1]>0){
                dp[i] = dp[i-1]+array[i];
            }else{
            //如果到i-1位置的子数组和小于0，那么第i个位置上的最大子数组之和就是自己
                dp[i]=array[i];
            }
            ret = Math.max(ret, dp[i]);
        }
        return ret;
    }

    public static void main(String[] args) {
        int[] t =new int[]{1,-5,-10,5,12,15};
        System.out.println(FindGreatestSumOfSubArray(t));
    }
}