指针：

指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；

可以是空值，可以在任何时候被初始化。

指针的值在初始化后可以改变，即指向其它的存储单元。

sizeof 指针 得到的是指针本身的大小。

引用：

跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。

引用不可以为空，当被创建的时候，必须初始化。

引用在进行初始化后就不会再改变了。

sizeof 引用 得到的是所指向的对象的大小。

指针示例

int a=1;
int *p=&a;

定义了一个整形变量和一个指针变量p，该指针变量指向a的存储单元，即p的值是a存储单元的地址。

引用示例

int a=1;
int &b=a;

定义了一个整形变量a和这个整形a的引用b。事实上a和b是同一个东西，在内存占有同一个存储单元。

BJFUOJ

以节点为引用传递参数,以引用的方式传递

遍历指针的实现方式是创建一个新节点，以拷贝当前遍历节点

void DeleteEqualValueNode(ListNode& L)
{
	//遍历指针 
	ListNode p;
	//越过头节点，从第一个节点开始遍历 
	p=L->next; 
	
	//双指针：删除操作需要一前一后两个指针 
	ListNode front,back;
	
    //遍历链表：遍历每一个元素，查找后续与之重复的节点，重复则删除。 
    while(p->next)
    {
    	//后指针指向当前遍历位置 
        back=p;
        //前指针指向当前遍历位置的前一个位置 
        front=back->next;
        //前面有节点时 
        while(front)
        {
        	//前后节点值相同，就删除前面的节点 
            if(front->val==p->val)///重复判断
            {
            	//从链表里删除节点 
                back->next=front->next;
                //从内存中删除节点，释放内存
                delete front; 
                //前指针指向后指针的前一位 
                front=back->next; 
            }
            //前后节点值不同，两个指针一同向前滑动一位，相当于一个滑动窗口，永远保持一前一后的相邻状态 
            else
            {
                back=front;
                front=front->next;
            }
        }
        //如果前面还有节点，就向前遍历 
        if(p->next)
        {
            p=p->next;
        }
    }
}

以节点类型的指针作为参数传递，传的是地址

遍历指针的实现方式是创建一个节点类型的指针，存放当前遍历节点的地址。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
ListNode* removeDuplicateNodes(ListNode* L)
{
	//遍历指针 
	ListNode* p;//=new ListNode();
	//头节点也存储有效值
	p=L; 
	
	//双指针：删除操作需要一前一后两个指针 
	ListNode* front;
    ListNode* back;
	
    //遍历链表：遍历每一个元素，查找后续与之重复的节点，重复则删除。 
    while(p&&p->next)
    {
    	//后指针指向当前遍历位置 
        back=p;
        //前指针指向当前遍历位置的前一个位置 
        front=back->next;
        //前面有节点时 
        while(front)
        {
        	//前后节点值相同，就删除前面的节点 
            if(front->val==p->val)///重复判断
            {
            	//从链表里删除节点 
                back->next=front->next;
                //从内存中删除节点，释放内存
                delete front; 
                //前指针指向后指针的前一位 
                front=back->next; 
            }
            //前后节点值不同，两个指针一同向前滑动一位，相当于一个滑动窗口，永远保持一前一后的相邻状态 
            else
            {
                back=front;
                front=front->next;
            }
        }
        //如果前面还有节点，就向前遍历 
        if(p->next)
        {
            p=p->next;
        }
    }
    return L;
}
};