Java数据结构、算法面试题

程序员文章站 2024-03-16 14:38:40

...

转自https://blog.csdn.net/zyx520ytt/article/details/72466255

1.题目：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

代码：





import java.util.ArrayList;




import java.util.Collections;




import java.util.Comparator;




import java.util.Iterator;








public class Solution {



    public static String PrintMinNumber(int [] numbers) {



		String result = "";



		int length=numbers.length;



		if(length<1){



			return result;



		}



		ArrayList<Integer> list=new ArrayList<Integer>();



		for(int i=0;i<length;i++){



			list.add(numbers[i]);



		}



		Collections.sort(list,new Comparator<Integer>() {



			@Override




			public int compare(Integer o1, Integer o2) {



				String result1=o1+""+o2;



				String result2=o2+""+o1;



				return result1.compareTo(result2);



			}



		});



		Iterator<Integer> iterator=list.iterator();



		while(iterator.hasNext()){



			result+=(iterator.next()+"");



		}



		return result;



    }



}

2.题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

代码：




/**



 * Definition for binary tree



 * public class TreeNode {



 *     int val;



 *     TreeNode left;



 *     TreeNode right;



 *     TreeNode(int x) { val = x; }



 * }



 */




public class Solution {



    public TreeNode reConstructBinaryTree(int[] pre, int[] in) {



		return DFS(pre,in,0,pre.length-1,0,in.length-1);



	}







	private TreeNode DFS(int []pre,int []in,int prestart,int preend,int instart,int endstart){



		if(prestart>preend||instart>endstart){



			return null;



		}



		TreeNode root=new TreeNode(pre[prestart]);



		for(int indexstart=instart;indexstart<=endstart;indexstart++){



			if(pre[prestart]==in[indexstart]){



				root.left=DFS(pre, in, prestart+1, prestart+indexstart-instart, instart, indexstart-1);



				root.right=DFS(pre, in, indexstart-instart+prestart+1, preend, indexstart+1, endstart);



			}



		}



		return root;



	}



}

3.题目：给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。

代码：




/*



public class TreeNode {



    int val = 0;



    TreeNode left = null;



    TreeNode right = null;







    public TreeNode(int val) {



        this.val = val;







    }







}



*/








import java.util.ArrayList;




import java.util.Arrays;




import java.util.Collections;




import java.util.Comparator;




import java.util.Iterator;




public class Solution {



    //思路：二叉搜索树的中序遍历就是按顺序排列的，所以，直接中序查找就可以了




   int index=0;



	 TreeNode KthNode(TreeNode pRoot, int k) {



		if(pRoot!=null){



			TreeNode left=KthNode(pRoot.left, k);



			if(left!=null)



				return left;



			index++;



			if(index==k)



				return pRoot;



			TreeNode right=KthNode(pRoot.right, k);



			if(right!=null)



				return right;



		}



		return null;



     }



}

题目描述

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){



			return 0;



		}



		int sum=array[0];



		int Maxsum=array[0];



		for(int i=1;i<array.length;i++){



			if(sum<0){



				sum=0;



			}



			sum+=array[i];



			Maxsum=Math.max(Maxsum, sum);



		}



		return Maxsum;



	}



}

题目描述

在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是重复的数字2或者3。

代码：





import java.util.HashSet;




import java.util.Iterator;




import java.util.LinkedHashSet;




import java.util.Set;




public class Solution {



    // Parameters:




    //    numbers:     an array of integers




    //    length:      the length of array numbers




    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;




    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++




    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]




    // Return value:       true if the input is valid, and there are some duplications in the array number




    //                     otherwise false




    //	private static final int Max=(int) (1e5+10);




	private static int []vis;



	public static boolean duplicate(int numbers[], int length, int[] duplication) {



		if(length<1){



			return false;



		}



		vis=new int [length];



		for(int i=0;i<length;i++){



			vis[numbers[i]]++;



		}



		Set<Integer> set=new HashSet<Integer>();



		for(int i=0;i<length;i++){



			if(vis[numbers[i]]>1){



				set.add(numbers[i]);



			}



		}



		Iterator<Integer> iterator=set.iterator();



		int cnt=0;



		while(iterator.hasNext()){



			duplication[cnt++]=iterator.next();



			break;



		}



//		for(int i=0;i<cnt;i++){



//			System.out.print(duplication[i]+" ");



//		}



		if(cnt!=0){



			return true;



		}



		return false;



	}



}

