java演算法數組
讀取數組元素，加一判斷數組兩個是否相等，相等直接輸出，不等，換行輸出。直到數組內所有元素都比完，程序結束。
Ⅱ java 數組錄入排序演算法
//給你寫了個新的
//給點財富鼓勵一下，ok？
import java.util.Arrays;
import java.util.Scanner;
public class lianxi
{
public static void main(String[] args)
{
int capacity=16,count=0;
int[] arr=new int[capacity];
Scanner sc=new Scanner(System.in);
String s=null;
System.out.println("請輸入要排序的數據，輸入exit結束：");
while(true)
{
s=sc.nextLine();
if(null!=s)
{
if(s.equals("exit"))
{
break;
}
else if(count+1>=capacity)
{
capacity*=2;
arr=Arrays.Of(arr,capacity);
}
arr[count++]=Integer.parseInt(s);
}
}
Arrays.sort(arr,0,count);
System.out.println("min="+arr[0]);
System.out.println("max="+arr[count-1]);
}
}
Ⅲ java數組演算法 求高手解答..
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class DuAry {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
String[][] string={{"A","1"},{"A","2"},{"B","3"},{"B","4"}};
for(int i = 0; i < string.length; i++){
String[] ary = string[i];
String cract = ary[0].trim();
if(map.containsKey(cract)){
map.put(cract,new Integer(map.get(cract).intValue() + Integer.parseInt(ary[1].trim())));
}else{
map.put(cract, new Integer(ary[1].trim()));
}
}
Iterator<Map.Entry<String, Integer>> ite = map.entrySet().iterator();
while(ite.hasNext()){
Map.Entry<String, Integer> entry = ite.next();
System.out.println(entry.getKey() + "\t" + entry.getValue());
}
}
}
-------------testing
B 7
A 3
--------------------演算法2：
import java.util.ArrayList;
import java.util.List;
public class DuArray2 {
public static void main(String[] args) {
String[][] string={{"A","1"},{"A","2"},{"B","3"},{"B","4"}};
List<Item> list = new ArrayList<Item>();
for(String[] ary: string){
String key = ary[0];
String value = ary[1];
boolean isFound = false;
for(Item item: list){
if(item.getKey().equals(key)){
item.add(Integer.parseInt(value));
isFound = true;
break;
}
}
if(!isFound){
list.add(new Item(key, Integer.parseInt(value)));
}
}
for(Item item: list){
System.out.println(item.toString());
}
}
}
class Item{
private String key;
private Integer value;
public Item(String key, Integer value){
this.key = key;
this.value = value;
}
public void add(int num){
this.value = new Integer(this.value.intValue() + num);
}
public String getKey() {
return key;
}
public String toString(){
return key + "\t" + value;
}
}
-----------testing result
A 3
B 7
Ⅳ Java的數組的幾種經典演算法
JAVA中在運用數組進行排序功能時，一般有四種方法：快速排序法、冒泡法、選擇排序法、插入排序法。
快速排序法主要是運用了Arrays中的一個方法Arrays.sort（）實現。
冒泡法是運用遍歷數組進行比較，通過不斷的比較將最小值或者最大值一個一個的遍歷出來。
選擇排序法是將數組的第一個數據作為最大或者最小的值，然後通過比較循環，輸出有序的數組。
插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。下面我就將他們的實現方法一一詳解供大家參考。
<1>利用Arrays帶有的排序方法快速排序
public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //進行排序 for(int i: a){ System.out.print(i); } } }
<2>冒泡排序演算法
public static int[] bubbleSort(int[] args){//冒泡排序演算法 for(int i=0;i<args.length-1;i++){ for(int j=i+1;j<args.length;j++){ if (args[i]>args[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; }
<3>選擇排序演算法
public static int[] selectSort(int[] args){//選擇排序演算法 for (int i=0;i<args.length-1 ;i++ ){ int min=i; for (int j=i+1;j<args.length ;j++ ){ if (args[min]>args[j]){ min=j; } } if (min!=i){ int temp=args[i]; args[i]=args[min]; args[min]=temp; } } return args; }
<4>插入排序演算法
public static int[] insertSort(int[] args){//插入排序演算法 for(int i=1;i<args.length;i++){ for(int j=i;j>0;j--){ if (args[j]<args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }
Ⅳ JAVA數組的幾種演算法能不能用通俗易懂的意思介紹一下
數組主要是排序。插入排序相當於玩撲克牌排序一次排序拿到數字直接插入最終位置，冒泡排序就想是燒開水一樣沒次排序把大的向上排序，（或者小的向上），快速排序就是找到一個中間的左邊一定比他小右邊一定比他大之後對左右繼續這種演算法。排序就這么多還有啥演算法暫時想不起來了你主要想問啥呢？
Ⅵ java數組的方法
1.;創建數組 1)先聲明,再用new進行內存分配 int arr[]; //一維數組 ...
2.;初始化 //一維數組 int arr1[] = new int[]{1,2,3,4,5...
3.;數組的基本操作 1)遍歷數組時,foreach語句更簡單 2)對數組元素進行替換--...
4.;對數組進行排序---Arrays類就靜態sort()方法-----可對任意類型數組...
5.;復制數組 1)Of()方法---復制數組至指定長度----開辟新的內存空間,原...
Ⅶ java數組和演算法的問題
arr[arr.length-1]=num;
43在這句的時候被num替換掉了
java的數組長度被初始化之後就是固定的
如果你想像裡面加入一個新值
需要重新定義數組，也就是說如果oldarr.length
=
5
你想像中見放第六個數是辦不到的
只能重新定義數據
int[]
newarr
=
new
int[oldarr+1]
這么來弄
Ⅷ java怎麼讓數組的數字從大到小排序
將數字從大到小排序的方法：
例如簡一點的冒泡排序，將第一個數字和後面的數字逐個比較大小，如果小於，則互換位置，大於則不動。此時，第一個數為數組中的最大數。然後再將第二個數與後面的數逐個比較，以次類推。
示例代碼如下：
publicclassTest{
publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //兩個數交換位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}
數組對於每一門編程語言來說都是重要的數據結構之一，當然不同語言對數組的實現及處理也不盡相同。
Java 語言中提供的數組是用來存儲固定大小的同類型元素。
你可以聲明一個數組變數，如 numbers[100] 來代替直接聲明 100 個獨立變數 number0，number1，....，number99
(8)java演算法數組擴展閱讀
Java中利用數組進行數字排序一般有4種方法：
1、選擇排序是先將數組中的第一個數作為最大或最小數，然後通過循環比較交換最大數或最小數與一輪比較中第一個數位置進行排序。
2、冒泡排序也是先將數組中的第一個數作為最大或最小數，循環比較相鄰兩個數的大小，滿足條件就互換位置，將最大數或最小數沉底。
3、快速排序法主要是運用Arrays類中的Arrays.sort方法（）實現。
4、插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。
Ⅸ java常用演算法,給個int數組,數字不連續,找出最小空缺數
public static void main(String[] args) {
int[] array = new int[] {1,2,3,6,7,8,9,10,11,12, 13, 14, 15, 16, 17, 18, 19, 20 };
//將數組拆分
int minque = 1;
if (1 == array[0]){
minque = zhaoque(array);
}
System.out.println(minque);
}
public static int zhaoque(int[] array){
int minque = 1;
//array 不為空
if (null != array && array.length>0){
if (array.length == 1){
minque = array[0]+1;
} else if(array.length == 2){
if (1 == (array[1] - array[0])){
minque = array[1]+1;
} else {
minque = array[0]+1;
}
} else {
int headlength = (array.length+1)/2;
int[] headArray = new int[headlength];
System.array(array,0,headArray,0,headlength);
//檢查前半部分是否密集
int headmin = headArray[0];
int headmax = headArray[headlength-1];
if (headlength > (headmax - headmin)){
//前部分密集分布
int footlength = array.length - headlength;
int[] footArray = new int[footlength];
System.array(array,headlength,footArray,0,footlength);
int footmin = footArray[0];
int footmax = footArray[footlength-1];
// 檢查後部分是否與前部分銜接
if (1 == (footmin - headmax)){
//檢查後部分是否密集
if (footlength > (footmax - footmin)){
//後半部分密集分布
minque = footmax +1;
} else {
minque = zhaoque(footArray);
}
} else {
minque = headmax +1;
}
} else {
minque = zhaoque(headArray);
}
}
}
return minque;
}
Ⅹ java 演算法數組（4，6，8，9，10，12，14，15，16，18，20，21，22，24，
importjava.util.Arrays;
importjava.util.LinkedList;
publicclassTest
{
publicstaticvoidrecursionSub(LinkedList<String[]>list,intcount,String[]array,intind,
intstart,int...indexs)
{
start++;
if(start>count-1)
{
return;
}
if(start==0)
{
indexs=newint[array.length];
}
for(indexs[start]=ind;indexs[start]<array.length;indexs[start]++)
{
recursionSub(list,count,array,indexs[start]+1,start,indexs);
if(start==count-1)
{
String[]temp=newString[count];
for(inti=count-1;i>=0;i--)
{
temp[start-i]=array[indexs[start-i]];
}
list.add(temp);
}
}
}
publicstaticvoidmain(String[]args)
{
Stringstring="4,6,8,9,10,12,14,15,16,18,20,21,22,24,25,26,27,28,30,32,33";
String[]A=string.split(",");
LinkedList<String[]>list=newLinkedList<String[]>();
recursionSub(list,4,A,0,-1);
for(String[]strings:list)
{
intsum=0;
for(inti=0;i<strings.length;i++)
{
inta=Integer.parseInt(strings[i]);
sum+=a;
}
if(sum>=80&&sum<90)
{
System.out.println(Arrays.toString(strings).replaceAll(",\s","+")+"="+sum);
}
}
}
}