2. 程式人生 > >java陣列以及氣泡排序實現過程

java陣列以及氣泡排序實現過程

阿新 • • 發佈：2018-12-18

陣列：
1.什麼是陣列
程式：由人事先寫好的，讓電腦做的
程式=演算法+資料結構
一個好的演算法+資料結構=優秀的程式
演算法：變數，運算子，分支，迴圈
資料結構：陣列是一種最基本的資料結構   集合
陣列可以理解為一個容器  水杯=容器    儲存水
陣列  容器   儲存資料
陣列只能存放具有相同資料型別的一堆資料
2.陣列的定義
語法：資料型別【】 陣列名/變數名=new 資料型別【大小】；
3.陣列的初始化
4.陣列的訪問
5.陣列的複製
6.陣列的排序

package com.lddx.day1029;
//java中的陣列
public class ArrayDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//資料型別[] 陣列名/變數名=new  資料型別[大小];
		//10 20 30 40 50 60
		int[] arr1=new int[6];
		//定義了一個int型別的陣列，陣列的名字為arr1。陣列的大小為6，可以在陣列arr1中儲存6個int型別的整數
		double[] arr2=new double[3];
		String[] arr3=new String[4];
		
		 
		
		
		
		
	}

}

 

package com.lddx.day1031;

import java.util.Arrays;

public class ArrayDemo1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1 陣列的概念
		//2 陣列的定義
		//3 陣列的初始化
		//方式1：陣列在建立之後沒有具體的值，但是會有預設值這種方式稱為動態初始化，和陣列定義的語法一致
		int[] arr=new int[5];
		//arr陣列建立完後，只有大小，沒有具體值，但預設值為0;
		//arr  0 0 0 0 0
		double[] arr1=new double[5];
		//arr1 0.0 0.0 0.0 0.0 0.0 0.0
		boolean[] arr2=new boolean[5];
		//arr2 false false false false false
		String[] arr3=new String[5];
		//String型別為引用型別，預設值為null
		//arr3 null null null null null
		//總結：陣列動態初始化後，陣列中的元素內容是有預設值的
		//byte short int long char型別的陣列，預設值是0
		//float double型別的陣列，預設值是false
		//String型別的引用型別陣列，預設值是null
		int[] a=new int[5];
		//方式2：靜態初始化
		//可以在陣列宣告的同時對數組裡的元素內容直接初始化
		int[] arr4={10,20,30,40,50};
		//既有大小，又有內容
		//宣告的陣列arr4的大小為5，元素內容為10 20 30 40 50
		char[] arr5={'a','b','c'};
		//宣告陣列arr5的大小為3，內容為‘a' ’b' ‘c'
		String[] arr6={"張三","李四"};
		//宣告的陣列arr6的大小為2，內容為“張三”  “李四”
	//	int[] arr7={7,'m',"張三",true};編譯錯誤，{}裡的內容要和陣列的資料型別匹配
		//方式3：也屬於靜態初始化的方式
		//方式1+方式2的結合
		int[] arr8=new int[]{100,200,300};
		//陣列arr8的大小為3，陣列的內容為100 200 300
		//注意：一種錯誤的寫法
		int[] arr9;//先宣告一個數組，為arr9
		//arr9={10,20,30};//編譯錯誤，java語法不允許這樣寫
		arr9=new int[3];//ok 陣列arr9大小為3，內容為0 0 0
		arr9=new int[]{10,20,30};//ok 陣列arr9的大小為3，內容為10 20 30
	//	int[] arr10=new int[];//編譯錯誤；方式一動態初始化方式必須寫大小
		//4關於陣列的訪問
		int[] arr11=new int[3];//0 0 0
		//通過length屬性訪問陣列的大小，語法：陣列名.length
		System.out.println(arr11.length);//3
		int[] arr12={10,20,30,40,50};//陣列加內容
		System.out.println(arr12.length);//5
		//通過下標對陣列進行訪問和操作
		//陣列下標的特點：從0開始，到length-1結束
		//語法：陣列名【下標】
		System.out.println(arr11[0]);//0
		System.out.println(arr11[1]);//0
		System.out.println(arr11[2]);//0
		System.out.println(arr12[2]);//30
		//將陣列arr12中的20替換為200
		arr12[1]=200;
		System.out.println(arr12[1]);//200
		//輸出arr12陣列中的最後一個元素
		System.out.println(arr12[arr12.length-1]);//50   軟編碼方式
		//System.out.println(arr12[5]);//執行錯誤
		//arr12陣列的大小為5，下標是0-4.陣列越界
		//將陣列arr12中的所有元素內容輸出
		System.out.println(arr12);//[
 