题目描述

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育**,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育**啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何。为了方便起见,你可以认为大小王是0。

代码：





import java.util.HashSet;




import java.util.Set;




public class Solution {



    //思路：判断不合法的情况：1.numbers长度不为5，2.numbers中除0外，有重复的数，3.最大值减最小值>=5




	//剩下的就是合法的情况了




   public boolean isContinuous(int[] numbers) {



		int length=numbers.length;



		if(length!=5){



			return false;



		}



		Set<Integer> hashSet=new HashSet<Integer>();



		int ans=0;//0的个数




		int Max=-1,Min=100;



		for(int i=0;i<length;i++){



			if(numbers[i]!=0){



				hashSet.add(numbers[i]);



				Max=Math.max(Max, numbers[i]);



				Min=Math.min(Min, numbers[i]);



			}else{



				ans++;



			}



		}



		if(ans+hashSet.size()!=length){



			return false;



		}



		if(Max-Min>=5){



			return false;



		}



		return true;



	}



}

题目描述

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

代码：





public class Solution {



 public  String LeftRotateString(String str, int n) {



		if(str.length()==0){



			return str;



		}



		n%=(str.length());



		if(str.length()<1)



			return null;



		for(int i=0;i<n;i++)



			str=GetString(str);



		return str;



	}



	private  String GetString(String str){



		return str.substring(1, str.length())+str.charAt(0);



	}



}

题目描述

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

代码：





public class Solution {



 public static String ReverseSentence(String str) {



		String string=str.trim();



		String a="";



		if(string.equals(a)){



			return str;



		}



		StringBuilder result=new StringBuilder();



		String []split=str.split(" ");



		for(int i=split.length-1;i>=0;i--){



			result.append((split[i]+" "));



		}



		return result.toString().trim();



	}



}

题目描述

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

代码：





import java.util.ArrayList;




public class Solution {



   public static ArrayList<Integer> maxInWindows(int [] num, int size)




    {



        ArrayList<Integer> list=new ArrayList<Integer>();



        int length=num.length;



        if(size<=0){



        	return list;



        }



        if(length>=1){



        	int Max=Integer.MIN_VALUE;



        	for(int i=0;i<length;i++){



        		Max=Math.max(Max, num[i]);



        	}



        	if(size>length){



        		return list;



        	}else{



        		for(int i=0;i<length-size+1;i++){



        			int MAX=Integer.MIN_VALUE;



        			for(int j=i;j<size+i;j++){



        				MAX=Math.max(MAX, num[j]);



        			}



        			list.add(MAX);



        		}



        	}



        }



        return list;



    }



}

题目描述

每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

代码：





public class Solution {



    private final static int Max=(int) (1e5+10);



	public int LastRemaining_Solution(int n, int m) {



		int []array=new int[Max];



		int i=-1,count=n,step=0;



		while(count>0){//模拟环




			i++;



			if(i>=n){



				i=0;



			}



			if(array[i]==-1)



				continue;



			step++;



			if(step==m){



				step=0;



				count--;



				array[i]=-1;



			}



		}



		return i;



	}



}

题目描述

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

代码：





import java.util.ArrayList;




import java.util.LinkedList;




import java.util.Queue;



/*



public class TreeNode {



    int val = 0;



    TreeNode left = null;



    TreeNode right = null;







    public TreeNode(int val) {



        this.val = val;







    }







}



*/




public class Solution {



    public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {



		ArrayList<ArrayList<Integer>> list=new ArrayList<ArrayList<Integer>>();



		if(pRoot==null){



			return list;



		}



		int ans=1;



		Queue<TreeNode> queue=new LinkedList<TreeNode>();



		queue.add(pRoot);



		while(!queue.isEmpty()){



			ArrayList<Integer> nodes=new ArrayList<Integer>();



			int size=queue.size();



			for(int i=0;i<size;i++){



				TreeNode root=queue.poll();



				if(ans%2==0){



					nodes.add(0,root.val);



				}else{



					nodes.add(root.val);



				}



				if(root.left!=null){



					queue.add(root.left);



				}



				if(root.right!=null){



					queue.add(root.right);



				}



			}



			list.add(nodes);



			ans++;



		}



		return list;



	}







}

