精华内容
下载资源
问答
  • 首先我们来了解数组的概念 一.数组的概念 单个变量能存储信息如果有批量数据需要存储,单个变量存储时间和空间上不经济和实用,而且过于麻烦,这时候需要用数组这一引用数据类型来存储。 数组:用来存储具有相同数据...

    首先我们来了解数组的概念
    一.数组的概念
    单个变量能存储信息如果有批量数据需要存储,单个变量存储时间和空间上不经济和实用,而且过于麻烦,这时候需要用数组这一引用数据类型来存储。
    数组:用来存储具有相同数据类型的数据的集合,可以使用共同的名字来引用数组中存储的数据。
    特点:数组可以存储任何类型的数据,包括原始数据类型和引用数据类型,但是一旦指定了数组的类型之后,就只能用来存储指定类型的数据。

    二.数组声明
    两种方式:a. 数据类型 [] 数组名 int [] name={数据};
    -------------- b. 数据类型 数组名[] int name[]={数据};

    三.一维数组
    从一维数组的定义可知:一维数组的形式为 name[]={225,21,3,2,34,3,44,3};
    数组的开始位置都是从0开始的,比如name[1]的值是21,3储存在数组name[7]中,
    数组的作用是便于数据的存储和读取,因此我们可以引申得到数据的获取方式

    package day03;
    
    public class t1 {
       public static void main(String[] args) {
    	   int s[]={34,56,23,78,45,33};
    	   //数组的遍历
    	   for(int j=0;j<s.length;j++){
    			System.out.print(s[j]+" ");	
    		}
    		//获取最值
    	   int max=s[0];  
    	   int min=s[0];
    	   for(int i=0;i<s.length;i++){
    		   if(max<s[i]){
    			  max=s[i];
    		   }else{
    			  max=max;
    		    }
    	     }
    	   for(int i=0;i<s.length;i++){
    		   if(min>s[i]){
    			  min=s[i];
    		   }else{
    			  min=min;
    		    }
    	     }
    	   System.out.println(min);
    	   System.out.println(max);
    }
    }
    
    

    接下来实现一维数组的冒泡排序:
    冒泡排序的要点是每次对比之后,都会将大的值往后移一位,直到最大值被放在了最后一位,最大值找出来之后,就找到第二大的值,以此类推。直到首位的值最小为止。
    在这里插入图片描述

    public static void maopao(){
    		int s[]={90,34,-23,18,12};
    		for(int i=0;i<s.length-1;i++){//减一是因为组数从首位开始比较,可以不算在循环内
    			for(int j=0;j<s.length-1-i;j++){
    				int temp=s[j];
    				if(s[j]>s[j+1]){
    					s[j]=s[j+1];
    					s[j+1]=temp;
    				}
    			}
    		}
    		for(int k=0;k<s.length;k++){
    			System.out.print(s[k]+" ");
    		}
    	}
    
    展开全文
  • Java 数组实现冒泡排序 public class MaoPaoSort { public static void main(String[] args) { int[] arr = new int[]{3,8,3,89,4,3,6,309,55,32}; //冒泡排序,小到大排序, for(int i = 0; i < arr....

    Java 数组实现冒泡排序

    
    public class MaoPaoSort {
    	public static void main(String[] args) {
    		int[] arr = new int[]{3,8,3,89,4,3,6,309,55,32};
    		//冒泡排序,小到大排序,
    		for(int i = 0; i < arr.length; i++){
    			for(int j = 0; j <arr.length-1-i; j++){
    				// 每一次把最大的放后面
    				if(arr[j]>arr[j+1]){
    					int temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    				
    			}
    
    		}
    		for(int i = 0; i<arr.length;i++){
    			System.out.println(arr[i]);
    		}
    	}
    
    }
    
    
    展开全文
  • java 数组实现冒泡排序,小到大排序//冒泡排序法,小到大排序public class TestArray { public static void main(String args[ ]){ int i , j ; int a[ ] = { 5,9,6,8,7}; for ( i = 0 ; i ; i

    java 数组实现冒泡排序,小到大排序

    //冒泡排序法,小到大排序
    
    public class TestArray
    {
        public static void main(String  args[ ]){  
            int  i , j ;
            int  a[ ] = { 5,9,6,8,7};
            for  ( i = 0 ; i < a.length-1; i ++ ) {
                int  k = i;
                for  ( j = i ; j < a.length ;  j++ )
                    if  ( a[j]<a[k] ) 
                        k = j; //找到最小的元素
                int  temp =a[i];
                a[i] = a[k];
                a[k] = temp;
            }
            for  ( i =0 ; i<a.length; i++ )
                    System.out.print(a[i]+"  ");
           System.out.println( );
       }
    }
    • 输出结果:
      5 6 7 8 9
    展开全文
  • 封装一个函数,利用冒泡排序实现对整型数组的升序排序 例如数组:int arr[10]={4,3,6,9,1,2,10,8,7,5}; arr是数组名,数组名即是数组的首地址。在封装函数中,void bubbleSort(int *arr,int len);,创建一个函数,...

    封装一个函数,利用冒泡排序,实现对整型数组的升序排序
    例如数组:int arr[10]={4,3,6,9,1,2,10,8,7,5};

    arr是数组名,数组名即是数组的首地址。在封装函数中,void bubbleSort(int *arr,int len);,创建一个函数,传入arr的首地址和长度。上述代码也等于代码:

    int *arr;
    int len;
    void bubbleSort(arr,len){
    *********
    }
    

    注意传入的时候是int *arr而不是int arr。

    完整代码:

    #include<iostream>
    using namespace std;
    void bubbleSort(int *arr,int len) {
    	for (int i = 0; i < len-1; i++) {
    		for (int j = 0; j < len - 1 - i; j++) {
    			if (arr[j] > arr[j+1]) {
    				int temp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = temp;
    			}
    		}
    	}
    	for (int i = 0; i < 10; i++) {
    		cout << arr[i] << ",";
    	}
    
    }
    
    
    int main() {
    
    	int arr[] = { 4,3,6,9,1,2,10,8,7,5 };
    	int len = sizeof(arr) / sizeof(arr[0]);
    	bubbleSort(arr, len);
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • **原理:**冒泡排序,顾名思义就是每次从数组的低端冒出一个最大值和最小值来实现对组数的降序或者升序排列,这里我们来实现对上面数组的升序排列,也就是从数组的底端到顶端每次冒出一个最小值来,那这个最小值是...
  • 实现了一维数组排序,同时二位数组也可实现排序利用C++实现,以下为主函数 #include<iostream> using namespace std; #define N 3 void paixu(int (*p)[N]); void out(int (*p)[N]); int main() { ...
  • 冒泡排序 1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,就交换他们的位置 2.每一次比较,都会产生出一个最大,或者最小的数字 3.下一轮则可以少一次排序 4.依次循环,直到结束 */ public class ...
  • 冒泡排序的的优点是好理解,稳定,再就是空间复杂度低,不需要额外开辟数组元素的临时保存控件,当然了,编写起来也容易。 其算法很简单,就是比较数组相邻的两个值,把大的像泡泡一样“冒”到数组后面去,一共要...
  • 数组:是一个有序的值得集合 可以存储大量的数据 (1)创建数组的两种方式:1、字面量:var arr=[ ] --创建一个空数组 注意点:数组里面可以存储任意类型的数据,但规定是存储同类型的数据2、构造函数的方式:var arr...
  • 而我现在要做的是利用一组无序的数组实现冒泡排序; 无序是指:在【】里面,我存储的数据是没有顺序可言的,数字顺便传; 但可以利用冒泡排序,从而实现一串数字的大小顺序排列; 冒泡排序算法的原理如下: ...
  • 数组实现冒泡排序---图释

    千次阅读 2012-12-03 11:37:21
    (1)从小到大排序   算法分析:排序是将一组随机...排序冒泡法、选择法和插入法等。   起泡法的思路是:将相邻两个数a[i]和a[i+1]比较,将大数调到后头,小数调到前头;   用一例子的图释方法来理解冒泡
  • 主要思想 package practice; public class BubbleSort { ... //创建冒泡排序类的对象 BubbleSort souter = new BubbleSort(); //调用排序方法将数组排序 souter.sort(array); //输出排序后的数组.
  • 经典算法 冒泡排序 public class test { public static void main(String[] args) { int[] nums = new int[]{1, 2,1,1, 1, 3,4,6,5}; //定义temp临时变量 int temp=0; for(int i=0;i<nums.length;i++) { /...
  • //实现一个对整形数组冒泡排序 //从大到小 //打印数组 void print_arr(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n"); } //冒泡排序 void ...
  • Java实现数组冒泡排序

    千次阅读 2018-09-22 10:43:51
    //格式化打印数组 public static void printArray(int[] arr){ System.out.print("["); for (int i = 0;i;i++){ if(i==arr.length-1){ System.out.println(arr[i]+"]"); }else{ System.out....
  • 封装一个函数,利用冒泡排序实现对整形数组的升序排序 #include<iostream> using namespace std; void maopao(int *a,int len){ for(int i=0;i<len-1;i++){ for(int j=0;j<len-1-i;j++){ if(*...
  • Java中数组冒泡排序以及选择排序一、代码及效果图1.冒泡排序2.选择排序总结 一、代码及效果图 1.冒泡排序 代码如下(示例): public class Hello1 { public static void main(String[] args) { int arr[]={9,4,...
  • * 冒泡排序 * @param arr */ public static void bubbleSort ( int [ ] arr ) { for ( int i = 0 ; i < arr . length - 1 ; i ++ ) { for ( int x = 0 ; x < arr . length - 1 ; x ...
  • 用c++做的例子,利用指针数组冒泡排序
  • 数组冒泡排序

    2017-09-08 10:20:10
    虚拟链接线好比数组的上方出现了气泡,所以称为冒泡排序。 二.代码Ⅰ.初步代码实现利用重复循环,将最大值丢到数组最右下标。实现依次排列。//冒泡排序 import java.util.Arrays; import java.util.Scanner; ...
  • 一维数组冒泡排序

    千次阅读 2020-02-08 11:46:36
    冒泡排序(Bubble Sort)是啥? 来源百度百科: 冒泡排序是一种简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访...
  • 使用一维数组进行冒泡排序 【问题描述】从键盘输入某班学生某门课的成绩(每班人数最多不超过40人),当输入为负值时,表示输入结束,试用冒泡法编程将分数按从高到低顺序进行排序并输出。 【输入形式】任意输入一组...
  • java 数组排序之冒泡排序和选择排序 对于数组的排序有许多方法,这里介绍一下最经典的两个方法: 冒泡和选择排序 1.冒泡排序: 这里我们说一下冒泡排序的思想(升序): 开始将数组的第一个值和第二个值比较,...
  • #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; void fun(char **str); int main() { char *str[4]; int i; str[0] = malloc(sizeof... str[1] = mal...
  • 利用指针数组函数 结合冒泡排序来对一个数组里面的数进行排序 //冒泡排序 #include<iostream> using namespace std; void Bibblesort(int* arr, int len)//数组首地址,长度 { for (int i = 0; i < len - ...
  • 3.数组 3.1.数组的概念 数组的概念:用于保存相同数据类型的多个变量的集合 3.2.使用数组的步骤 //1声明数组 数据类型[] 数组名称; 或 数据类型 数组名称[];...//3为数组元素赋值(利用数组元素的下标指定数组...
  • 冒泡排序 冒泡排序算法的原理如下: 2.比较相邻的元素。如果第一个比第二个大,就交换他们两个。 3.对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 4....
  • 一维数组: 定义形式1:数据类型[ ] 数组变量名=new 数据类型[数组长度] 例1:int[ ] array=new int[10]; 例2:char[ ] array=new char[8]; 定义形式2:数据类型[ ] 数组变量名={值1,值2,值3,…,值n} 例1:int [ ]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,308
精华内容 15,323
关键字:

利用数组实现冒泡排序