程序员面试金典:双栈排序、二叉平衡检查、输出单层节点

学习并总结了牛客网上的《程序员面试经典》的部分算法题

1.双栈排序

题目描述
测试样例：

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

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

[1,2,3,4,5]

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

public class TwoStacks {
	//双栈排序
    public ArrayList<Integer> twoStacksSort(int[] numbers) {
    	ArrayList<Integer> list=new ArrayList<Integer>();
        Stack<Integer> s1=new Stack<Integer>();
        Stack<Integer> s2=new Stack<Integer>();
        
        if(numbers==null||numbers.length==0)	return null;
        for(int i=0;i<numbers.length;i++){
            s1.push(numbers[i]);
        }
        while(!s1.isEmpty()){
            int top=s1.pop();
            while(!s2.isEmpty()&&s2.peek()>top){
                s1.push(s2.pop());
            }
            s2.push(top);
        }
        
        while(!s2.isEmpty()){
            list.add(s2.pop());
        }
          return list;
    }
}

2.二叉平衡检查

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

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

/*二叉树的递归一直搞的迷迷糊糊的，只能先Mark下以后慢慢理解吧*/
class TreeNode{
	TreeNode left=null;
	TreeNode right=null;
	int data;
	
	public TreeNode(int data){
		data=data;
	}
}

public class BinTree {
	public static void main(String[] args) {
		TreeNode t1=new TreeNode(1);
		TreeNode t2=new TreeNode(2);
		TreeNode t3=new TreeNode(3);
		TreeNode t4=new TreeNode(4);
		TreeNode t5=new TreeNode(5);
		TreeNode t6=new TreeNode(6);
		TreeNode t7=new TreeNode(7);
		TreeNode t8=new TreeNode(8);
		TreeNode t9=new TreeNode(9);
		TreeNode t10=new TreeNode(10);
		TreeNode t11=new TreeNode(11);
		
		t1.left=t2;		t1.right=t3;
		t2.left=t4;		t2.right=t5;
		t3.left=t6;		t3.right=t7;
		t4.left=t8;		t4.right=t9;
		t8.left=t10;	t8.right=t11;
		
		System.out.println(getLen(t1));
		System.out.println(isBalance(t1));
	}
	
	public static boolean isBalance(TreeNode root) {
		if(root==null)	return true;
		else{
			int left=getLen(root.left);
			int right=getLen(root.right);
			if(Math.abs(left-right)<=1){
				return isBalance(root.left)&&isBalance(root.right);
			}else{
				return false;
			}
		}
	}
	
	//遍历求树的高度
	public static int getLen(TreeNode r){
		if(r==null)	return 0;
		else{
			int left=getLen(r.left);
			int right=getLen(r.right);
			return left>right?left+1:right+1;
		}
	}
}

3.输出单层节点

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

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

public class Demo1 {
	static ListNode head=new ListNode(-1);
	static ListNode node=head;
	public static void main(String[] args) {
		TreeNode t1=new TreeNode(1);
		TreeNode t2=new TreeNode(2);
		TreeNode t3=new TreeNode(3);
		TreeNode t4=new TreeNode(4);
		TreeNode t5=new TreeNode(5);
		TreeNode t6=new TreeNode(6);
		TreeNode t7=new TreeNode(7);
		
		t1.left=t2;
		t1.right=t3;
		t2.left=t4;
		t2.right=t5;
		t3.left=t6;
		t3.right=t7;
		
		ListNode tt=getTreeLevel(t1,3);
		while(tt!=null){
			System.out.print(tt.val+"->");
			tt=tt.next;
		}
	}
	
	public static ListNode getTreeLevel(TreeNode root, int dep) {
		if(root==null||dep<=0)	return null;
		if(dep==1){
			node.next=new ListNode(root.val);
			node=node.next;
		}else{
			getTreeLevel(root.left, dep-1);
			getTreeLevel(root.right, dep-1);
		}
		return head.next;
	}
public static ListNode getTreeLevel2(TreeNode root, int dep) {
		ListNode head=new ListNode(-1);
		ListNode p=head;
		Queue<TreeNode> queue=new LinkedList<TreeNode>();
		queue.offer(root);
		int level=1;
    	// 	1->2->3->4->5->6->7
		while(!queue.isEmpty()){
			int size=queue.size();
			//	用for循环来控制层数
			for (int i = 0; i < size; i++) {
					TreeNode temp=queue.poll();
					if(level==dep){
						p.next=new ListNode(temp.val);
						p=p.next;
					}else{
						if(temp.left!=null){
							queue.offer(temp.left);
						}
						
						if(temp.right!=null){
							queue.offer(temp.right);
						}
					}
				}
				level++;
			}
		return head.next;
	}
}