C++ (Cpp) swap1示例

示例#1

文件： 8.3.c 项目： zqw86713/The.C.Programming.Language

int main() {
        void swap1(int *p1, int *p2);
            void swap2(int *p1, int *p2);

                int a , b, c, d;
                    int *pointer_1, *pointer_2, *pointer_3, *pointer_4;

                        printf("Please enter a and b: ");

                            scanf("%d,%d", &a, &b);

                                printf("Please enter c and d: ");

                                    scanf("%d,%d", &c, &d);

                                        pointer_1 = &a;
                                            pointer_2 = &b;

                                                if (a<b) {
                                                            swap1(pointer_1, pointer_2);
                                                                }

                                                    pointer_3 = &c;
                                                        pointer_4 = &d;

                                                            if (c<d) {
                                                                        swap2(pointer_3, pointer_4);
                                                                            }

                                                                printf("max=%d, min=%d\n", a, b);
                                                                    printf("max=%d, min=%d\n", c, d);
                                                                        return 0;
}

示例#2

文件： swap.c 项目： Andy-Shao/arithmetic_c

main(){
    int x=1, y=2;
    printf("x=%d, y=%d\n", x, y);
    swap1(x,y);
    printf("After swap1(x,y): x=%d, y=%d\n", x, y);
    swap2(&x,&y);
    printf("After swap2(&x,&y): x=%d, y=%d\n", x, y);
}

示例#3

文件： 05.02.cpp 项目： walrus7521/code

int main()
{
    unsigned long long x;
    int i, j;
    x = 0x00080004; i = 19, j = 0;
    printf("swap(%016llx, %d, %d) => %016llx\n", x, i, j, swap1(x, i, j));
    x = 0x00080004; i = 19, j = 0;
    printf("swap(%016llx, %d, %d) => %016llx\n", x, i, j, swap2(x, i, j));
}

示例#4

文件： swap.c 项目： Morainy/MyCode

int main(int argc,char * crgv[])
{
	int a=1,b=1;
	printf("a=%d,b=%d\n",a,b);
	swap1(&a,&b);
	printf("a=%d,b=%d\n",a,b);
	swap2(&a,&b);
	printf("a=%d,b=%d\n",a,b);
}

示例#5

文件： 1-2.c 项目： godofchina/CPraticeCode

int main()
{
	int a=3,b=5;
	swap1(a,b);
	swap2(&a,&b);
	// swap3(a, b);

	printf("a:%d,b:%d\n", a, b);
	return 0;
}

示例#6

文件： bl-swap-a.c 项目： tranganlab/mc

void main () {
	int i, j;
	int v1 = 1, v2 = 2;

	i = v1;
	j = v2;

	swap1 (&i, &j);
        
        //@ assert (i == v2);
}

示例#7

文件： swap.c 项目： simondevries/University-Practice-Code

int main() {
  int a = 12, b = 13;
  printf("Initial values:\n");
  printf("a = %d  b = %d\n\n", a, b);
  swap1(a, b);
  printf("After swap1:\n");
  printf("a = %d  b = %d\n\n", a, b);
  swap2(&a, &b);
  printf("After swap2:\n");
  printf("a = %d  b = %d\n", a, b);
}

示例#8

文件： function2.c 项目： supernovaremnant/comp2123

int main(){
    double a = 5.5;
    double b = 10.5;
    print(a,b);
    swap1(a,b);
    print(a,b);
    swap2(a,b);   // Comment this line out
    print(a,b);   // Comment this line out
    swap3(&a,&b);
    print(a,b);    
    return 0;
}

示例#9

文件： xor_swap.c 项目： r930709/Practice_code

int main() {

    int x = 5,y =12;
    printf("original : x = %d,y = %d\n",x,y);
    swap1(&x,&y);
    //swap2(&x,&y);
    //swap3(x,y);
    //swap4(&x,&y);
    printf("after swap x = %d,y = %d\n",x,y);

    system("pause");
    return(0);
}

示例#10

文件： Bubblesort.cpp 项目： ythunder/yushu

void BubbleSort1(int arr[], int num)
{
    int i,j;

    for(int i=0; i<num-1; i++)
    {
        for(int j=0; j<num-i-1; j++)
        {
            if(arr[j] > arr[j+1])
                swap1(&arr[j], &arr[j+1]);
        }
    }
}

示例#11

