数组与冒泡排序

  1 package shuzu;
  2
  3 import java.util.Arrays;
  4
  5 public class ssss {
  6
  7     public static void main(String[] args) {
  8
  9         //一维数组
 10
 11         int myarry [] = new int [5];
 12
 13         //索引从0开始
 14
 15         myarry[0] = 100;
 16
 17         myarry[2] = 200;
 18
 19         for(int i =0; i<myarry.length;i++)
 20         {
 21             System.out.println("myarry=" + myarry [i]);
 22         }
 23
 24           //第二种方式,初始化数组,遍历
 25
 26          int my[]  =new int [] {0,1,2,3,4};
 27
 28             for(int i =0; i<my.length;i++)
 29             {
 30                 System.out.println("my=" + my [i]);
 31             }
 32
 33             //第三种方式
 34
 35
 36             char [] csz = new char [5];
 37
 38             csz [0] =    ‘f‘;
 39
 40             double [] dsz = {1,2,3};
 41
 42             long lsz [] = new long [ ] {1,3,5,4};
 43
 44             long l =lsz [2];
 45
 46             //操作数组
 47             Arrays.sort(lsz );    //排序
 48
 49             //遍历  while 循环
 50
 51             int i =0;
 52
 53             while (i<lsz.length)
 54             {
 55                System.out.println("lsz [" + i + "] = "+ lsz[i]);
 56                i++;
 57                 Arrays.sort(lsz );    //排序
 58             }
 59             //复制数组
 60
 61             long [] lsz2 =lsz;
 62             long [] lsz3 =Arrays.copyOf(lsz,2);
 63             long [] lsz4 =Arrays.copyOfRange(lsz,1,3);
 64
 65             //查询数组,返回索引值,如果么有找到返回负数,可以判断是否包含某元素
 66
 67             System.out.println("8的索引位置=" +Arrays.binarySearch(lsz,8));
 68
 69             //填充
 70             Arrays.fill(lsz2,2);
 71             Arrays.fill(lsz3,1, 3, 8);
 72
 73
 74             //foreach语句
 75
 76             for (double d :dsz)
 77             {
 78                 System.out.println("d=" + d);
 79             }
 80
 81             //二维数组
 82
 83             int [] [] ewsz = new int [2] [3];
 84
 85             ewsz [0] = new int [] {1,2,3};
 86             ewsz [1] = new int [] {4,5,6};
 87
 88             System.out.println("ewsz=" + ewsz [1] [2]);
 89
 90             System.out.println("ewsz=" + ewsz .length);
 91
 92             for (int [] ie : ewsz)                                                    //foreach循环
 93             {
 94                 for (int f : ie)
 95                 {
 96                     System.out.print( f +" ");
 97                 }
 98                 System.out.println();
 99             }
100
101             for (int m = 0; m < ewsz.length;m++)                     //for循环
102             {
103                 for (int n =0; n< ewsz [m].length; n++)
104                 {
105                     System.out.print("" +ewsz [m] [n]);
106                 }
107                 System.out.println();
108             }
109
110             long [] [] lesz = new long [2] [];
111
112             lesz [0] = new long [] {1,5};
113             lesz [1] = new long [] {2,3,4,5,};
114
115             for (int m = 0; m < lesz.length;m++)                     //for循环
116             {
117                 for (int n =0; n< lesz [m].length; n++)
118                 {
119                     System.out.print("" +lesz [m] [n]);
120                 }
121                 System.out.println();
122             }
123
124
125
126
127
128     }
129
130 }
 1 package maopao;
 2
 3 public class xxx {
 4
 5     public static void main(String[] args) {
 6
 7         //冒泡排序
 8
 9         int [] sz = {23,12,56,97,19,30,7,21};
10
11         for (int i : sz)
12         {
13             System.out.print(i +",");
14         }
15         System.out.println();
16         for (int j =1;j<sz.length;j++)
17         {
18             for (int i =0; i<sz.length - j; i++)
19             {
20                 //可以改变序列方式
21                 if (sz [i] > sz [i+1])
22                 {
23                     int t = sz [i+1];
24                     sz [i+1] =sz [i];
25                     sz [i] =t;
26                 }
27             }
28             }
29
30
31         for (int i : sz)
32         {
33             System.out.print(i +",");
34         }
35         System.out.println();
36
37     }
38
39 }
时间: 2024-08-09 10:44:06