[email protected]
		//根據的是陣列在記憶體中的地址值
		//根據陣列下標輸出
		for(int i=0;i<arr12.length;i++)
			System.out.println(arr12[i]);
	//	Arrays.toString()方法能夠將數組裡的東西輸出System.out.println(Arrays.toString(arr12));
		//要求20和30交換位置，並輸出交換後的內容
		int[] arr14={10,20,30,40,50};
		int m=0,n=0;
		for(int i=0;i<arr14.length;i++){
			if(arr14[i]==20)
				m=i;
			if(arr14[i]==30)
				n=i;
			}
		int x;
		x=arr14[m];
		arr14[m]=arr14[n];
		arr14[n]=x;
		for(int i=0;i<arr14.length;i++)
			System.out.println(arr14[i]);
		//關於陣列的複製   通過自己寫程式碼的方式完成陣列的複製
		int[] arr15={10,20,30,40,50};
		//屬於靜態初始化的方式，大小為5，內容為10，20,30,40,50
		int[] arr16=new int[5];
		//arr16屬於動態初始化的方式，大小為5，內容為 0 0 0 0 0
		System.out.println("複製前："+Arrays.toString(arr16));
		//思路：從arr15中取出元素內容放入arr16陣列中
		for(int i=0;i<arr15.length;i++)
			arr16[i]=arr15[i];
		System.out.println("複製後："+Arrays.toString(arr16));
			//使用java中提供的一種方法完成陣列的複製
		//System.out.println()
		//System.in
		//完成陣列複製
		//system.arraycopy(src,srcPos,dest,destPos,length)
		/*
		 * src:源陣列（要被複制的陣列）
		 * srcPos：源陣列的起始下標位置
		 * dest：目標陣列
		 * destPos：目標陣列的起始下標位置
		 * length:要複製的源陣列的元素個數
		 */
		int[] arr17={2,5,7,9,11};//源陣列
		int[] arr18=new int[5];//目標陣列
		System.arraycopy(arr17, 1, arr18, 2, 3);
		//System.arraycopy(arr17, 0, arr18, 0, arr17.length);
		System.out.println("複製後："+Arrays.toString(arr18));
		//練習：將源陣列arr17中的579複製到目標陣列arr19中的最後三個位置
		
	//使用Arrays。copyOf（）方法完成陣列的複製
		//語法：目標陣列=Arrays.copyOf（源陣列，目標陣列的長度）
		int[] arr20={2,5,7,9,1};
		int[] arr21=Arrays.copyOf(arr20,5);
		System.out.println("目標陣列："+Arrays.toString(arr21));
		//如果目標陣列的長度小於源陣列的長度，會進行擷取操作
		int[] arr22=Arrays.copyOf(arr20, 3);
		System.out.println(Arrays.toString(arr22));//生成的目標陣列arr22大小為3，源陣列後的9,1會舍掉
		//如果目標陣列的長度大於源陣列的長度，會進行填充   填充的內容：0 0.0 false null
		double[] arr23={10.3,3.14,20.5};
		double[] arr24=Arrays.copyOf(arr23, 6);
		System.out.println(Arrays.toString(arr24));
		boolean[] arr25={true,true,false,false,true};
		boolean[] arr26=Arrays.copyOf(arr25, 8);
		System.out.println(Arrays.toString(arr26));
		String[] arr27={"a","c","d"};
		String[] arr28=Arrays.copyOf(arr27,5);
		System.out.println(Arrays.toString(arr28));
    }

}

 

package com.lddx.day1031;

import java.util.Arrays;
import java.util.Random;