文件： z2.c 项目： wwq0327/studyC

int main()
{
	int a = 10;
	int b = 5;
	printf("使用数据方式交换数据\n");
	printf("原来： a: %d, b: %d\n", a, b);
	swap1(a, b);

	printf("交换后的值为：a: %d, b: %d\n", a, b);

	printf("使用指针方式交换\n");
	swap2(&a, &b);
	printf("交换后的值： a： %d, b: %d\n", a, b);

	return 0;
}

示例#12

文件： heapsort.hpp 项目： jasonzhong/algorithm

void heapsort::sort(int arr[], int num)
{
    print(arr, num);

    int i = 0;
    for (i = (num / 2); i >= 0; --i) {
        percdown(arr, i, num);
        print(arr, num);
    }

    for (i = (num - 1); i > 0; --i) {
        swap1(&arr[0], &arr[i]);
        print(arr, num);
        percdown(arr, 0, i);
    }
}

示例#13

文件： Bubblesort.cpp 项目： ythunder/yushu

void BubbleSort3(int arr[], int num)
{ 
    int flag = num-1;
    for(int i=0; i<num-1; i++)
    {
        int k = flag;
        for(int j=0; j<k; j++)
        {
            if(arr[j] > arr[j+1])
            {
                swap1(&arr[j], &arr[j+1]);
                flag = j;
            }
        }
    }
}

示例#14

文件： ch-05-ex-03-solution.cpp 项目： islijepcevic/ProgrammingConcepts_noEclipse

int main(int argc, char* argv[])
{
	double x =  2.73;
	double y = -3.141592;

	std::cout << "The numbers are: " << x << " " << y << std::endl;

	swap1(&x, &y);

	std::cout << "We've swapped the numbers: " << x << " " << y << std::endl;

	swap2(x, y);

	std::cout << "And swapped them back: " << x << " " << y << std::endl;

	return 0;
}

示例#15

文件： swap2.c 项目： tracer-x/tracer

void main () {
  
  int *i, *j;
  
  int v1, v2;
  
  i = malloc(4);
  j = malloc(4);
  
  *i = v1;
  *j = v2;
  
  if (__NONDET) {
    swap1 (i, j);
  } 
  else{
    swap2 (i,j);
  }  
  
}

示例#16

文件： Bubblesort.cpp 项目： ythunder/yushu

void BubbleSort2(int arr[], int num)
{
    bool flag = true;
    int i,j;
    while(flag)
    {
        flag = false;
        for(int i=0; i<num-1; i++)
        {
            for(int j=0; j<num-i-1; j++)
            {
                if(arr[j] > arr[j+1])
                {
                    swap1(&arr[j], &arr[j+1]);
                    flag = true;
                }
            }
        }
    }
}

示例#17

文件： qsort_unknown.c 项目： opomuc/code-dump

void quick_sort(int* data, int length)
{
    int right = length, left = 0;
    int middle = data[length/2];

    do
    {
        while (data[left] < middle)
        {
            left++;
        }
        while (data[right] > middle)
        {
            right--;
        }

        if (left <= right)
        {
            swap1(&data[left], &data[right]);
            left++;
            right--;
        }

    }
    while (left < right);

    if (right > 0)
    {
        quick_sort(data, right);
    }

    if (left < length)
    {
        quick_sort(data + left, length - left);
    }

}

示例#18

文件： swap.c 项目： kxk2907/C-Code

int main() {
	int i = 10, j = 20;
	swap1(&i,&j);
	printf("i = %d, j = %d \n",i,j);
}

示例#19

文件： lab5.c 项目： hangngopham/CS-271

