How swapping two numbers using pointer in c plus plus?

Answer 1

Starting with a pointer to the pointer to the first element (p1**), verify the first pointer is not null (*p1 != null), retrieve the pointer to the second element (*p2 = *p1.next) and verify it is also not null (*p2 != null), and then retrieve the pointer to the third element (*p3 = *p2.next). Note that *p3 might be null, but *p1 and *p2 must not be null, or the swap can not be performed. Note that using pointer to pointer syntax allows you to treat pointer to first element the same as pointer to subsequent element, i.e. to not need to handle the special case. Also, since you do need to modify the pointer, you need a pointer to the pointer. Set *p1 = *p2, *p3 = *p1, and *p2 = *p3. Note that these assignments must be done using the original values, not the intermediate value, so you will need some temp pointers. The end result is that **p1 will be ordered after **p2.

Answer 2

#include<iostream>

#include<cassert>

int main()

{

int a = 42;

int b = 24;

int* pa = &a;

int* pb = &b;

(*pa) ^= (*pb) ^= (*pa) ^= (*pb);

assert (a==24);

assert (b==42);

}

Answer 3

function swap(head, p)

inputs: pointer to the head of the list

pointer p to a node to swap with its neighbor

will exchange nodes p and p->next

local variables - pointers to list nodes : q = head, temp

if (p->next != NULL)

while (q->next != p) q = q->next;

q->next = p->next;

temp = p->next->next;

p->next->next = p;

p->next = temp;

end if p is not at the end of the list

end function swap

Answer 4

You don't. This is a classic mistake perpetuated through the misconception that adjusting node pointers is more efficient than moving huge amounts of data around. While that is undoubtedly true, there is no rule that states that the data must be placed in the node itself. The data can be stored externally to the list, and the nodes can simply point at that data, thus you only need to swap the data pointers. There is no need to deal with the special case when nodes are adjacent (which also requires working out which comes first) as well as the more general case when they are non-adjacent. Your swap code essentially reduces to a normal swap with a temporary pointer:

void list::swap( node &x, node &y)

{

data_pointer* temp = x.data;

x.data = y.data;

y.data = temp;

}

Note that there's no need to test if x and y refer to the same node because in the vast majority of cases the nodes will be different nodes. The actual swap is so efficient that it more than compensates for the odd case where the two nodes might refer to each other, but the calling code should ensure that's never the case anyway.

As a general rule, if the data size is less than or equal to a pointer (4 bytes on a 32-bit system), then you can store the data in the node and swap the data directly. Otherwise you should point to it and swap the data pointers (not the node pointers). But if you know in advance that the data will never be moved around the list then you can store the data in the nodes themselves, regardless of the size of the data.

The node pointers in any list only need adjusting during an insertion or an extraction of an individual node. Even then, an extraction simply adjusts the node pointers of the nodes on either side of the extracted node, never the node itself. This is known as detaching. The node still knows its correct place in the list meaning it can be easily re-attached. this is handy when you want to temporarily remove nodes without affecting their order. If you detach several nodes, then you must re-attach them in reverse order (last out, first in).

Obviously if the nodes point at the data rather than store the data there is a cost in memory consumption (4 bytes per node on a 32-bit system). However, you only need to do that when you need to move data around the list (such as sorting). The speed benefit more than compensates for the extra memory consumed because there is no need to test if the nodes are adjacent, which requires far more code than is necessary.

In the interest of completeness, here's the code you need to swap two adjacent node pointers:

void CList::swapadjacent( CNode &x, CNode &y )

{

if( x.prev ) x.prev->next = &y;

if( y.next ) y.next->prev = &x;

y.prev = x.prev;

x.next = y.next;

x.prev = &y;

y.next = &x;

}

Note the this method assume x is previous to y. This is catered for by the main swap method but before we get to that, here's the code to handle non-adjacent nodes:

void CList::swapnonadjacent( CNode &x, CNode &y )

{

CNode temp;

temp.prev = x.prev;

temp.next = x.next;

x.prev = y.prev;

x.next = y.next;

y.prev = temp.prev;

y.next = temp.next;

}

Finally, the main swap method, which makes the correct call and adjusts the head and tail if necessary.

void CList::swap( CNode &x, CNode &y )

{

if( &x &y ) ? &x : tail;

}

Note that all methods should be declared private to the list. Only the sorting method and any other methods that need to sort nodes need be public.

Clearly this is a great deal of effort compared with swapping data pointers. But each to his own.

Answer 5

Voila:

typedef float DataType;

void swap(DataType* const a, DataType* const b) {

DataType c = *a;

*a = *b;

*b = c;

}

Answer 6

you don't you don't