code(03)

       一、输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

      

 public  ArrayList<Integer> printMatrix(int [][] matrix) {
		 ArrayList<Integer> list=new ArrayList();
	     int width=matrix.length-1;
	     int len=matrix[0].length-1;
		  int k=0; //第k次循环
		  while(k<=len-k){
			  
			  if(k>len-k)
				  break;
			  for(int j=k;j<=len-k;j++)
				  list.add(matrix[k][j]); 
			  if(k+1>width-k)
				  break;
			  for(int i=k+1;i<=width-k;i++)
				  list.add(matrix[i][len-k]);
			  if(len-k-1<k)
				  break;
			  for(int j=len-k-1;j>=k;j-- )
				  list.add(matrix[width-k][j]);
			  if(width-k-1<k+1)
				  break;
			  for(int i=width-k-1;i>=k+1;i--)
				  list.add(matrix[i][k]);
			  k++;
			  
		  }
		  return list;
		    
	    }

    二、输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

        优秀代码真的好简洁明了，优秀的同学，绝对是优秀的同学

        

 public boolean IsPopOrder(int [] pushA,int [] popA) {
		   if(pushA.length==0)
			   return false;
		   Stack<Integer> stack=new Stack();
		   for(int i=0,j=0;i<pushA.length;){
			    stack.push(pushA[i++]);
			    while(j<popA.length&&stack.peek()==popA[j]){
			    	stack.pop();
			        j++;
		       }
		   }
		   return stack.isEmpty();	           
	   }

        三、输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。

           方法1.暴力破解，以O(n2)的时间复杂度找到每一个结点的随机指针域

        方法2：利用哈希表，将<N,N'>作为键值对存入，O(N)的时间复杂度将next域串起来，然后再一次遍历找到N.random所对应的value值。以O(n)的空间复杂度把时间复杂度降到O(n).

          方法三：最优解，时间复杂度O(n)

          

/*
	public class RandomListNode {
	    int label;
	    RandomListNode next = null;
	    RandomListNode random = null;

	    RandomListNode(int label) {
	        this.label = label;
	    }
	}
	*/
	
	 public RandomListNode Clone(RandomListNode pHead)
	    {
		    if(pHead==null)
		    	return null;
	        CloneNodes(pHead);
	        ConnectSibilingNodes(pHead);
	        return ReconnectNodes(pHead);
	          
	    }
	    //复制结点并放在每一个被复制的之后
	   public void CloneNodes(RandomListNode pHead){
	         RandomListNode p=pHead;
	        while(p!=null){
	            RandomListNode newNode=new RandomListNode(p.label);
	            newNode.next=p.next;
	            p.next=newNode;
	            p=newNode.next;
	        }  
	    }
	    //复制pSibiling指的那一部分
	    public void ConnectSibilingNodes(RandomListNode pHead){
	         RandomListNode p=pHead;
	         while(p!=null){
	             RandomListNode RandomNode=p.random;
	             if(RandomNode==null)
	                 p.next.random=null;
	             else
	                 p.next.random=RandomNode.next;
	             p=p.next.next;
	         }
	    }
	    //按照奇偶数将两个链表分开
	    public RandomListNode ReconnectNodes(RandomListNode pHead){
	         RandomListNode p=pHead;
	         RandomListNode q=p.next;
	         RandomListNode newHead=q;
	         while(q.next!=null){
	             p.next=q.next;
	             q.next=q.next.next;
	             q=q.next;
	             p=p.next;  
	         }
	          p.next=null;
	         return newHead;
	    }