链表的合并排序java：堆栈溢出

我正在尝试实现一个链表合并排序

这是我尝试在其中进行合并排序的类

/**
 * CS 200 Colorado State University, Fall 2011
 */

public class Member {

private String userID;
private String first;
private String last;
private EdgeStack edgeStack;

public void sortScore(Member member){
    // calling a helper method
    // this greedy method takes all the creds 
    edgeStack = sortEdgeStack(member); 
}

private EdgeStack sortEdgeStack(Member member)
{
    // our temp stacks
    EdgeStack tempEdgeStack_A = new EdgeStack();
    EdgeStack tempEdgeStack_B = new EdgeStack();

    // our return value 
    EdgeStack result = null; 
    // storing the size of the stack 
    int sizeOfStack = member.getEdgeStack().getSize();
    // base case 
    if(sizeOfStack<0){
        return null; 
    }
    // our true base case
    else if(sizeOfStack==1) 
    { 
        // init stack
        EdgeStack base = new EdgeStack(); 

        base.push(member.getEdgeStack().pop());
        return base; 
    }
    else
    {

        // pop and store 
        for(int i = 0; i < (sizeOfStack / 2); i++)
        {
            tempEdgeStack_A.push(member.getEdgeStack().pop()); 
        }
        // pop and store into b
        for(int j = (sizeOfStack/2)+1; j < sizeOfStack; j++)
        {
            tempEdgeStack_B.push(member.getEdgeStack().pop());
        }

        tempEdgeStack_A = sortEdgeStack(member);
        tempEdgeStack_B = sortEdgeStack(member);
        result = merge(tempEdgeStack_A,tempEdgeStack_B); 
        return result;
    }
}


private EdgeStack merge(EdgeStack tempEdgeStack_A, EdgeStack tempEdgeStack_B) {

    EdgeStack result = new EdgeStack(); 

    // while either or
    while(tempEdgeStack_A.getSize()> 0 || tempEdgeStack_B.getSize() > 0)
    {
        // if both are bigger then 0 
        if(tempEdgeStack_A.getSize()> 0 && tempEdgeStack_B.getSize() > 0)
        {
            if(tempEdgeStack_A.peek().getEdgeRank()<=tempEdgeStack_B.peek().getEdgeRank())
            {
                // adds b to result
                result.push(tempEdgeStack_A.pop()); 
            }
            else 
            {
                result.push(tempEdgeStack_B.pop());
            }
        }
        // these elses cover if A or B are > 0 but A or B is also less then or equal too 0; 
        else if(tempEdgeStack_A.getSize()> 0)
        {
            while(tempEdgeStack_A.iterator().hasNext())
            {
                result.push(tempEdgeStack_A.iterator().next()); 
            }
        }
        else if(tempEdgeStack_B.getSize()> 0)
        {
            while(tempEdgeStack_B.iterator().hasNext())
            {
                result.push(tempEdgeStack_B.iterator().next()); 
            }
        }
    }

    return result; 
}
 }

/**
*CS 200科罗拉多州立大学，2011年秋季
*/
公共班级成员{
私有字符串用户标识；
私有字符串优先；
私有字符串最后；
私人EdgeStack EdgeStack；
公共无效SortCore（成员）{
//调用助手方法
//这种贪婪的方法使人丧失了所有的信誉
edgeStack=分拣机堆栈（成员）；
}
专用EdgeStack sortEdgeStack（成员）
{
//我们的临时堆栈
EdgeStack TEMPEGESTACK_A=新EdgeStack（）；
EdgeStack TEMPEGESTACK_B=新EdgeStack（）；
//我们的回报价值
EdgeStack结果=空；
//存储堆栈的大小
int-sizeOfStack=member.getEdgeStack（）.getSize（）；
//基本情况
if（sizeOfStack 0 | | tempEdgeStack|B.getSize（）>0）
{
//如果两者都大于0
if（tempEdgeStack_A.getSize（）>0&&tempEdgeStack_B.getSize（）>0）
{
如果（tempEdgeStack_A.peek（）.getEdgeRank（）为0，但A或B也小于或等于0；
else if（tempEdgeStack_A.getSize（）>0）
{
while（tempEdgeStack_A.iterator（）.hasNext（））
{
push（tempEdgeStack_A.iterator（）.next（））；
}
}
else if（tempEdgeStack_B.getSize（）>0）
{
while（tempEdgeStack_B.iterator（）.hasNext（））
{
push（tempEdgeStack_B.iterator（）.next（））；
}
}
}
返回结果；
}
}

这是stack类（它实现了一个链表）。为什么会出现堆栈溢出错误

import java.util.LinkedList;
import java.util.ListIterator;

/**
 * CS 200 Colorado State University, Fall 2011
 */

public class EdgeStack {


private LinkedList<Edge> llist=new LinkedList<Edge>();

public EdgeStack(){
    //add your code
}

public boolean isEmpty(){
    return llist.isEmpty();
}

public void push(Edge e){
    llist.add(e);
}

public Edge getIndexAt(int n){
    return llist.get(n);
}

public Edge pop(){
    return llist.remove();
}

public Edge peek(){

    return llist.getLast();
}

public int getSize(){
    return llist.size();
}

//  public Edge peek(int n){
//      LinkedList<Edge> temp=llist;
//      return temp.peek();
//  }


public LinkedList<Edge> popAll(){
    LinkedList<Edge> temp=llist;
    llist=null;
    return temp;    }

public ListIterator<Edge> iterator()
{
    return llist.listIterator();
}

}

import java.util.LinkedList；
导入java.util.ListIterator；
/**
*CS 200科罗拉多州立大学，2011年秋季
*/
公共级EdgeStack{
私有LinkedList llist=新LinkedList（）；
公共EdgeStack（）{
//添加您的代码
}
公共布尔值为空（）{
返回llist.isEmpty（）；
}
公共空间推送（边缘e）{
添加（e）；
}
公共边缘getIndexAt（int n）{
返回list.get（n）；
}
公共边缘流行音乐（）{
返回list.remove（）；
}
公共边缘窥视（）{
返回list.getLast（）；
}
公共int getSize（）{
返回list.size（）；
}
//公共边缘窥视（int n）{
//LinkedList temp=llist；
//返回温度peek（）；
//  }
公共链接列表popAll（）{
LinkedList temp=llist；
llist=null；
返回温度；}
公共列表迭代器迭代器（）
{
返回llist.listIterator（）；
}
}

检查以下内容：

    else if(tempEdgeStack_A.getSize()> 0)
    {
        while(tempEdgeStack_A.iterator().hasNext())
        {
            result.push(tempEdgeStack_A.iterator().next()); 
        }
    }
    else if(tempEdgeStack_B.getSize()> 0)
    {
        while(tempEdgeStack_B.iterator().hasNext())
        {
            result.push(tempEdgeStack_B.iterator().next()); 
        }
    }

---

你不从栈中删除条目，所以循环不停止。这里有一些建议：如果你张贴这么多代码，考虑使用代码粘贴服务。同样，你所发布的代码没有编译，因为边缘类丢失了，现在我可以测试它，因为没有主方法。如果你得到一个Excel在Java程序中，请确保发布stacktrace。人们通常乐于提供帮助，但您也需要付出一些努力；）