剑指offer 26到30题 （ JAVA ）

第二十六题：

（参考：https://blog.csdn.net/qq_41901915/article/details/90670763）

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

思路：
//1.将左子树构造成双链表，并返回链表头节点。
//2.定位至左子树双链表最后一个节点。
//3.如果左子树链表不为空的话，将当前root追加到左子树链表。
//4.将右子树构造成双链表，并返回链表头节点。
//5.如果右子树链表不为空的话，将该链表追加到root节点之后。
//6.根据左子树链表是否为空确定返回的节点。

代码：

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

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

    }

}
*/
public class Solution {
     public TreeNode Convert(TreeNode root) {
        if(root==null)
            return null;
        if(root.left==null&&root.right==null)
            return root;//返回倒数第二层
        // 1.将左子树构造成双链表，并返回链表头节点
        TreeNode left = Convert(root.left);//递归
        TreeNode p = left;  // 2.定位至左子树双链表最后一个节点
        while(p!=null&&p.right!=null){
            p = p.right;//排除特殊情况
        }
        // 3.如果左子树链表不为空的话，将当前root追加到左子树链表
        if(left!=null){
            p.right = root;
            root.left = p;
        }
        // 4.将右子树构造成双链表，并返回链表头节点
        TreeNode right = Convert(root.right);
        // 5.如果右子树链表不为空的话，将该链表追加到root节点之后
        if(right!=null){
            right.left = root;
            root.right = right;
        }
        return left!=null?left:root;       
    }
}

---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------

第二十七题：

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

思路：

第一步：确定第一个位置的字符，就是第一个位置与后边的所有字符进行交换。 
第二步：对除了第一个位置的后边所有位置的字符进行相同处理；直至剩下一个字符，打印。

 

代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String>res =new ArrayList<>();
        if(str==null||str.length()==0)return res;
        char[]chs =str.toCharArray();//ToCharArray( )的用法，将字符串对象中的字符转换为一个字符数组。
        findPermutation(res,chs,0);//排序
        Collections.sort(res);//Collections的sort方法，对传入的list进行排序，直接改变原list，无返回值
        return (ArrayList)res;//强制类型转换
    }
    //对chs[i~length-1]范围内的字符数组完成全排列，并将结果加入res中
    public void findPermutation(ArrayList<String>res,char[]chs,int i)
    {
        if(i==chs.length)
        {
            res.add(new String(chs));
            return;
        }//将最后一个字符，加入List
    HashSet<Character>set=new HashSet<>();
    //从【i~length-1】中枚举确定i位置的字符
        for (int j = i; j < chs.length; j++) {
            if(!set.contains(chs[j]))//如果以前没有选过
            {
                set.add(chs[j]);//交换
                swap(chs,i,j);//确定好位置，对char[i+1~length-1]进行全排列
                findPermutation(res,chs,i+1);//递归
                swap(chs,i,j);//还原前一次交换
            }
        }
        return;
    }
    public void swap(char[]chs,int i,int j)
    {
        char temp=chs[i];
        chs[i]=chs[j];
        chs[j]=temp;
    }
}

 

---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------

第二十八题：

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

思路：将数组进行排序，之后遍历判断。

代码：

import java.util.Arrays;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        Arrays.sort(array);//用sort排序
        int count=0;
        for(int i=0;i<array.length;i++){
            if(array[i]==array[array.length/2]){
                count++;
            }
        }
        if(count>array.length/2){
            return array[array.length/2];
        }else{
            return 0;
        }
         
    }
}

---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------

第二十九题：

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

思路：冒泡排序，然后一直取最小的一位，直到K满了。

代码：

import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> al = new ArrayList<Integer>();
        if (k > input.length) {
            return al;
        }
        for (int i = 0; i < k; ++i) {
            for (int j = 0; j < input.length - i - 1; ++j) {
                if (input[j] < input[j + 1]) {
                    int temp = input[j];
                    input[j] = input[j + 1];
                    input[j + 1] = temp;//冒泡排序，最后一位即为最小的
                }
            }
            al.add(input[input.length - i - 1]);
        }
        return al;
    }
}

---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------

第三十题：

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

思路：

数组遍历过程中记录同时比对。

代码：

public class Solution {
     public int FindGreatestSumOfSubArray(int[] array) {
         if (array.length==0 || array==null) {
             return 0;
         }
         int curSum=0;
         int greatestSum=array[0];
         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;
     }
 }

---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------