c/c++和java实现swap函数的不同处

c/c++和java实现swap函数的不同处

2014-05-06 11:59
2255人阅读 评论(0)
收藏
举报

本文章已收录于：


分类：
C/C++ Vs Java（2）




作者同类文章X

版权声明：本文为博主原创文章，未经博主允许不得转载。

首先我们来看一下在c/c++中实现的swap函数

[cpp]
view plain
copy
print?

void  swap ( int & a, int & b)      
{      
    int  Temp;      
    temp = a;      
    a = b;      
    b = temp;      
}  

void  swap ( int & a, int & b)
{
int  Temp;
temp = a;
a = b;
b = temp;
}

那么在java中是否还能这样呢，很显然java中没有地址引用符号了。

首先我们来看下c/c++和java的区别。

本质区别

C/C++中swap功能的本质：通过传递变量地址(指针或引用)来交换变量地址中的值。

Java标榜其中对C/C++一个很大的改进就是：Java对程序员屏蔽了变量地址的概念，减少指针误用。

在Java世界中函数或者叫方法的入参都是通过值拷贝的方式进行传递：

原始类型(char，int，double等）都是通过直接拷贝变量值传参；
对象类型都是通过引用拷贝(跟C++中引用不同)传参，通过该引用能够更改其指向的对象内部值，但是更改该引用值，仅对函数内部可见，函数外部的实参依然没有改变；
从上面可以看出通过地址的方式在java中是不可能实现的，因为java严格遵循值传递(pass-by-value)。

java传递是引用的拷贝，既不是引用本身，更不是对象。

但没有解决不了的问题，我们可以利用其他方法来实现：

Method1：用数组交换值（对于数组中的元素的交换，所以经常在排序中看到）

[java]
view plain
copy
print?





Public  static  void  swap ( int [] Data,  int  a,  int  b) {  
        int  t = Data [a];      
        data [a] = data ;      
        data [b] = t;      
}  

Public  static  void  swap ( int [] Data,  int  a,  int  b) {
int  t = Data [a];
data [a] = data [b];
data [b] = t;
}

Method2：用重定义类（自己定义的）

[b][java]
view plain
copy
print?





Class  MyInteger {         
    Private  int  x;     / / the x as the only data member       
    Public  MyInteger ( int  xIn) {x = xIn;}  / / Constructor       
    Public  int  getValue () {  return  x;}   / / get the value        
    Public  void  insertValue ( int  xIn) {x = xIn;}  / / change the value of the      
}      
   
Public  Class  Swapping {         
    / / Swap: pass object references       
    static  void  swap (MyInteger rWrap, MyInteger sWrap) {            
        / / Change the value of the process           
        int  t = rWrap.getValue ();            
        rWrap.insertValue (sWrap.getValue ());            
        sWrap.insertValue (t);         
    }         
    Public  static  void  main (String [] args) {            
        int  a =  23 , b =  47 ;            
        System.out.println ( "Before. a:"  + a +  ", b:"  + b);            
        MyInteger AWRAP =  new  MyInteger (a);            
        MyInteger bWrap =  new  MyInteger (b);            
        swap (aWrap, bWrap);            
        a = aWrap.getValue ();            
        b = bWrap.getValue ();            
        System.out.println ( "After. a:"  + a +  ", b:"  + b);         
    }      
}  

Class  MyInteger {
Private  int  x;     / / the x as the only data member
Public  MyInteger ( int  xIn) {x = xIn;}  / / Constructor
Public  int  getValue () {  return  x;}   / / get the value
Public  void  insertValue ( int  xIn) {x = xIn;}  / / change the value of the
}

Public  Class  Swapping {
/ / Swap: pass object references
static  void  swap (MyInteger rWrap, MyInteger sWrap) {
/ / Change the value of the process
int  t = rWrap.getValue ();
rWrap.insertValue (sWrap.getValue ());
sWrap.insertValue (t);
}
Public  static  void  main (String [] args) {
int  a =  23 , b =  47 ;
System.out.println ( "Before. a:"  + a +  ", b:"  + b);
MyInteger AWRAP =  new  MyInteger (a);
MyInteger bWrap =  new  MyInteger (b);
swap (aWrap, bWrap);
a = aWrap.getValue ();
b = bWrap.getValue ();
System.out.println ( "After. a:"  + a +  ", b:"  + b);
}
}

Method3：外部内联法

[java]
view plain
copy
print?





Public  Class  Swap2 {       
    Public  static  void  main (String args []) {       
        Swap2 SW =  new  Swap2 ( 1 , 2 );       
        System.out.println ( "i is"  + sw.i);       
        System.out.println ( "J is"  + sw.j);       
        sw.swap ();       
        System.out.println ( "i is"  + sw.i);       
        System.out.println ( "J is"  + sw.j);       
    }       
    int  i, J;       
    Public  Swap2 ( int  i,  int  J) {       
        this . i = i;       
        this . J = J;       
    }       
   
    Public   void  swap () {       
        int  Temp;       
        temp = i;       
        i = j;       
        j = temp;       
    }       
}       
   
Public  Class  swap1 {       
    Public  static  void  swap1 (Integer a, Integer b) {       
        Integer temp = a;       
        a = b;       
        b = temp;       
    }       
    Public   static   void  main (String args []) {       
        Integer a, b;       
        a =  new  Integer ( 10 );       
        b =  new  Integer ( 20 );       
        Swap1.Swap1 (a, b);       
        System.out.println ( "a is"  + a);       
        System.out.println ( "b is"  + b);       
    }       
}  

Public  Class  Swap2 {
Public  static  void  main (String args []) {
Swap2 SW =  new  Swap2 ( 1 , 2 );
System.out.println ( "i is"  + sw.i);
System.out.println ( "J is"  + sw.j);
sw.swap ();
System.out.println ( "i is"  + sw.i);
System.out.println ( "J is"  + sw.j);
}
int  i, J;
Public  Swap2 ( int  i,  int  J) {
this . i = i;
this . J = J;
}

Public   void  swap () {
int  Temp;
temp = i;
i = j;
j = temp;
}
}

Public  Class  swap1 {
Public  static  void  swap1 (Integer a, Integer b) {
Integer temp = a;
a = b;
b = temp;
}
Public   static   void  main (String args []) {
Integer a, b;
a =  new  Integer ( 10 );
b =  new  Integer ( 20 );
Swap1.Swap1 (a, b);
System.out.println ( "a is"  + a);
System.out.println ( "b is"  + b);
}
}

总结：
数组中的元素交换，可以使用下文中的public static void swap(int[] data, int a, int b)方法；
非数组中的元素交换，可以使用最原始的交换方法，可以实现交换；也可以使用上面提到的重定义类的方式、外部内联的方式，视情况而定



顶1踩0
 
 

上一篇《Thinking in Algorithm》16.堆结构之斐波那契堆
下一篇c语言之struct

public  class  Swap1 {      

   public  static  void  Swap1 (Integer a, Integer b) {      

       Integer temp = a;      

       a = b;      

       b = temp;      

   }

     

   public   static   void  main (String args []) {      

       Integer a, b;      

       a =  new  Integer ( 10 );      

       b =  new  Integer ( 20 );      

       Swap1.Swap1 (a, b);      

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

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

   } 

//javac Swap1.java

//java Swap1

//a is10

//b is20

}