//氣泡排序演算法
public class BulleSortDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//int[] arr={89,23,65,4};
		int[] arr=new int[1000000];
		Random r=new Random();
		for(int i=0;i<arr.length;i++)
			arr[i]=r.nextInt(10000);
		//i=0 1 2 3
		long t1=System.currentTimeMillis();
		for(int i=0;i<arr.length-1;i++){
		//每一輪2個數之間的比較
		/*
		 * i=0 j=0 1 2 3次比較
		 * i=1 j=0 1   2次比較
		 * i=3 j=0     1次比較
		 */
			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;
				}
			
		}
		System.out.println(Arrays.toString(arr));
		long t2=System.currentTimeMillis();
		long t3=t2-t1;
		System.out.println(t3);
	
	}

}

 

package com.lddx.day1101;

import java.util.Arrays;
import java.util.Random;

//演示java中的排序
public class ArraySortDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//int[] arr={3,1,9,20,5};
		int[] arr=new int[1000000];
		Random r=new Random();
		for(int i=0;i<arr.length;i++)
			arr[i]=r.nextInt(10000);
		//i=0 1 2 3
		long t1=System.currentTimeMillis();
		//System.out.println("排序前："+Arrays.toString(arr));
	/*
	 * Arrays.toString()
	 * Arrays.copyOf()
	 * 
	 */
		Arrays.sort(arr);
	//	System.out.println("排序後："+Arrays.toString(arr));
		long t2=System.currentTimeMillis();
		long t3=t2-t1;
		System.out.println(t3);
	
	
	
	}

}

 

package com.lddx.day1101;

import java.util.Scanner;

public class 陣列練習 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		System.out.println("請輸入班級人數：");
		int number=sc.nextInt();
		double[] socre=new double[number];
		String[] name=new String[number];
		for(int i=1;i<=number;i++){
			System.out.print("請輸入第"+i+"位同學的姓名和成績：");
			name[i-1]=sc.next();
			socre[i-1]=sc.nextDouble();
		}
		double max=0;
		double min=100;
		int a=0;
		int b=0;
		double sum=0.0;
		for(int i=1;i<=number;i++){
			if(max<socre[i-1]){
				max=socre[i-1];a=i-1;
			}
			if(min>socre[i-1]){
				min=socre[i-1];b=i-1;
			}
			sum+=socre[i-1];
		}
		System.out.println("總分："+sum);
		System.out.println("平均分："+sum/number);
		System.out.println("最高分："+name[a]+"\t"+socre[a]);
		System.out.println("最低分："+name[b]+"\t"+socre[b]);
		
		
		
		
		
		
	}

}

 

相關推薦

java陣列以及氣泡排序實現過程

陣列： 1.什麼是陣列 程式：由人事先寫好的，讓電腦做的 程式=演算法+資料結構 一個好的演算法+資料結構=優秀的程式 演算法：變數，運算子，分支，迴圈 資料結構：陣列是一種最基本的資料結構   集合 陣列可以理解為一個容器  水杯=容器    儲存水 陣列

Java實現陣列的氣泡排序