// start the main function
int main(void) {

// define an array of integers called values with 5 elements
	int values[5];

// using a for loop, assign the even integers 2 to 10 to the
// array elements
	int i, n = 2;
	for(i = 0; i < 5; i++) {
		values[i]= n;
		n = n + 2;
	}

// declare an integer named x and initialize it to 1
	int x = 1;

// declare an integer named y and initialize it to 2
	int y = 2;

// call the swap1 function using parameters values[x] and values[y]
	swap1(values[x],values[y]);

// print a message "After the first swap:\n".
// using a for loop, print the contents of the array values,
// all on one line
// print a blank line
	printf("After the first swap:\n");
	int a;
	for(a = 0; a < 5; a++) {
		printf("%d ", values[a]);
	}
	printf("\n");

// define a pointer named aPtr that points to an object of type int
// assign the starting address of the array values to aPtr
	int *aPtr = values;

// define a pointer named vPtr that points to an object of type int
// assign vPtr the address of values[1]
	int *vPtr;
	vPtr = &values[1];

// define a pointer named wPtr that points to an object of type int
// assign wPtr the address of values[2]
	int *wPtr;
	wPtr = &values[2];

// call the swap2 function using parameters vPtr and wPtr
	swap2(vPtr, wPtr);

// print a message "After the second swap:\n".
// using a for loop, print the contents of the array values,
// all on one line
// print a blank line
	printf("After the second swap:\n");
	int b;	
	for(b = 0; b < 5; b++) {
		printf("%d ", values[b]);
	}
	printf("\n");
	
// print a message "Using Pointer/Offset Notation:\n"
// using a for loop and pointer/offset notation, print the contents
// of the array values, all on one line
	printf("Using Pointer/Offset Notation:\n");
	int j;
        size_t offset;
	for(offset = 0; offset < 5; offset++) {
		printf("*(aPtr+%u) = %d\n",offset, *(aPtr+offset));
		
	}
	printf("\n");

// print a message "Using Pointer subscripting:\n"
// using a for loop and pointer subscripting, print the contents
// of the array values, all on one line
	printf("Using Pointer subscripting:\n");

// print aPtr (with an informative message)
	printf("aPtr is %p\n", aPtr);

// print aPtr + 3 (with an informative message)
	printf("aPtr + 3 is %p\n", aPtr + 3);

// print the value stored at aPtr + 3 (with an informative message)
	printf("The value stored at aPtr + 3 is %d\n", *(aPtr + 3));

// declare an array called list with 10 elements of type float
// using a for loop, input numbers from the user and store them
// in the array list
	float list[10];
	
	int c;
	for(c = 0; c < 10; c++) {
		scanf("%f",&list[c]);
		
	}

// call the maximum function with the array list and 10. Store the
// return value in a variable called max.
// print max (with an informative message)
	float max = maximum(list,10);
	printf("The maximum value is: %.2f\n", max);
} // end the main function

示例#20

文件： commute.cpp 项目： xywei/texmacs

