您好，我正在尝试使用C ++进行冒泡排序 [英] Hello, I am trying bubble sorting in C++

查看：73
本文介绍了您好，我正在尝试使用C ++进行冒泡排序的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我必须用c ++编写一个程序，打印出N和M随机数的2d数组。 N和M由用户输入。然后我需要找出每行中最大的值，并使用BUBBLE排序按升序排序。



以下是问题的正确解释：



编写一个程序，用10到90的随机数填充二维数组A [N，M]的值，并确定每行中的最大值。行最大元素值按升序排列，使用气泡排序算法。 N和M由用户输入。



我尝试过： 



 #include< iostream> 
 #include< cstdlib> 
 #include< ctime> 
 using namespace std; 
 
 
 int main（）
 {
 srand（time（0））; 
 int i，j，r，c，temp = 0; 
 cout<< 多少行？; 
 cin>> R等
 cout<< 有多少cloumns？; 
 cin>> C; 
 int a [r] [c]; 
 
 for（i = 0; i< r; i ++）
 {
 for（j = 0; j< c; j ++）
 {
a [i] [j] = rand（）％80 + 10; 
} 
 cout<< ENDL; 
} 
 cout<< ENDL; 
 
 for（i = 0; i< r; i ++）{
 for（j = 0; j< c; j ++）{
 cout<< <<一个[i] [j]; 
} 
 cout<< ENDL; 
} 
 
 for（int i = 0; i< r; i ++）
 {
 int max = a [i] [0]; 
 for（int j = 1; j< c; j ++）
 {
 if（a [i] [j]> max）
 {
 max = a [i] [j]; 
} 
} 
 cout<< 行中的最高值<< i<< 是：<< max<< ENDL; 
} 
 for（int i = 0; i< r; i ++）
 {
 int max = a [i] [0]; 
 for（int j = 1; j  -  1< c; j ++）
 {
 if（max> a [j + 1]）$ ​​b $ b {
 temp = max; 
 max = a [j + 1]; 
 a [j + 1] = temp; 
} 
} 
 
} 
 for（int i = 0; i< r; i ++）
 {
 cout<< ;一个[i] [j]; 
} 
}

解决方案

首先，停止在中创建新变量对于循环，给它们不同的名称给 i 和 j 你在方法的开始。当你这样做：

 int i = 666; 
 for（int i = 0; i< 5; i ++）
 cout<< i<< \\\
; 
 cout<< i<< \\\
;

有两个具有相同名称的变量，它们不是连接的。输出将是：

 0 
 1 
 2 
 3 
 4 
 666

因为内部变量 i 掩盖了最外面的变量 i ，直到它最后超出范围循环并被销毁。



所以当你到达最后一个循环时，你会期望什么价值 j 包含？

 for（int i = 0; i< r; i ++）
 {
 cout<<一个[i] [j]; 
}

答案： j 与 c 并将索引一个没有值的数组元素。



当你把所有东西都清理干净的时候，它会变得更加明显在，您可以开始寻找运行时问题。



将开发过程想象为编写电子邮件：成功编译意味着您使用正确的语言编写电子邮件 - 例如英语，而不是德语 - 而不是电子邮件包含你要发送的信息。



现在你进入第二阶段的发展（实际上它是第四或第五阶段，但你会来到之前的阶段）：测试和调试。



首先看看它做了什么，以及它与你想要的有什么不同。这很重要，因为它可以为您提供有关其原因的信息。例如，如果程序旨在让用户输入一个数字并将其翻倍并打印答案，那么如果输入/输出是这样的：

输入预期输出实际输出
 1 2 1 
 2 4 4 
 3 6 9 
 4 8 16

然后很明显问题出在将它加倍的位 - 它不会将自身加到自身上，或者将它乘以2，它会将它自身相乘并返回输入的平方。

所以，你可以查看代码和很明显，它在某处：

  int   Double （ int   value ）
 {
  return   value  * 值; 
}



一旦你知道可能出现的问题，就开始使用调试器找出原因。在方法的第一行放置一个断点，然后运行你的应用程序。当它到达断点时，调试器将停止，并将控制权移交给您。您现在可以逐行运行代码（称为单步执行）并根据需要查看（甚至更改）变量内容（哎呀，您甚至可以更改代码并在需要时再试一次）。 />
在执行代码之前，请考虑代码中的每一行应该做什么，并将其与使用Step over按钮依次执行每一行时实际执行的操作进行比较。它符合您的期望吗？如果是这样，请转到下一行。

如果没有，为什么不呢？它有什么不同？

希望这可以帮助你找到代码的哪个部分有问题，以及问题是什么。

这是一项技能，它是一个值得开发的，因为它可以帮助你在现实世界和发展中。和所有技能一样，它只能通过使用来改进！


来自OriginalGriff的提示是绝对正确的，但是因为我看到你的代码不会编译，因为你输入数组需要一些其他代码和动态内存。 

  int  a =  new   int  [r * c];

