<span style="font-family: Arial, Helvetica, sans-serif;">鄙人：</span>
<span style="font-family: Arial, Helvetica, sans-serif;">package testWebApp;</span>
/**
*
* @author luozhonghua
*
*/
public class testmysort {
static final int N=200;
public static void main(String[]args){
long begin=System.currentTimeMillis();
int []array=new int[N];// {123,115,100,193,194,167,151,183,190,136 } ;
System.out.println("排序前：");
for(int i=0;i<N;i++){
array[i]=(int)(100+Math.random()*(100+1));
System.out.print(array[i]+" ");
}
System.out.print("\n");
sort("", array);
System.out.println("排序后：");
for(int i:array){
System.out.print(i+" ");
}
long end=System.currentTimeMillis();
System.out.print("\n");
System.out.println("耗时："+(end-begin));
}
static void sort(String desc,int [] array){
int temp=0;
int count=0;
if(desc.equals("desc")){
for(int i=0;i<array.length;i++){
for(int j=i;j<array.length;j++){
if(array[i]<array[j]){
temp = array[i]; //小
array[i] = array[j]; //大
array[j] = temp;//小
count++;
// array[i] = array[i] + array[j];
// array[j] = array[i] - array[j];
// array[i] = array[i] - array[j];
}
}
}
System.out.println("比较次数："+count);
}else{
for(int i=0;i<array.length;i++){
for(int j=i;j<array.length;j++){
if(array[i]>array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp;
count++;
}
}
}
System.out.println("比较次数："+count);
}
}
}
排序前：
156 101 178 118 193 195 194 109 157 143 167 183 185 122 173 105 132 130 172 191 169 160 149 168 117 200 122 119 110 114 117 118 120 198 145 194 158 197 110 197 169 111 180 186 152 185 152 132 110 149 123 196 168 137 139 166 133 142 160 127 183 188 169 190 184
178 117 102 141 101 135 123 186 102 156 175 162 183 128 139 189 141 183 127 195 164 128 191 110 138 142 183 135 110 180 132 134 196 131 152 144 114 174 114 193 174 144 190 138 184 197 200 141 195 131 147 149 132 100 133 199 134 137 144 154 125 110 166 116
112 158 180 143 152 181 105 199 119 110 170 168 113 165 153 188 125 137 181 183 155 146 147 180 168 154 191 180 184 162 116 151 118 139 102 179 141 115 130 192 163 114 187 116 135 139 173 186 156 161 131 152 134 185 100 189 130 176 122 191 192 127 156 183
170 160 193 167 158 119 139
比较次数：5508
排序后：
100 100 101 101 102 102 102 105 105 109 110 110 110 110 110 110 110 111 112 113 114 114 114 114 115 116 116 116 117 117 117 118 118 118 119 119 119 120 122 122 122 123 123 125 125 127 127 127 128 128 130 130 130 131 131 131 132 132 132 132 133 133 134 134 134
135 135 135 137 137 137 138 138 139 139 139 139 139 141 141 141 141 142 142 143 143 144 144 144 145 146 147 147 149 149 149 151 152 152 152 152 152 153 154 154 155 156 156 156 156 157 158 158 158 160 160 160 161 162 162 163 164 165 166 166 167 167 168 168
168 168 169 169 169 170 170 172 173 173 174 174 175 176 178 178 179 180 180 180 180 180 181 181 183 183 183 183 183 183 183 184 184 184 185 185 185 186 186 186 187 188 188 189 189 190 190 191 191 191 191 192 192 193 193 193 194 194 195 195 195 196 196 197
197 197 198 199 199 200 200
耗时：16
某书：
import java.util.Random;
public class P4_1 {
static final int SIZE=200;
public static void bubbleSort(int[] a) {
int temp;
int count=0;
for (int i = 1; i < a.length; i++) {
//将相邻两个数进行比较，较大的数往后冒泡
for (int j = 0; j < a.length - i; j++) {
if (a[j] > a[j + 1]) {
//交换相邻两个数
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
count++;
}
}
// System.out.print("第"+i+"步排序结果:"); //输出每步排序的结果
// for(int k=0;k<a.length;k++)
// {
// System.out.print(" "+a[k]); // 输出
// }
// System.out.print("\n");
}
System.out.println("比较次数："+count);
}
public static void main(String[] args) {
long begin=System.currentTimeMillis();
int[] shuzu=new int[SIZE];//{123,115,100,193,194,167,151,183,190,136 }
int i;
System.out.print("排序前的数组为：\n"); //输出排序前的数组
for(i=0;i<SIZE;i++){
shuzu[i]=(int)(100+Math.random()*(100+1)); //初始化数组
System.out.print(shuzu[i]+" ");
}
System.out.print("\n");
bubbleSort(shuzu); //排序操作
System.out.print("排序后的数组为：\n");
for(i=0;i<SIZE;i++){
System.out.print(shuzu[i]+" "); //输出排序后的数组
}
System.out.print("\n");
long end=System.currentTimeMillis();
System.out.println("耗时："+(end-begin));
}
}
排序前的数组为：
193 118 137 130 152 194 109 194 188 156 139 112 137 159 172 199 196 100 166 154 171 104 197 107 197 193 107 163 129 141 186 121 156 139 116 154 158 150 134 199 133 149 102 160 135 142 108 179 159 162 138 200 185 183 183 146 131 163 120 182 136 143 141 148 181
187 109 146 166 141 116 147 184 146 128 130 140 178 120 162 143 156 182 142 157 190 187 118 154 130 154 172 161 169 149 132 130 162 171 162 172 119 192 188 163 136 148 130 151 157 171 178 120 117 153 115 193 163 101 127 130 113 167 179 136 158 120 117 191
123 103 190 199 157 108 173 104 198 136 184 109 102 118 185 137 185 137 158 181 120 127 185 135 141 128 153 132 110 145 195 164 117 197 127 187 190 109 200 140 162 124 134 178 147 164 139 186 100 141 150 144 162 119 115 110 169 193 114 200 116 112 136 103
131 184 178 114 193 126 175
比较次数：10367
排序后的数组为：
100 100 101 102 102 103 103 104 104 107 107 108 108 109 109 109 109 110 110 112 112 113 114 114 115 115 116 116 116 117 117 117 118 118 118 119 119 120 120 120 120 120 121 123 124 126 127 127 127 128 128 129 130 130 130 130 130 130 131 131 132 132 133 134 134
135 135 136 136 136 136 136 137 137 137 137 138 139 139 139 140 140 141 141 141 141 141 142 142 143 143 144 145 146 146 146 147 147 148 148 149 149 150 150 151 152 153 153 154 154 154 154 156 156 156 157 157 157 158 158 158 159 159 160 161 162 162 162 162
162 162 163 163 163 163 164 164 166 166 167 169 169 171 171 171 172 172 172 173 175 178 178 178 178 179 179 181 181 182 182 183 183 184 184 184 185 185 185 185 186 186 187 187 187 188 188 190 190 190 191 192 193 193 193 193 193 194 194 195 196 197 197 197
198 199 199 199 200 200 200
耗时：32
分享到：
相关推荐
要求完成在正序、逆序、小规模数据量（10、30、50）和大规模数据量（100、1000、10000等）情况下以移动次数和比较次数来分析算法效率。 几种内部排序算法在进行时间复杂度分析的时候给出了算法执行的大概执行时间。...
在IT领域，排序算法是计算机科学中的核心概念，特别是在数据结构和算法分析中。排序算法是用来组织一组元素，使其按照特定顺序排列...通过理解并比较这些排序算法，我们可以更好地理解和优化我们的代码，提高程序效率。
冒泡排序是一种简单但效率较低的排序算法，它的基本思想是通过重复遍历待排序的序列，比较相邻元素并根据需要交换它们的位置，直到序列中所有元素都按照指定顺序排列。这个过程就像水底下的气泡逐渐上升到水面一样，...
在实际应用中，冒泡排序效率较低，时间复杂度为O(n^2)，不适合处理大数据量的排序。然而，它的简单性和易于理解使得它成为初学者学习算法和数据结构的良好起点。在进一步的学习中，学生还会接触到更高效的排序算法，...
总结起来，这个软件工程作业的重点在于理解和实现冒泡排序算法，以及利用流程图、环路复杂度分析和测试用例设计来评估算法的效率和正确性。通过这样的练习，学生能够深入理解排序算法的工作原理，并掌握软件开发中的...
在实际应用中，可以通过编写两种算法并进行性能比较，了解不同实现方式对算法效率的影响。同时，也可以通过HMI（Human Machine Interface）界面，让用户输入排序区间，提高系统的交互性和灵活性。 总结来说，TIA...
本文将详细介绍C语言实现的几种经典排序算法，包括冒泡排序、插入排序、选择排序、快速排序以及希尔排序，它们各自有着不同的时间复杂度和适用场景。 1. **插入排序 (Insertion Sort)** 插入排序的基本思想是将一...
为了提高冒泡排序的效率，人们提出了多种改进算法，其中鸡尾酒排序（Cocktail Sort，又称双向冒泡排序）是一种常见的优化策略。 鸡尾酒排序的基本思想是在排序过程中，不仅从左向右进行比较和交换，还会从右向左...
提供了多种算法演示和验证的功能，如输入和输出待排序的数据，显示冒泡排序的过程和结果，验证冒泡排序的正确性和效率，比较冒泡排序和其他排序算法的优劣等。本资源适合算法演示和验证的学习者和工程师使用，帮助...
这些排序算法各有特点，选择排序和冒泡排序实现简单，但效率较低，适合小规模数据排序；而递归排序如快速排序和归并排序在处理大数据量时表现更优，但实现相对复杂。在实际应用中，需要根据具体场景和需求选择合适的...
标题中的“各种排序算法时间性能的比较”是指对多种经典的排序算法进行性能分析，包括直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序和归并排序。这些算法在不同的数据排列情况下（如...
本项目“排序算法效率比较(含报告)”旨在通过实际运行并测量程序执行时间，对多种常见的排序算法进行详细比较，以便了解它们在不同情况下的性能表现。 一、排序算法的种类及其工作原理 1. 冒泡排序：通过重复遍历...
算法设计与分析——时间复杂度 算法设计与分析是计算机科学中的一门重要课程，旨在研究和分析...通过本实验，我们可以看到快速排序的时间复杂度最低，同时也了解了算法设计与分析的基本概念和时间复杂度的计算方法。
在寻找插入位置时，采用二分查找的方法，将待插入元素与已排序区的一部分进行比较，从而减少查找时间，提高了效率。这种方法适合于数据量较大且部分有序的情况。 3. 希尔排序： 希尔排序，也称为缩短增量排序，是...
冒泡排序是一种基础且经典的排序算法，它通过不断交换相邻两个元素的位置，使得较大的元素逐渐“浮”到数组的一端...通过实践和理解这些代码，不仅可以掌握冒泡排序的实现，还能进一步提升对C语言以及排序算法的理解。
通过仔细阅读和理解这些代码，你可以加深对C++编程的理解，掌握算法应用的精髓，最终提升自己在解决实际编程问题时的效率和能力。此外，实际操作中对代码进行调试和优化，也是对算法理解深度和编程技能提升的必要...
冒泡排序是一种基础且经典的排序算法，...在实际应用中，由于其效率较低（时间复杂度为O(n^2)），在处理大量数据时通常不被采用。不过，它仍然是理解排序算法和数据结构的基础，对于学习计算机科学的学生来说至关重要。
冒泡排序的时间复杂度为O(n^2)，在处理大量数据时效率较低，但因其简单易懂，常被用作教学示例。 在PLC编程中，冒泡排序可能被用于对传感器读取的数据、设备状态或其他需要排序的信息进行处理。例如，你可以使用这...
总结起来，这个实验不仅要求学生理解各种排序算法的原理，还强调了实践能力，通过编写代码并进行性能比较，帮助学生深入理解排序算法的效率和适用场景。在实际工程中，选择合适的排序算法对于提升程序性能至关重要，...