题目描述

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

代码：




/*



public class TreeNode {



    int val = 0;



    TreeNode left = null;



    TreeNode right = null;







    public TreeNode(int val) {



        this.val = val;







    }







}



*/




import java.util.ArrayList;




import java.util.LinkedList;




import java.util.Queue;




public class Solution {



    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {



	    ArrayList<ArrayList<Integer>> list=new ArrayList<ArrayList<Integer>>();



	    if(pRoot==null){



	    	return list;



	    }



	    Queue<TreeNode> queue=new LinkedList<TreeNode>();



	    queue.add(pRoot);



	    while(!queue.isEmpty()){



	    	ArrayList<Integer> arrayList=new ArrayList<Integer>();



	    	int size=queue.size();



	    	for(int i=0;i<size;i++){



	    		TreeNode root=queue.poll();



	    		arrayList.add(root.val);



	    		if(root.left!=null){



	    			queue.add(root.left);



	    		}



	    		if(root.right!=null){



	    			queue.add(root.right);



	    		}



	    	}



	    	list.add(arrayList);



	    }



	    return list;



    }







}

题目描述

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

代码：





import java.util.ArrayList;




import java.util.Collections;




import java.util.Comparator;




public class Solution {







    private ArrayList<Integer> list=new ArrayList<Integer>();



	public void Insert(Integer num) {



		list.add(num);



		Collections.sort(list,new Comparator<Integer>() {







			@Override




			public int compare(Integer o1, Integer o2) {



				return o1-o2;



			}



		});



	}







	public Double GetMedian() {



		int length=list.size();



		int MID=length>>1;



		double mid=0;



		if((length&1)==0){



			Integer a1=list.get(MID);



			Integer a2=list.get(MID-1);



			mid=(Double.valueOf(a1+"")+Double.valueOf(a2+""))/2;



		}else{



			Integer a3=list.get(MID);



			mid=Double.valueOf(a3+"");



		}



		return mid;



	}



}

题目描述

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出描述:

输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

代码：





import java.util.ArrayList;




public class Solution {



    public static ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {



		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();



		if (sum < 0) {



			return list;



		}



		for (int i = 1; i <= sum; i++) {



			for (int j = i; j <= sum; j++) {



				int n = j - i + 1;



				int ans = i*n+(n*(n-1))/2;



				if (ans != sum) {



					continue;



				}



				ArrayList<Integer> arrayList = new ArrayList<>();



				for (int k = i; k <= j; k++) {



					arrayList.add(k);



				}



				if(arrayList.size()>=2){//至少包括两个数




					list.add(arrayList);



				}



			}



		}



		return list;



	}



}

题目描述

有一副由NxN矩阵表示的图像，这里每个像素用一个int表示，请编写一个算法，在不占用额外内存空间的情况下(即不使用缓存矩阵)，将图像顺时针旋转90度。

给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于500，图像元素小于等于256。

测试样例：

[[1,2,3],[4,5,6],[7,8,9]],3

返回：[[7,4,1],[8,5,2],[9,6,3]]

代码：





import java.util.*;








public class Transform {



    public  int[][] transformImage(int[][] mat, int n) {



		int [][]A=new int[n][n];



		int x=0,y=n-1;



		for(int i=0;i<n;i++){



			for(int j=0;j<n;j++){



				A[x][y]=mat[i][j];



				if(x==n-1){



					y--;



					x=0;



				}else{



					x++;



				}



			}



		}



		return A;



    }



}

题目描述

假定我们都知道非常高效的算法来检查一个单词是否为其他字符串的子串。请将这个算法编写成一个函数，给定两个字符串s1和s2，请编写代码检查s2是否为s1旋转而成，要求只能调用一次检查子串的函数。

给定两个字符串s1,s2,请返回bool值代表s2是否由s1旋转而成。字符串中字符为英文字母和空格，区分大小写，字符串长度小于等于1000。

测试样例：

"Hello world","worldhello "

返回：false

"waterbottle","erbottlewat"

返回：true

代码：





