26.二叉搜索树与双向链表
题目描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
思路一:非递归版
- 核心是中序遍历的非递归算法
- 修改当前遍历节点与前一遍历节点的指针指向
package com.matajie;
import java.util.Stack;
/**
* 26.二叉搜索树与双向链表
* 题目描述
* 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。
* 要求不能创建任何新的结点，只能调整树中结点指针的指向。
*
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class Convert {
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
public TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree == null) return null;
Stack<TreeNode> stack = new Stack<>();
TreeNode p = pRootOfTree;
TreeNode pre = null;//用于保存中序遍历序列的上一节点
boolean isFirst = true;
while (p != null || !stack.empty()){
while (p != null){
stack.push(p);
p=p.left;
}
p = stack.pop();
if(isFirst){//将中序遍历序列中的第一节点记为pRootOfTree.
pRootOfTree = p;
pre = pRootOfTree;
isFirst = false;
}else {
pre.right = p;
p.left = pre;
pre = p;
}
p = p.right;
}
return pRootOfTree;
}
}
思路二:递归版
- 将左子树构造成双链表,并返回链表的头节点;
- 新增一个全局变量记录左子树的最后一个节点;
- 如果左子树链表不为空的话,将当前pRootOfTree追加到左子树链表;
- 将右子树构造成双链表,并返回链表头节点;
- 如果右子树链表不为空的话,将该链表追加到pRootOfTree节点之后;
- 根据左子树链表是否为空确定返回的节点;
package com.matajie;
import java.util.Stack;
/**
* 26.二叉搜索树与双向链表
* 题目描述
* 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。
* 要求不能创建任何新的结点，只能调整树中结点指针的指向。
*
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class Convert {
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
protected TreeNode ledtLast = null;//记录子树链表的最后一个节点,
// 终结点只可能为只含左子树的非叶节点与叶节点;
public TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree == null) return null;
if(pRootOfTree.left == null && pRootOfTree.right == null){
ledtLast = pRootOfTree;
return pRootOfTree;
}
TreeNode left = Convert(pRootOfTree.left);//将左子树构造成双链表,并返回链表头节点
if(left != null){//如果左子树链表不为空,将当前pRootOfTree追加到左子树链表;
ledtLast.right = pRootOfTree;
pRootOfTree.left = ledtLast;
}
ledtLast = pRootOfTree;//当根节点只含左子树时,则该根节点为最后一个节点
TreeNode right = Convert(pRootOfTree.right);//将右子树构造成双链表,并返回链表头节点
if(right != null){//如果右子树链表不为空,将该链表追加到pRootOfTree节点之后
right.left = pRootOfTree;
pRootOfTree.right = right;
}
return left != null ? left : pRootOfTree;
}
}
27.字符串的排列
题目描述
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
思路一:
对于无重复的情况,固定第一个字符,递归取得首位后面的各种字符串组合,再把第一个字符串与后面每个字符交换,并同样递归获得首位后面的字符串组合.
递归出口:只剩一个字符的时候
递归循环过程:从每个字串的第二个字符开始一次与第一个字符串交换,然后继续处理子串.
对于T = {X1,X2,X3,…Xn-1,Xn},我们获得了在第一个位置上的所有情况之后,对每一种情况,抽去序列T中的第一个位置,那么对于剩下的序列可以看出是一个全新的序列.
T1 = { X2,X3,X4…Xn-1,Xn},序列T1,可以认为是与之前的序列毫无关联了,同样,我们可以对T1,进行与T的相同操作,直到T1中只有一个元素位置,这样我们就获得了所有的可能性,显然这是一个递归算法.
第一位的所有情况无非是将X与后面的所有数X2,X3…Xn依次交换一次
如果存在相同元素呢?
我们每一次交换递归之前对元素进行检查,如果这个元素的后面还存在数值相同的元素,我们就可以跳过进行下一次循环.
package com.matajie;
import java.util.ArrayList;
import java.util.Collections;
/**
* 27.字符串的排列
* 题目描述
* 输入一个字符串,按字典序打印出该字符串中字符的所有排列。
* 例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
*
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class Permutation {
public ArrayList<String> Permutation(String str) {
ArrayList<String> resultlist = new ArrayList<>();
if(str.length() == 0) return resultlist;
fun(str.toCharArray(),resultlist,0);//递归的初始值为(str数组,空的list,初始值下标为0)
Collections.sort(resultlist);
return resultlist;
}
private void fun(char[] ch,ArrayList<String> list,int i){
if(i == ch.length - 1){//递归终止条件,当i下标已经移到char数组的末尾时,添加这一组字符串进入结果集中判断是否重复.
if(!list.contains(new String(ch))){
list.add(new String(ch));
return;
}
}else {
for(int j = i;j<ch.length;j++){
swap(ch,i,j);
fun(ch,list,i+1);
swap(ch,i,j);//对于如图的左子树,当程序将ACB加入到list中,此时数组的状态就是ACB,
// 因为递归的原因,程序会退栈回到根节点,如果没有这个swap,此时根节点时ACB,而不是ABC
}
}
}
private void swap(char[] str,int i ,int j){
if(i != j){
char t = str[i];
str[i] = str[j];
str[j] = t;
}
}
}
思路二:全排列的非递归实现(字典序)
要考虑全排列的非递归实现,先来考虑如何计算字符串的下一个排列.只要对字符串反复求出下一个排列,全排列问题迎刃而解.
如何计算字符串的下一个排列呢?用" 926520 "这个字符串为例,从后向前找第一双相邻的递增数字,“20”,"52"都是非递增的,“26"满足要求,我们称前一个数字2为替换数,替换数的下标称为替换点,再从后面找一个比替换数大的最小数(此数一定存在),0 , 2 都不行, 5 可以,将5和2交换,然后再将替换点后的字符串"6220"颠倒,即得"950226”.
28.数组中出现次数超过一半的数字
题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
思路一:HashMap
package com.matajie;
import java.util.HashMap;
/**
* 28.数组中出现次数超过一半的数字
*
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class MoreThanHalfNum_Solution {
public int MoreThanHalfNum_Solution(int [] array) {
if(array == null) return 0;
HashMap<Integer,Integer> map = new HashMap<>();
for(int ar : array){
if(!map.containsKey(ar)){
map.put(ar,1);
}else {
map.put(ar,map.get(ar)+1);
}
if(map.get(ar) > array.length/2){
return ar;
}
}
return 0;
}
}
思路二:阵地攻守思想
第一个数字作为第一个士兵,守阵地,count = 1,遇到相同元素,count++;遇到不同元素,即为敌人,同归于尽,count–,当遇到count = 0的情况,又以新的i值作为守阵地的士兵,继续下去,到最后还留在阵地上的士兵有可能是主元素,再加一次循环,记录这个士兵的个数看是否大于数组一半即可.
package com.matajie;
/**
* 28.数组中出现次数超过一半的数字
*
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class MoreThanHalfNum_Solution {
public int MoreThanHalfNum_Solution(int [] array) {
if(array == null) return 0;
int index = 0;
int count = 01;
int i = 0;
for(i = 0;i<array.length;i++){
if(array[i] == array[index]){
count++;
}else {
count--;
}
if(count == 0){
index = i;
count = 1;
}
}
count = 0;
for(i = 0;i<array.length;i++){
if(array[i] == array[index]){
count++;
}
}
if(count > array.length/2){
return array[index];
}
return 0;
}
}
29.最小的k个数
题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
思路:
用最大堆保存这k个数,每次只和堆顶比,如果比堆顶小,删除堆顶,新数入堆.
package com.matajie;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
/**
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class GetLeastNumbers_Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> result = new ArrayList<>();
int length = input.length;
if(k>length || k == 0) return result;
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
for(int i = 0;i<length;i++){
if(maxHeap.size() != k){
maxHeap.offer(input[i]);
}else if(maxHeap.peek()>input[i]){
Integer temp = maxHeap.poll();
temp = null;
maxHeap.offer(input[i]);
}
}
for(Integer integer : maxHeap){
result.add(integer);
}
return result;
}
}
30.连续子数组的最大和
题目描述
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
思路一:
package com.matajie;
import java.util.Map;
/**
* 30.连续子数组的最大和
*
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class FindGreatestSumOfSubArray {
public int FindGreatestSumOfSubArray(int[] array) {
int sum = 0;
int res = array[0];
for(int num : array){
if(sum > 0){
sum += num;
}else {
sum = num;
}
res = Math.max(sum,res);
}
return res;
}
}
思路二:动态规划
F(i):以array[ i ]为末尾元素的子数组的和的最大值,子数组的元素相对位置不变
F(i) = max(F(i-1)+array[ i ],array[ i ])
res:所有子数组的和的最大值,res = max(res,F(i)).
如数组[6, -3, -2 ,7, -15, 1, 2, 2]
初始状态: F(0) = 6, res = 6;
i = 1:F(1) = max(F(0)-3,-3) = max(6-3,3) = 3;
res = max(F(1),res) = max(3,6) = 6.
i = 2:F(2) = max(F(1)-2,-2) = max(3-2,-2) = 1;
res = max(F(2),res) = max(1,6) = 6.
i = 3:F(3) = max(F(2)+7,7) = max(1+7,7) = 8;
res = max(F(2),res) = max(8,6) = 8.
i = 4…以此类推,最终res值为8.
package com.matajie;
/**
* 30.连续子数组的最大和
*
* 我的程序才不会有bug！
* author:年仅18岁的天才少年程序员丶mata杰
**/
public class FindGreatestSumOfSubArray {
public int FindGreatestSumOfSubArray(int[] array) {
int res = array[0];//记录当前所有子数组的和的最大值,包含array[i]的连续数组的最大值
int max = array[0];
for(int i = 1;i<array.length;i++){
max = Math.max(max + array[i],array[i]);
res = Math.max(max,res);
}
return res;
}
}
144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