bool
swap (modification& m1, modification& m2) {
  // Assuming that m1;m2 (the patch m1 followed by m2) is well-defined,
  // determine modifications m1* and m2* such that m2*;m1* is equivalent
  // to m1;m2.  If such modifications exist, then set m1 := m2* and
  // m2 := m1* and return true.  Otherwise, return false
  path rp1= root (m1);
  path rp2= root (m2);
  if (is_nil (rp1))
    switch (m1->k) {
    case MOD_ASSIGN:
      {
	if (m1 == m2) return true;
	if (!is_nil (rp2) || m2->k != MOD_INSERT_NODE) return false;
	modification aux= m2;
	m2= modification (m1->k, path (m2->p->item, m1->p), m1->t);
	m1= aux;
	return true;
      }
    case MOD_INSERT:
      {
	if (is_nil (m2->p)) return false;
	int b= m1->p->item;
	int e= b + insert_length (m1->t);
	if (m2->p->item >= b && m2->p->item < e)
	  if (!is_nil (root (m2)) || m2->p->item != b || m2->k != MOD_INSERT)
	    if (!is_nil (root (m2)) || m2->k != MOD_INSERT_NODE)
	      return false;
	return swap1 (m1, m2, b, e-b);
      }
    case MOD_REMOVE:
      {
	if (is_nil (m2->p)) return false;
	int i= m1->p->item;
	int d= m1->p->next->item;
	return swap1 (m1, m2, i, -d);
      }
    case MOD_SPLIT:
      {
	if (is_nil (m2->p)) return false;
	int i= m1->p->item;
	if (m2->p->item == i || m2->p->item == i+1)
	  if (!is_nil (root (m2)) || m2->p->item != i || m2->k != MOD_INSERT)
	    if (!is_nil (root (m2)) || m2->k != MOD_INSERT_NODE)
	      return false;
	return swap1 (m1, m2, i, 1);
      }
    case MOD_JOIN:
      {
	if (is_nil (m2->p)) return false;
	int i= m1->p->item;
	if (m2->p->item == i)
	  if (!is_nil (root (m2)) || m2->k != MOD_INSERT)
	    return false;
	return swap1 (m1, m2, i, -1);
      }
    case MOD_ASSIGN_NODE:
      {
	if (!is_nil (root (m2))) return swap_basic (m1, m2);
	if (m1 == m2) return true;
	if (!is_nil (rp2) || m2->k != MOD_INSERT_NODE) return false;
	modification aux= m2;
	m2= modification (m1->k, path (m2->p->item, m1->p), m1->t);
	m1= aux;
	return true;
      }
    case MOD_INSERT_NODE:
      {
	if (is_nil (root (m2))) return false;
	if (m2->p->item != m1->p->item) return false;
	modification aux= m1;
	m1= modification (m2->k, m2->p->next, m2->t);
	if (m2->k != MOD_INSERT_NODE || !is_nil (root (m1))) m2= aux;
	else m2= modification (aux->k, path (m1->p->item, aux->p), aux->t);
	return true;
      }
    case MOD_REMOVE_NODE:
      {
	modification aux= m1;
	m1= modification (m2->k, path (m1->p->item, m2->p), m2->t);
	m2= aux;
	return true;
      }
    case MOD_SET_CURSOR:
      {
        if (!is_nil (rp2) ||
            m2->k == MOD_JOIN ||
            m2->k == MOD_SPLIT ||
            m2->k == MOD_ASSIGN_NODE)
          return swap_basic (m1, m2);
        return false;
      }
    }
  else if (is_nil (rp2))
    switch (m2->k) {
    case MOD_ASSIGN:
      return false;
    case MOD_INSERT:
      {
	int b= m2->p->item;
	int e= b + insert_length (m2->t);
	return swap2 (m1, m2, b, e-b);
      }
    case MOD_REMOVE:
      {
	int b= m2->p->item;
	int e= b + m2->p->next->item;
	if (m1->p->item >= b && m1->p->item < e) return false;
	return swap2 (m1, m2, b, b-e);
      }
    case MOD_SPLIT:
      {
	int i= m2->p->item;
	if (m1->p->item == i) return false;
	return swap2 (m1, m2, i, 1);
      }
    case MOD_JOIN:
      {
	int i= m2->p->item;
	if (m1->p->item == i || m1->p->item == i+1) return false;
	return swap2 (m1, m2, i, -1);
      }
    case MOD_ASSIGN_NODE:
      return swap_basic (m1, m2);
    case MOD_INSERT_NODE:
      {
	modification aux= m2;
	m2= modification (m1->k, path (m2->p->item, m1->p), m1->t);
	m1= aux;
	return true;
      }
    case MOD_REMOVE_NODE:
      {
	if (m1->p->item != m2->p->item) return false;
	modification aux= m2;
	m2= modification (m1->k, m1->p->next, m1->t);
	m1= aux;
	return true;
      }
    case MOD_SET_CURSOR:
      {
        if (!is_nil (rp1) ||
            m1->k == MOD_JOIN ||
            m1->k == MOD_SPLIT ||
            m1->k == MOD_ASSIGN_NODE)
          return swap_basic (m1, m2);
        return false;
      }
    }
  else if (rp1->item == rp2->item) {
    path h (rp1->item);
    modification s1= m1 / h;
    modification s2= m2 / h;
    bool r= swap (s1, s2);
    m1= h * s1;
    m2= h * s2;
    return r;
  }
  else return swap_basic (m1, m2);
  FAILED ("unexpected situation");
}

示例#21

文件： commute.cpp 项目： Easycker/itexmacs