import java.util.*;








public class ReverseEqual {



    public boolean checkReverseEqual(String s1, String s2) {



		if(s1==null||s2==null||s1.length()!=s2.length()){



			return false;



		}



		return (s1+s1).contains(s2);



	}



}

题目描述

输入一个链表，输出该链表中倒数第k个结点。




/*



public class ListNode {



    int val;



    ListNode next = null;







    ListNode(int val) {



        this.val = val;



    }



}*/








import java.util.LinkedHashMap;




public class Solution {







	public ListNode FindKthToTail(ListNode head, int k) {



		LinkedHashMap<Integer, ListNode> map=new LinkedHashMap<Integer, ListNode>();



		int cnt=0;



		while(head!=null){



			map.put(cnt++, head);



			head=head.next;



		}



		return map.get(cnt-k);







	}







}

题目描述

实现一个算法，删除单向链表中间的某个结点，假定你只能访问该结点。

给定带删除的节点，请执行删除操作，若该节点为尾节点，返回false，否则返回true

代码：





import java.util.*;







/*



public class ListNode {



    int val;



    ListNode next = null;







    ListNode(int val) {



        this.val = val;



    }



}*/




public class Remove {



    public boolean removeNode(ListNode pNode) {



        if(pNode==null){



			return false;



		}



		if(pNode.next==null){



			return false;



		}



		return true;



    }



}

题目描述

编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前

给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。

代码：





import java.util.*;




import java.util.Collections;




import java.util.Comparator;




import java.util.LinkedList;



/*



public class ListNode {



    int val;



    ListNode next = null;







    ListNode(int val) {



        this.val = val;



    }



}*/




public class Partition {



 public ListNode partition(ListNode pHead, int x) {



		if(pHead==null||pHead.next==null){



			return pHead;



		}







		ListNode cur=pHead;



		ListNode Ahead=new ListNode(-1);



		ListNode Bhead=new ListNode(-1);



		ListNode Atemp=Ahead;



		ListNode Btemp=Bhead;



		while(cur!=null){



			if(cur.val<x){



				Atemp.next=new ListNode(cur.val);



				Atemp=Atemp.next;



			}else{



				Btemp.next=new ListNode(cur.val);



				Btemp=Btemp.next;



			}



			cur=cur.next;



		}



		ListNode newhead=Ahead;



		while(newhead.next!=null&&newhead.next.val!=-1){



			newhead=newhead.next;



		}



		newhead.next=Bhead.next;



		return Ahead.next;//取Ahead->next而不取Ahead是因为Ahead头的val是-1，不是链表中的值




	}



}

题目描述

有两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表的首部。编写函数对这两个整数求和，并用链表形式返回结果。

给定两个链表ListNode* A，ListNode* B，请返回A+B的结果(ListNode*)。

测试样例：

{1,2,3},{3,2,1}

返回：{4,4,4}

代码：





import java.util.*;



/*



public class ListNode {



    int val;



    ListNode next = null;







    ListNode(int val) {



        this.val = val;



    }



}*/




public class Plus {



  public static ListNode plusAB(ListNode a, ListNode b) {



		if (a == null && b == null) {



			return null;



		}



		ListNode Ahead = a;



		ListNode Bhead = b;



		ListNode newhead = new ListNode(-1);



		ListNode newtemp = newhead;



		int temp = 0;



		while (Ahead != null || Bhead != null) {



			// 三种情况:1:Ahead!=null&&Bhead!=null




			// 2:Ahead==null&&Bhead！=null




			// 3:Ahead!=null&&Bhead==null




			if (Ahead != null && Bhead != null) {



				ListNode node = new ListNode((Ahead.val + Bhead.val + temp) % 10);



				temp = (Ahead.val + Bhead.val + temp) / 10;



				newtemp.next = node;



				newtemp = newtemp.next;



				Ahead = Ahead.next;



				Bhead = Bhead.next;



			} else if (Ahead == null && Bhead != null) {



				ListNode node = new ListNode((Bhead.val + temp) % 10);



				temp = (Bhead.val + temp) / 10;



				newtemp.next = node;



				newtemp = newtemp.next;



				Bhead = Bhead.next;



			} else if (Ahead != null && Bhead == null) {



				ListNode node = new ListNode((Ahead.val + temp) % 10);



				temp = (Ahead.val + temp) / 10;



				newtemp.next = node;



				newtemp = newtemp.next;



				Ahead = Ahead.next;



			}



		}



		if (temp != 0) {



			ListNode node = new ListNode(temp);



			newtemp.next = node;



			newtemp = newtemp.next;



		}



		return newhead.next;



	}







}

