ZCC的专栏

一、题目给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。示例 1：输入: “babad”输出: “bab”注意: "aba"也是一个有效答案。二、解决方案package com.company;/** * 功能描述： 最长回文子串 * * @author zc * @since 2020-05-19 */class Solution05 { /** * 寻找最长回文子串 * 算法: 动态规划 * 动态

一、堆排序简介堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种**选择排序，**它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。堆排序的基本思想是：将待排序序列构造成一个大顶堆 ( 一般升序采用大顶堆，降序采用小顶堆 )，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。二、堆排序实现/** * * 堆排序

“推箱子”这个经典的游戏,具体规则就是在一个N*M的地图上，有1个玩家、1个箱子、1个目的地以及若干障碍，其余是空地。玩家可以往上下左右4个方向移动，但是不能移动出地图或者移动到障碍里去。如果往这个方向移动推到了箱子，箱子也会按这个方向移动一格，当然，箱子也不能被推出地图或推到障碍里。当箱子被推到目的地以后，游戏目标达成。现在告诉你游戏开始是初始的地图布局，请你求出玩家最少需要移动多少步才能够将游

用栈来求解限制后的汉诺塔问题(限制不能从最左侧的塔直接移动到最右侧，也不能从最右侧直接移动到最左侧，而是必须经过中间，求当塔有N层的时候，打印最优移动过程和最优移动总步数)import java.util.Stack;//用栈来求解限制后的汉诺塔问题(限制不能从最左侧的塔直接移动到最右侧，也不能从最右侧直接移动到最左侧，而是必须经过中间，求当塔有N层的时候，打印最优移动过程和最优移动总步数

实现的代码如下://删除链表的中间节点和a/b处的节点public class DelMidList{ //链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data

实现的完整代码如下:import java.util.*;//生成窗口最大值数组(设计时间复杂度为O(N)的算法)public class getMaxWindowArr{ /** 获得最大值数组 arr[] 表示源数组 w 滑动窗口的大小 ret 返回的最大值数组 **/ public static

* 设计实现一个有getMin功能的栈 (实现一个特殊的栈,在实现栈的基本功能(pop,push)的基础上， 再实现返回栈中最小元素(getMin)的操作)import java.util.*;/** * 设计实现一个有getMin功能的栈 * (实现一个特殊的栈,在实现栈的基本功能(pop,push)的基础上， * 再实现返回栈中最小元素(getMin)的操作) * @autho

实现单链表的反转://翻转链表public class ReverseList{ //链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data) {

举个例子如下:实现的代码如下:import java.util.Stack;import java.util.HashMap;//构造数组的MaxTreepublic class MaxTree{ //二叉树结点的定义如下 public static class Node{ public int value; public Nod

反转单向和双向链表简化://反转单向和双向链表public class ReverseList{ //节点的定义 public static class Node{ public int value; public Node next; public Node(int data)

反转部分单向链表://反转部分单向链表的public class ReverseSubList{ //链表节点的定义 public static class Node{ public int value; public Node next; //节点的定义 public Node(int

import java.util.*;//将搜索二叉树转换成双向链表public class TwoList{ //节点的定义 public static class Node{ public int value; public Node left; public Node right; public Nod

//解决约瑟夫问题public class YueSeFu{ //定义链表的节点 public static class Node{ public int value; Node next; public Node(int data) { this.value=data;

//单链表的选择排序public class SelectSortList{ //单链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data) { this.value=

//一种怪异的节点的删除public class RemoveNode{ //单链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data) { this.va

//向有序的环形单链表中插入新节点public class InsertNode{ //单链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data) { this.v

编写一个类，用两个栈实现一个队列，支持队列的基本操作(add,poll,peek)    编写的代码如下:import java.util.Stack;public class Problem_02_TwoStacksImplementQueue { public static class TwoStacksQueue { public Stack stackPush;

import java.util.Stack;//判断一个链表是否为回文结构public class HuiWenList{ //定义链表的节点 public static class Node{ int value; Node next; public Node(int data) { this.valu

仅用递归函数和栈操作逆序一个栈  (1) getAndRemoveLastElement()函数(2) reverse()函数(3)完整代码如下:import java.util.Stack;//仅用递归函数和栈操作逆序一个栈public class ReverseStack{ //将栈的栈底元素返回并移除 public static

//合并两个有序的单链表public class MergeList{ public static class Node{ public int value; public Node next; public Node(int data) { this.value=data; } } //合并两

实现的完整代码如下: import java.util.Stack;//获得给定矩阵的最大子矩阵public class MaxSubMatrix{ public static int getMaxSubMatrix(int[][]map) { if(map==null||map.length==0||map[0].length==0) {

import java.util.LinkedList;//最大值减去最小值小于或等于num的子数组数量public class getAllSubArray{ //获得子数组的数量 public static int getNum(int[]arr,int num) { if(arr==null||arr.length==0) {

//按照左右半区的方式重新组合单链表public class ReConList{ //链表的定义 public static class Node{ public int value; public Node next; public Node(int data) { this.value=data; } } //按照左右半区的方式重新组合单链表

import java.util.LinkedList;import java.util.Queue;//将单向链表按某值划分成左边小、中间相等、右边大的形式public class DivideList{ //链表节点的定义 public static class Node{ public int value; public Node next; publi

import java.util.Stack;//分别用递归和非递归方式实现二叉树先序、中序和后序遍历public class TreeTravel{ //二叉树节点的定义 public static class Node{ public int value; public Node left; public Node right;

import java.util.*;//复制含有随机指针的链表public class CopyList{ //链表节点的定义 public static class Node{ public int value; public Node next; public Node rand; public Node(int da

//打印两个有序链表的公共部分public class getSameList{ //获得两个有序链表的公共部分 public static void GetSameList(int[] head1,int[] head2) { if(head1==null||head2==null) { return; }

实现猫狗队列问题:import java.util.Queue;import java.util.LinkedList;//实现猫狗队列的问题public class CatDogQueue{ //宠物 类 public static class Pet{ private String type; public Pet(String

用一个栈实现另外一个栈的排序:import java.util.Stack;//用一个栈实现另外一个栈的排序public class StackSortStack{ //借助栈的排序 public static void StackSort(Stackstack) { Stack help =new Stack(); while(

实现的完整代码如下://在单链表和双链表中删除倒数第k个节点public class DeleteList{ //单链表节点的定义 public static class Node{ int value; Node next; public Node(int data) { thi

public class PrintEdgeNodes { //二产树节点的定义 public static class Node { public int value; public Node left; public Node right; public Node(int data) { this.value = data; } } //按照标准

//找到二叉树中的最大搜索二叉子树public class MaxSearchTree{ //二叉树节点的定义 public static class Node{ public int value; public Node left; public Node right;

import java.util.Stack;//两个单链表生成相加链表public class plusList{ //链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data) { this

public class PrintBinaryTree { //二叉树节点的定义 public static class Node { public int value; public Node left; public Node right; public Node(int data) { this.value = data; } } //打

import java.util.*;//二叉树的序列化和反序列化public class SerializeTree{ //二叉树结点的定义 public static class Node{ public int value; public Node left; public Node right; public Node(

//两个单链表相交的一系列问题public class TwoInterList{ //链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data) { this.value=data; } } //返回两个链表相交的第一个

//在二叉树中找到一个节点的后继节点public class getNextNode{ //节点的定义 public static class Node{ public int value; public Node left; public Node right; public Node parent; public Node(int data) { this

import java.util.Stack;//将单链表的每k个节点之间逆序public class ReverseKOfList{ //单链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data)

import java.util.*;//在二叉树中找到两个节点的最近公共祖先public class GetLowestTree{ //二叉树节点的定义 public static class Node{ public int value; public Node left; public Node right; public Node(int data) {

import java.util.HashMap;import java.util.LinkedList;public class TarjanAndDisjointSetsForLCA { public static class Node { public int value; public Node left; public Node right; public N