注意：     1 迴圈圈數越來越少     2 每次迴圈比較次數越來越少     3 每次比較都從索引0和索引1開始 public class BubbleSort{ public static void m

java實現陣列的氣泡排序、選擇排序程式碼

陣列排序之氣泡排序： 相鄰元素兩兩比較，大的往後放，第一次完畢，最大值出現在了最大索引處 package cn.lgt.sortarray; public class MaoPaoSort {

JNI之c/c++返回中文給java 亂碼問題以及java陣列在c排序

c/c++返回中文給java時會亂碼，因為java和c/c++的編碼格式不一樣，java的utf-16，c/c++是utf-8，所以在返回中文字元的時候，包裝成gb2312返回。 具體見如下部落格連結： jni互動中文亂問題分析 public class CodeTest {

Java中陣列的氣泡排序，氣泡排序優化

氣泡排序： 思路： int[] arr={3,4,2,6,1}; 1.第一次排序，從索引[0]開始，依次兩兩比較。索引[0]與[1]比，[1]與[2]比，[2]與[3]比…… if(arr[0]<arr[1]){

氣泡排序詳細過程，c語言實現

此時按道理應該開始第四趟比較，也就是比較4和5，但是我們通過第三趟比較後可以知道，順序已經排好了，所以再次比較，只會增加演算法的時間，降低演算法的效能，所以我們應該設定一個標記變數flag，當比較沒有交換後，我們可以跳出迴圈，列印結果。

JAVA之氣泡排序—實現雙色球機選小程式

紅球6位：1~33 中不重複的遞增陣列 ，籃球1位：1~16   廢話不多說，上程式碼 pojo package pojo; public class Lottery {public int red;public int blue;public int startRed

氣泡排序實現--圖解/例項/java/php

氣泡排序 概念 在接觸程式的過程中，我們經常會使用到各種各樣的排序演算法來滿足我們的需求 氣泡排序就是眾多排序演算法中一種簡單好用的演算法 氣泡排序以其像氣泡一樣將元素交換到頂端的形式從而命名氣泡排

Java基礎 String 裸暴力演算法- 五個小練習 Java陣列直接選擇排序、sort（）排序

  之間的部落格,承上啟下:    Java基礎 String/StringBuff 常用操作方法複習/記憶體分析 Java陣列直接選擇排序、sort（）排序 Java基礎 String 演算法 - 五個練習題目要求: /** 1.模擬一個trim方法，去除

Java經典演算法氣泡排序

氣泡排序、 實現原理： 比較兩個相鄰位數的元素，將較大的元素交換到右端或左端，最大的元素就在最右端或是最左端；     從小-->大   1 public class MaoPao { 2 3 public static void

java演算法之氣泡排序法

氣泡排序法 口訣： 外層迴圈 0到n-1 //控制比較輪數 n 表示元素的個數 內層迴圈 0到n-i-1 //控制每一輪比較次數 兩兩比較做交換       氣泡排序的優點：每進行一趟排序，就會少比較一次，因為每進行一

傳統的三種排序以及氣泡排序的優化演算法

　　  今天聽到leader說面試的事，說問一個有兩年工作經驗的人，傳統的三種排序可以手寫嗎都手寫不出來。讓我心中也是一顫，其實想想，工作了這麼久，對於原生js這塊兒真的有些淡忘了，在工作中平時都是用的框架來搞事情，直接拿來就可以用，想想當初剛入這行的時候，那時候就覺得js真的很神奇，可是隨著

Java中的氣泡排序

import java.lang.reflect.Array; import java.util.Arrays; import java.util.Random; /**  * 生成一個[10,20]之間的隨機長度,裡面的元素是[10,50]之間的陣列  * 氣泡排序 &nb

字尾陣列的快速排序實現

快速排序 這種排序方法更容易理解，直接寫一個二元組的比較函式，用sort排序就可以了，每次排序時間複雜度O(n*logn)，總的時間複雜度是，一般這個複雜度是可以接受的 題目： C++程式碼實現： #include <bits/stdc++.h> u

字尾陣列的基數排序實現

基數排序（不懂基數排序的看這裡-->基數排序） 基數排序的時間複雜度是，總的時間複雜度是 C++程式碼實現： #include <bits/stdc++.h> using namespace std; #define infy 0x3f3f3f3f #

Java併發程式設計中volatile實現過程詳細解析

首先併發程式設計有三大特性： 可見性，有序性，原子性。volatile關鍵字實現了前面兩個特性。那麼它是如何實現這兩個特性的呢？ 　　首先是可見性。可見性主要是讓快取，直接寫穿透到主存中。然後另外的cpu 通過底層的硬體層面的嗅探，可以發現自己cpu本地的快取已經失效。然後到主存中直接讀取。

陣列、氣泡排序、選擇排序

一、一維陣列 程式： 結果： 總結： （1)12行的結果為40：系統會為一個數組分配一段連續的儲存空間。每個資料元素佔用的位元組數，就是基型別的位元組數,一個元素佔4個位元組。int array1[10];由於陣列1是int型的（佔四個位元組），而且陣列1裡有

Java-十種內部排序實現（選擇，冒泡，插入，希爾，堆，歸併，快速，基數，計數，桶）及程式碼下載

選擇排序 氣泡排序 插入排序 希爾排序 堆排序 歸併排序 快速排序 基數排序 計數排序 桶排序 1. 選擇排序 這個排序方法最簡單，廢話不多說，直接上程式碼： public class SelectSort { /** * 選擇排

Java和C氣泡排序

Java 示例程式碼： public class test { public static void main(String[] args) { String str = "321dca5"; //需要排序的字串 char[] new_string; new_str

Java陣列3種排序方法

一、陣列封裝好的排序方法              public static void main(String[] args) {         i