bool
swap (modification& m1, modification& m2) {
  path rp1= root (m1);
  path rp2= root (m2);
  if (is_nil (rp1))
    switch (m1->k) {
    case MOD_ASSIGN:
      {
	if (m1 == m2) return true;
	if (!is_nil (rp2) || m2->k != MOD_INSERT_NODE) return false;
	modification aux= m2;
	m2= modification (m1->k, path (m2->p->item, m1->p), m1->t);
	m1= aux;
	return true;
      }
    case MOD_INSERT:
      {
	if (is_nil (m2->p)) return false;
	int b= m1->p->item;
	int e= b + insert_length (m1->t);
	if (m2->p->item >= b && m2->p->item < e)
	  if (!is_nil (root (m2)) || m2->p->item != b || m2->k != MOD_INSERT)
	    if (!is_nil (root (m2)) || m2->k != MOD_INSERT_NODE)
	      return false;
	return swap1 (m1, m2, b, e-b);
      }
    case MOD_REMOVE:
      {
	if (is_nil (m2->p)) return false;
	int i= m1->p->item;
	int d= m1->p->next->item;
	return swap1 (m1, m2, i, -d);
      }
    case MOD_SPLIT:
      {
	if (is_nil (m2->p)) return false;
	int i= m1->p->item;
	if (m2->p->item == i || m2->p->item == i+1)
	  if (!is_nil (root (m2)) || m2->p->item != i || m2->k != MOD_INSERT)
	    if (!is_nil (root (m2)) || m2->k != MOD_INSERT_NODE)
	      return false;
	return swap1 (m1, m2, i, 1);
      }
    case MOD_JOIN:
      {
	if (is_nil (m2->p)) return false;
	int i= m1->p->item;
	if (m2->p->item == i)
	  if (!is_nil (root (m2)) || m2->k != MOD_INSERT)
	    return false;
	return swap1 (m1, m2, i, -1);
      }
    case MOD_ASSIGN_NODE:
      {
	if (!is_nil (root (m2))) return swap_basic (m1, m2);
	if (m1 == m2) return true;
	if (!is_nil (rp2) || m2->k != MOD_INSERT_NODE) return false;
	modification aux= m2;
	m2= modification (m1->k, path (m2->p->item, m1->p), m1->t);
	m1= aux;
	return true;
      }
    case MOD_INSERT_NODE:
      {
	if (is_nil (root (m2))) return false;
	if (m2->p->item != m1->p->item) return false;
	modification aux= m1;
	m1= modification (m2->k, m2->p->next, m2->t);
	if (m2->k != MOD_INSERT_NODE || !is_nil (root (m1))) m2= aux;
	else m2= modification (aux->k, path (m1->p->item, aux->p), aux->t);
	return true;
      }
    case MOD_REMOVE_NODE:
      {
	modification aux= m1;
	m1= modification (m2->k, path (m1->p->item, m2->p), m2->t);
	m2= aux;
	return true;
      }
    case MOD_SET_CURSOR:
      {
        if (!is_nil (rp2) ||
            m2->k == MOD_JOIN ||
            m2->k == MOD_SPLIT ||
            m2->k == MOD_ASSIGN_NODE)
          return swap_basic (m1, m2);
        return false;
      }
    }
  else if (is_nil (rp2))
    switch (m2->k) {
    case MOD_ASSIGN:
      return false;
    case MOD_INSERT:
      {
	int b= m2->p->item;
	int e= b + insert_length (m2->t);
	return swap2 (m1, m2, b, e-b);
      }
    case MOD_REMOVE:
      {
	int b= m2->p->item;
	int e= b + m2->p->next->item;
	if (m1->p->item >= b && m1->p->item < e) return false;
	return swap2 (m1, m2, b, b-e);
      }
    case MOD_SPLIT:
      {
	int i= m2->p->item;
	if (m1->p->item == i) return false;
	return swap2 (m1, m2, i, 1);
      }
    case MOD_JOIN:
      {
	int i= m2->p->item;
	if (m1->p->item == i || m1->p->item == i+1) return false;
	return swap2 (m1, m2, i, -1);
      }
    case MOD_ASSIGN_NODE:
      return swap_basic (m1, m2);
    case MOD_INSERT_NODE:
      {
	modification aux= m2;
	m2= modification (m1->k, path (m2->p->item, m1->p), m1->t);
	m1= aux;
	return true;
      }
    case MOD_REMOVE_NODE:
      {
	if (m1->p->item != m2->p->item) return false;
	modification aux= m2;
	m2= modification (m1->k, m1->p->next, m1->t);
	m1= aux;
	return true;
      }
    case MOD_SET_CURSOR:
      {
        if (!is_nil (rp1) ||
            m1->k == MOD_JOIN ||
            m1->k == MOD_SPLIT ||
            m1->k == MOD_ASSIGN_NODE)
          return swap_basic (m1, m2);
        return false;
      }
    }
  else if (rp1->item == rp2->item) {
    path h (rp1->item);
    modification s1= m1 / h;
    modification s2= m2 / h;
    bool r= swap (s1, s2);
    m1= h * s1;
    m2= h * s2;
    return r;
  }
  else return swap_basic (m1, m2);
  FAILED ("unexpected situation");
}