题目描述

输入一个链表，反转链表后，输出链表的所有元素。

代码：




/*



public class ListNode {



    int val;



    ListNode next = null;







    ListNode(int val) {



        this.val = val;



    }



}*/




import java.util.LinkedHashMap;




public class Solution {



    public ListNode ReverseList(ListNode head) {



	       if(head==null){



	    	   return null;



	       }



	       ListNode newhead=null;



	       ListNode phead=head;



	       ListNode prehead=null;



	       while(phead!=null){



	    	   ListNode pnext=phead.next;



	    	   if(pnext==null){



	    		   newhead=phead;



	    	   }



	    	   phead.next=prehead;



	    	   prehead=phead;



	    	   phead=pnext;



	       }



	       return newhead;



    }



}

题目描述

请编写一个函数，检查链表是否为回文。

给定一个链表ListNode* pHead，请返回一个bool，代表链表是否为回文。

测试样例：

{1,2,3,2,1}

返回：true

{1,2,3,2,3}

返回：false

代码：





import java.util.*;







/*



public class ListNode {



    int val;



    ListNode next = null;







    ListNode(int val) {



        this.val = val;



    }



}*/




public class Palindrome {



   public boolean isPalindrome(ListNode pHead) {



		if (pHead == null) {



			return false;



		}



		LinkedList<Integer> linkedList = new LinkedList<Integer>();



		while (pHead != null) {



			linkedList.add(pHead.val);



			pHead = pHead.next;



		}



		return Check(linkedList);



	}







	// 检查是否为回文串




	private boolean Check(LinkedList<Integer> linkedList) {



		boolean result = true;



		int len = linkedList.size();



		int length =len>>1;



		for (int i = 0; i < length; i++) {



			if (linkedList.get(i) != linkedList.get(len - i - 1)) {



				result = false;



				break;



			}



		}



		return result;



	}



}

题目描述

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

代码:





import java.util.Stack;








public class Solution {



    Stack<Integer> stack1 = new Stack<Integer>();



    Stack<Integer> stack2 = new Stack<Integer>();







    public void push(int node) {



        stack1.push(node);



    }







    public int pop() {



    	while(!stack1.isEmpty()){



    		stack2.push(stack1.pop());



    	}



    	int node=stack2.pop();



    	while(!stack2.isEmpty()){



    		stack1.push(stack2.pop());



    	}



    	return node;



    }



}

题目描述

有一些数的素因子只有3、5、7，请设计一个算法，找出其中的第k个数。

给定一个数int k，请返回第k个数。保证k小于等于100。

测试样例：

返回：7

代码：





import java.util.*;








public class KthNumber {



   private static final int Max = (int) (1e5 + 10);



	private static int cnt;



	private static int []A;



	public static int findKth(int k) {



		InitData();



		return A[k];



	}







	private static void InitData() {



		cnt=1;



		int a=0,b=0,c=0;



		A=new int[Max];



		A[0]=1;



		while(cnt<=100){



			int temp=Math.min(A[a]*3, Math.min(A[b]*5, A[c]*7));



			if(temp==A[a]*3)



				a++;



			if(temp==A[b]*5)



				b++;



			if(temp==A[c]*7)



				c++;



			A[cnt++]=temp;



		}



	}



}

题目描述

现在我们有一个int数组，请你找出数组中每个元素的下一个比它大的元素。

给定一个int数组A及数组的大小n，请返回一个int数组，代表每个元素比他大的下一个元素,若不存在则为-1。保证数组中元素均为正整数。

测试样例：

[11,13,10,5,12,21,3],7

返回：[13,21,12,12,21,-1,-1]

代码：





import java.util.*;








public class NextElement {