数组与冒泡排序的相关文章

数组,冒泡排序,简化

//    int array[] = {3, 2, 6, 9, 8, 5, 7, 1, 4}; //    int count = sizeof(array) / sizeof(array[0]); //    int flag = 1; //    for (int i = 0; i < count - 1 && flag == 1; i++) { //        flag = 0; //        for (int j = 0; j < count - i - 1

「C语言」「算法」数组的冒泡排序

1 #include<stdio.h> 2 #define N 10 3 4 //数组的冒泡排序 5 6 void sort(int b[]){ 7 int i,j; 8 for(i=0;i<N;i++){ 9 for(j=i+1;j<N;j++){ 10 if(b[i]>b[j]){ 11 b[i]^=b[j]; 12 b[j]^=b[i]; 13 b[i]^=b[j]; 14 } 15 } 16 } 17 } 18 19 int main() { 20 int a[N];

数组的冒泡排序

<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title></title> <script type="text/javascript"> //数组的冒泡排序 arr = [1, 4, 7, 2]; //a = 1, b = 4, c = 7, d = 2 //1. 2. 3. 4 //abcd四个人相遇了,他们要排队,身高

我眼中的数组和冒泡排序

一维数组 数组是一个定长的容器,可以放相同类型的数据.数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型 专业解释 数组(Array)是一种线性表数据结构.它用一组连续的内存空间,来存储一组具有相同类型的数据.线性表,顾名思义,线性表就是数据排成像一条线一样的结构.每个线性表上的数据最多只有前和后两个方向.数组具有连续的内存空间和相同的数据类型 数组的声明 dataType[] arrayName;注:数组在声明时不能指定数组长度,即dataType[n] arrayName:是不合

12.数组三--数组的冒泡排序与快速排序

一.冒泡排序 package com.atguigu.java; /* * 数组的冒泡排序的实现 * */ public class BubbleSortTest { public static void main(String[] args) { int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99}; //冒泡排序 for(int i = 0;i < arr.length - 1;i++){ for(int j = 0;j < arr.l

数组,冒泡排序

<!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title></title> </head> <body> <script> //求一组数中的所有数的和 和平均值 /* var arr = [10,20,30,10]; var len = arr.length; var sum =

二维数组与冒泡排序

记住数组顺序是从0开始的!!! 记住数组顺序是从0开始的!!! 记住数组顺序是从0开始的!!! 重要的事情说三遍! 二维数组的静态位 一,Arrays.sort(lsz),//排序操作针对于整型数据.如果是char型数据或者其他,则按照unicode的编码顺序排序 二,Arrays.copyOf(lsz , 2),//复制操作可以复制全部或者一部分的长度,上式中就是取前两位数组. Arrays.copyOfRange(lsz, from, to)//复制操作,注意力两点,首先这个段位的长度可以大

例题:青歌赛打分程序。去掉两个最高分,去掉两个最低分,再算平均分。主要学习数组和冒泡排序,什么情况下要定义数组

Console.Write("请输入评委人数:");//输入人数 int renshu = Convert.ToInt32(Console.ReadLine());//人数代入 int[] fenshu = new int[renshu];//定义一个分数的数组,长度为人数 if (renshu >= 5)//去掉连个最高分,去掉两个最低分,所以至少五个人 { for (int i = 0; i < renshu; i++) { Console.Write("请输

【2-28】数组及冒泡排序

一 数组定义:相同数据类型的元素按照一定顺序排列的集合,即把有限个类型相同的变量用同一个名字命名. 作用:方便操作大量数据 注意:数组内元素必须为同一类型:索引下标必须有长度限制,否则返回初始值0 (一)一维数组: (1)数据类型[] 变量名 = new 数据类型[长度]: (2)string[]变量名= new string[] { "字符串a", "字符串b", "字符串c", "字符串d", "字符串e&quo