线性表（链表、数组）与栈

调整数组顺序使奇数位于偶数前面 
//方法一
public class Solution {
    public void reOrderArray(int [] array) {
        int[] a=new int[array.length];
        int m=0;
        for(int i=0;i<array.length;i++){    //先遍历数组找到所有奇数，并加入数组a中
            if(array[i]%2==1)
                a[m++]=array[i];
        }
        for(int j=0;j<array.length;j++){    //(此时的数组a已经包含所有的奇数)再遍历数组找到所有偶数，并追加到数组a中
            if(array[j]%2==0)
                a[m++]=array[j];
        }
        for(int n=0;n<a.length;n++){        //最后把数组a赋给原来数组array
                array[n]=a[n];
        }
    }
}
//方法二
import java.util.Stack;
public class Solution{
    Stack<Integer> stack1=new Stack<Integer>();
    Stack<Integer> stack2=new Stack<Integer>();
    int k=0;
    public void reOrderArray(int[] array){
        for(int i=0;i<array.length;i++){         //先遍历数组找到所有奇数压如Stack1中
            if(array[i]%2==1)
                stack1.push(array[i]);
        }
        for(int j=0;j<array.length;j++){         //再遍历数组找到所有偶数压如Stack1中
            if(array[j]%2==0)
                stack1.push(array[j]);
        }
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());           //将Stack1中的所有数出栈，并压入Stack2中
        }
        while(!stack2.isEmpty()){
            array[k++]=stack2.pop();              //stack2出栈并保存在数组中
        }
        
    }
}

链表中倒数第k个结点
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
import java.util.Stack;
public class Solution {
    
    public ListNode FindKthToTail(ListNode head,int k) {
        Stack<ListNode> stack=new Stack<ListNode>();    //思想：将所有的链表元素压栈，并记录元素节点个数
        int num=0;
        while(head!=null){
            num++;                                       //统计节点个数
            stack.push(head);
            head=head.next;
        }
        while(!stack.isEmpty()&&k>0){
           if(k>num){                                    //特别注意！！！ 要打印的节点的位置不能大于节点个数
               return null;
           }
            head=(ListNode)stack.pop();
            k--;                                         //对栈的弹出加限制，得到想要的节点
        }
        return head;

    }
}

输入一个链表，反转链表后，输出链表的所有元素。 
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
import java.util.Stack;
public class Solution {
    
    public ListNode ReverseList(ListNode head) {
        Stack<Integer> stack=new Stack<Integer>();   //思想：保持链表结构不变，将各个节点中的数字重新覆盖
        ListNode p1=head;                    //让p1指向头结点，向后遍历，将各个节点值压栈
        while(p1!=null){
            stack.push(p1.val);
            p1=p1.next;
        }
        ListNode p2=head;                    //让P2指向头结点，向后遍历，将出栈的值依次覆盖到各个节点中
        while(!stack.isEmpty()){
            p2.val=(Integer)stack.pop();
            p2=p2.next;
        }
        return head;                          //返回头结点（此时链表的结构没变，只是各个节点的值被改变）
    }
}

合并两个排序的链表 
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
import java.util.Stack;
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        Stack<ListNode> stack1=new Stack<ListNode>();           //思想：同时从链表的头结点开始比较，将较小的节点压入栈Stack1中，
        Stack<ListNode> stack2=new Stack<ListNode>();           //同时向后移动节点值较小的链表的指针，继续比较并压栈，直至链表
        ListNode listHeadMove=new ListNode(0);                  //list1或list2结束。再将栈stack1中的节点出栈并压如栈stack2中，
        ListNode listHead=listHeadMove;                         //最终让stack2出栈。
        while(list1!=null&&list2!=null){
                if(list1.val<list2.val){
                      stack1.push(list1);                       //将较小的压入栈Stack1中
                      list1=list1.next;
                 }else{
                      stack1.push(list2);                       //将较小的压入栈Stack1中
                      list2=list2.next;
                }
        }
        while(list1!=null){
            stack1.push(list1);                                 //list2结束，将剩余的list1压栈Stack1中
            list1=list1.next;
        }
        while(list2!=null){
            stack1.push(list2);                                  //list1结束，将剩余的list2压栈Stack1中
            list2=list2.next;
        }
        
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());                           //栈stack1中的节点出栈并压如栈stack2中
        }
        while(!stack2.isEmpty()){
            listHeadMove.next=stack2.pop();                       //stack2出栈
            listHeadMove=listHeadMove.next;
           
        }
        listHead=listHead.next;
        return listHead;
    }
}