    public static int[] findNext(int[] A, int n) {



		int []B=new int[n];



		for(int i=0;i<n;i++){



			int temp=-1;



			for(int j=i+1;j<n;j++){



				if(A[i]<A[j]){



					temp=A[j];



					break;



				}



			}



			B[i]=temp;



		}



		return B;



	}



}

题目描述

现在有一个数组，请找出数组中每个元素的后面比它大的最小的元素，若不存在则为-1。

给定一个int数组A及数组的大小n，请返回每个元素所求的值组成的数组。保证A中元素为正整数，且n小于等于1000。

测试样例：

[11,13,10,5,12,21,3],7

[12,21,12,12,21,-1,-1]

代码：





import java.util.*;








public class NextElement {



    public static int[] findNext(int[] A, int n) {



		int []B=new int[n];



		for(int i=0;i<n;i++){



			int temp=Integer.MAX_VALUE;



			boolean ok=false;



			for(int j=i+1;j<n;j++){



				if(A[i]<A[j]){



					ok=true;



					temp=Math.min(temp, A[j]);



				}



			}



			if(ok){



				B[i]=temp;



			}else{



				B[i]=-1;



			}



		}



		return B;



	}



}

题目描述

请编写一个程序，按升序对栈进行排序（即最大元素位于栈顶），要求最多只能使用一个额外的栈存放临时数据，但不得将元素复制到别的数据结构中。

给定一个int[] numbers(C++中为vector<int>)，其中第一个元素为栈顶，请返回排序后的栈。请注意这是一个栈，意味着排序过程中你只能访问到第一个元素。

测试样例：

[1,2,3,4,5]

返回：[5,4,3,2,1]

代码：





import java.util.*;








public class TwoStacks {



    public  ArrayList<Integer> twoStacksSort(int[] numbers) {



		ArrayList<Integer> list=new ArrayList<>();



		if(numbers.length==0){



			return list;



		}



		Stack<Integer> stack1=new Stack<Integer>();



		Stack<Integer> stack2=new Stack<Integer>();



		for(int i=0;i<numbers.length;i++){



			stack1.push(numbers[i]);



		}



		while(!stack1.isEmpty()){



			int temp=stack1.pop();



			while(!stack2.isEmpty()&&stack2.peek()>temp){



				stack1.push(stack2.pop());



			}



			stack2.push(temp);



		}



		int len=stack2.size();



		for(int i=0;i<len;i++){



			list.add(stack2.pop());



		}



		return list;



    }



}

题目描述

实现一个函数，检查二叉树是否平衡，平衡的定义如下，对于树中的任意一个结点，其两颗子树的高度差不超过1。

给定指向树根结点的指针TreeNode* root，请返回一个bool，代表这棵树是否平衡。

代码：





import java.util.*;







/*



public class TreeNode {



    int val = 0;



    TreeNode left = null;



    TreeNode right = null;



    public TreeNode(int val) {



        this.val = val;



    }



}*/




public class Balance {



   public boolean isBalance(TreeNode root) {



		if (root == null)



			return true;



		TreeNode left=root.left;



		TreeNode right=root.right;



		int val=Math.abs(GetHigh(left)-GetHigh(right));//判断左数和右树的高度差




		if(val>1)//如果大于1，不符合




			return false;



		//如果不大于1，继续判断左树的子树和右树的子树




		return isBalance(left)&&isBalance(right);



	}



	//获取一棵树的高度




	private int GetHigh(TreeNode root){



		if(root==null)



			return 0;



		int lefthigh=GetHigh(root.left);



		int righthigh=GetHigh(root.right);



		return lefthigh>righthigh?(lefthigh+1):(righthigh+1);



	}



}

题目描述

对于一个有向图，请实现一个算法，找出两点之间是否存在一条路径。

给定图中的两个结点的指针UndirectedGraphNode* a,UndirectedGraphNode*b(请不要在意数据类型，图是有向图),请返回一个bool，代表两点之间是否存在一条路径(a到b或b到a)。

代码：





import java.util.*;




import java.util.ArrayList;



/*



public class UndirectedGraphNode {



    int label = 0;



    UndirectedGraphNode left = null;



    UndirectedGraphNode right = null;



    ArrayList<UndirectedGraphNode> neighbors = new ArrayList<UndirectedGraphNode>();







    public UndirectedGraphNode(int label) {



        this.label = label;



    }



}*/




