java - 对传递给 java 函数的变量值感到困惑

Question

我有一个实现选择排序的函数。排序工作正常。然而，不知何故，传入的头部从函数体的末尾更改为函数调用。不要看整个代码，只看函数调用和函数的最后一行。

import java.util.*;


public class Sorting<E>
{

public static void sort( ListNode<String> head )
{
    if ( head == null )
        return;

    int eff_size;
    int size = 0;

    ListNode<String> last = null;

    for ( ListNode<String> node = head; node != null; node = node.getNext() )
    {
        size++;
    }

    System.out.println( "size is " + size );

    for ( eff_size = size; eff_size > 1; eff_size-- )
    {
        ListNode<String> biggest = head;
        ListNode<String> node = head;
        ListNode<String> biggestprevious = null;

        for ( int i = 0; i < eff_size-1; i++ )
        {
            if ( node.getNext() == null )
                break;

            if ( node.getNext().getValue().compareTo( biggest.getValue() ) > 0 )
            {
                biggestprevious = node;
                biggest = node.getNext();

            }
            node=node.getNext();
        }

        if (biggest.getNext()!=null){
            if (biggestprevious!=null && biggest.getNext()!=last){
                biggestprevious.setNext( biggest.getNext() );
            }
            if (head == biggest){
                head = biggest.getNext();
        }

            biggest.setNext( last );
            System.out.println(" node is " + node.getValue());

            if (node != biggest){
                node.setNext(biggest);
            }
        }

        last = biggest;

    }

     System.out.println("head at function end is - " + head.getValue());
}

public static <E> ListNode<E> buildList( E[] values )
{
    ListNode<E> head = null;
    ListNode<E> tail = null;
    for ( E value : values ) // for each value to insert
    {
        ListNode<E> node = new ListNode<E>( value, null );
        if ( head == null )
        {
            head = node;
        }
        else
        {
            tail.setNext( node );
        }
        tail = node; // update tail
    }

    return head;
}

public static void main( String[] args )
{
    Scanner kbd = new Scanner( System.in );
    boolean done = false;

    Sorting<String> ex = new Sorting<String>();

    do
    {
        System.out.println();
        System.out.println( "   (D) sort( ListNode<String> head )" );
        System.out.println( "   (Q) Quit" );
        System.out.println();
        System.out.print( "Enter a choice:  " );
        String response = kbd.nextLine();

        if ( response.length() > 0 )
        {
            System.out.println();

            switch ( response.charAt( 0 ) )
            {

                case 'D':
                case 'd':
                    ListNode<String> headD = buildList( new String[] {
                       "B", "F", "K", "Q", "Ant", "Aardvark",
                       "apple" } );


                    System.out.println("head before function call is - " + headD.getValue());
                    sort( headD );
                    System.out.println("head after function call is - " + headD.getValue());

                    break;

                default:
                    if ( response.toLowerCase().charAt( 0 ) == 'q' )
                    {
                        done = true;
                    }
                    else
                    {
                        System.out.print( "Invalid Choice" );
                    }
                    break;
            }
        }
    } while ( !done );
    System.out.println( "Goodbye!" );
}

}

我得到的输出:

函数结束处的头部是 - Aardvark

函数调用之前的头是 - B

函数调用后的头部是 - B

我知道列表已排序，因为在函数末尾我做了:

System.out.println("---------------------------------");
for ( ListNode<String> node = head; node != null; node = node.getNext() )
{

    System.out.println(node.getValue());
}

我得到:

Aardvark
Ant
B
F
K
Q
apple

但是不知怎的，头却乱了!

我不明白头部是如何保持为“B”的。我是 Java 的初学者(高中)，据我了解， head 是通过引用传递的，因此它应该在函数内部进行更改，并且更改应该得到反射(reflect)。将不胜感激任何帮助。

Answer 1

您正在传递对单个 ListNode 的引用 - 包含“B”的 ListNode。不要将其与表示整个列表的对象混淆 - 您的列表处理库似乎没有提供这些东西(与 Java 自己的列表实现相反)。

在排序程序中，您需要跟踪包含最小值的节点并返回该节点(猜测:return head;)，替换主程序中的 headD:

headD = sort( headD );

请注意，更改排序中的 head 没有帮助:head 是一个引用，并且是按值传递的，因此任何更改在调用时都不可见。