为r * c整数分配足够的内存。在代码的最后你必须

  delete  a;



并且正如OriginalGriff所说，要小心变量。我会称这样一个重要的变量不是a而是数组。



良好的命名是良好代码的基础。 ; - ）


I have to write a program in c++ that prints 2d array of N and M random numbers. N and M is input by user. Then I need to find out the largest value in each row and sort it into ascending order by using BUBBLE sort.

Below is the proper explanation of the problem:

Write a program that fills the values of the two dimensional array A[N,M] with the random numbers from 10 to 90 and determines the largest value in each row. Rows largest element values arrange in ascending order, using the "Bubble" sort algorithm. N and M input by the user.

What I have tried:

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;


int main()
{
	srand(time(0));
	int i, j, r, c, temp = 0;
	cout << " how many rows?";
	cin >> r;
	cout << "how many cloumns?";
	cin >> c;
	int a[r][c];

	for (i = 0; i<r; i++)
	{
		for (j = 0; j<c; j++)
		{
			a[i][j] = rand() % 80 + 10;
		}
		cout << endl;
	}
	cout << endl;

	for (i = 0; i<r; i++) {
		for (j = 0; j<c; j++) {
			cout << " " << a[i][j];
		}
		cout << endl;
	}

	for (int i = 0; i < r; i++)
	{
		int max = a[i][0];
		for (int j = 1; j < c; j++)
		{
			if (a[i][j] > max)
			{
				max = a[i][j];
			}
		}
		cout << "Highest value in row " << i << " is: " << max << endl;
	}
	for (int i = 0; i < r; i++)
	{
		int max = a[i][0];
		for (int j = 1; j - 1 < c; j++)
		{
			if (max > a[j + 1])
			{
				temp = max;
				max = a[j + 1];
				a[j + 1] = temp;
			}
		}

	}
	for (int i = 0; i < r; i++)
	{
		cout << a[i][j];
	}
}

解决方案

First off, either stop creating new variables in your for loops, of give them different names to the i and j you declare at the start of the method. When you do this:

int i = 666;
for (int i = 0; i < 5; i++)
   cout << i << "\n";
cout << i << "\n";

There are two variables with the same name, and they are not "connected". The output will be:

0
1
2
3
4
666

Because the inner most variable i masks the outermost variable i until it goes out of scope at the end of the loop and is destroyed.

So by the time you get to the final loop, what value would you expect j to contain?

for (int i = 0; i < r; i++)
{
    cout << a[i][j];
}

Answer: j will have the same value as c and will be indexing an array element that doesn't have a value.

When you have cleaned everything up a little so it's a bit more obvious what is going on, you can start looking for run time problems.

Think of the development process as writing an email: compiling successfully means that you wrote the email in the right language - English, rather than German for example - not that the email contained the message you wanted to send.

So now you enter the second stage of development (in reality it's the fourth or fifth, but you'll come to the earlier stages later): Testing and Debugging.

Start by looking at what it does do, and how that differs from what you wanted. This is important, because it give you information as to why it's doing it. For example, if a program is intended to let the user enter a number and it doubles it and prints the answer, then if the input / output was like this:

Input   Expected output    Actual output
  1            2                 1
  2            4                 4
  3            6                 9
  4            8                16

Then it's fairly obvious that the problem is with the bit which doubles it - it's not adding itself to itself, or multiplying it by 2, it's multiplying it by itself and returning the square of the input.
So with that, you can look at the code and it's obvious that it's somewhere here:

int Double(int value)
   {
   return value * value;
   }


Once you have an idea what might be going wrong, start using the debugger to find out why. Put a breakpoint on the first line of the method, and run your app. When it reaches the breakpoint, the debugger will stop, and hand control over to you. You can now run your code line-by-line (called "single stepping") and look at (or even change) variable contents as necessary (heck, you can even change the code and try again if you need to).
Think about what each line in the code should do before you execute it, and compare that to what it actually did when you use the "Step over" button to execute each line in turn. Did it do what you expect? If so, move on to the next line.
If not, why not? How does it differ?
Hopefully, that should help you locate which part of that code has a problem, and what the problem is.
This is a skill, and it's one which is well worth developing as it helps you in the real world as well as in development. And like all skills, it only improves by use!


The tips from OriginalGriff are absolute correct, but as I see your code wont compile, because you input array needs some other code with dynamic memory. 

int a = new int[r*c];

Allocates enough memory for r * c integer. At the end of your code you must

delete a;


And as OriginalGriff said be careful with variables. I would call such an important variable not "a" but "array".

Good naming is the base of good code. ;-)


这篇关于您好，我正在尝试使用C ++进行冒泡排序的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！

查看全文
相关文章
其他开发语言最新文章
热门教程
热门工具
登录 关闭
扫码关注1秒登录
发送“验证码”获取 | 15天全站免登陆