public class Path {



    public boolean checkPath(UndirectedGraphNode a, UndirectedGraphNode b) {



		if(a==b){



			return true;



		}



		HashMap<UndirectedGraphNode, Boolean> map=new HashMap<UndirectedGraphNode, Boolean>();



		boolean ok=Check(a,b,map);//从a开始找，b不动




		map.clear();



		return ok||Check(b,a,map);//从b开始找，a不动




    }



	private boolean Check(UndirectedGraphNode a, UndirectedGraphNode b,HashMap<UndirectedGraphNode, Boolean> map){



		if(a==b){



			return true;



		}



		map.put(a, true);



		for(int i=0;i<a.neighbors.size();i++){//从a的邻居找，看看有没有等于b的




			if(!map.containsKey(a.neighbors.get(i))&&Check(a.neighbors.get(i), b, map)){



				return true;



			}



		}



		return false;



	}







}

题目描述

对于一个元素各不相同且按升序排列的有序序列，请编写一个算法，创建一棵高度最小的二叉查找树。

给定一个有序序列int[] vals,请返回创建的二叉查找树的高度。

代码：





import java.util.*;








public class MinimalBST {



    public int buildMinimalBST(int[] vals) {



		int length=vals.length;



		if(length==0){



			return 0;



		}



		int sum=1;



		for(int i=1;i<=10000;i++){



			sum<<=1;



			if(sum-1>=length){



				return i;



			}



		}



		return 0;



    }



}

题目描述

对于一棵二叉树，请设计一个算法，创建含有某一深度上所有结点的链表。

给定二叉树的根结点指针TreeNode* root，以及链表上结点的深度，请返回一个链表ListNode，代表该深度上所有结点的值，请按树上从左往右的顺序链接，保证深度不超过树的高度，树上结点的值为非负整数且不超过100000。

代码：





import java.util.*;







/*



public class ListNode {



    int val;



    ListNode next = null;







    ListNode(int val) {



        this.val = val;



    }



}*/



/*



public class TreeNode {



    int val = 0;



    TreeNode left = null;



    TreeNode right = null;



    public TreeNode(int val) {



        this.val = val;



    }



}*/




public class TreeLevel {



   public ListNode getTreeLevel(TreeNode root, int dep) {



		ListNode listNode=new ListNode(-1);



		ListNode head=listNode;



		if(root==null||dep==0){



			return null;



		}



		Queue<TreeNode> queue=new LinkedList<TreeNode>();



		queue.add(root);



		int ans=1;



		while(!queue.isEmpty()){



			int size=queue.size();



			if(ans==dep){



				for(int i=0;i<size;i++){



					TreeNode node=queue.poll();



					ListNode newhead=new ListNode(node.val);



					head.next=newhead;



					head=head.next;



				}



				break;



			}else{



				for(int i=0;i<size;i++){



					TreeNode node=queue.poll();



					TreeNode left=node.left;



					TreeNode right=node.right;



					if(left!=null){



						queue.add(left);



					}



					if(right!=null){



						queue.add(right);



					}



				}



			}



			ans++;



		}







		return listNode.next;







	}



}

题目描述

请实现一个函数，检查一棵二叉树是否为二叉查找树。

给定树的根结点指针TreeNode* root，请返回一个bool，代表该树是否为二叉查找树。

代码：





import java.util.*;







/*



public class TreeNode {



    int val = 0;



    TreeNode left = null;



    TreeNode right = null;



    public TreeNode(int val) {



        this.val = val;



    }

上一篇：从m个数中获取n个不同的数

下一篇：白鹭引擎一些知识

Java数据结构、算法面试题

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

输出描述:

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

题目描述

【数据结构与算法01】栈

Java数据结构、算法面试题

数据结构和算法01-序列赋值

数据结构与算法面试题

数据结构与算法01概述

[Java数据结构]简单排序之冒泡排序

图论算法（二）-最短路径的Dijkstra [ 单源 ] 和Floyd[ 多源 ] 解法（JAVA ）

Java实现Dijkstra算法（算法分析与设计作业）

JAVA面试题--两个正序排序的数组，求合并后的第K个（非算法）

JAVA算法：最后一个单词的长度（JAVA代码）