行列「行列」
配列の注意:
配列は参照データの種類です.線形構造です.
lengthは、その唯一の属性の下付き操作です.
一次元配列
プラクティック配列
具体化配列のいくつかのタイプ---具体化した後、値を付与するにはループしなければなりません.
データタイプ[]配列名=newデータタイプ[長さ];-----声明の同時実装
データタイプ[]配列名;
配列名==newデータタイプ[長さ]先に声明して実用化する.
割り当ての種類
データタイプ[]配列名=newデータタイプ[長さ]{値...-----を実装し、値を割り当てます.
データタイプ[]配列名={値...}----直接割当オープンスペース
データタイプ[]配列名;
配列名==newデータタイプ[長さ]{値...;先に声明した後に、具体的な割り当てを行います.
二次元配列
実用化の面では、一次元配列と同じです. 二つに変更すればいいです.また{値}行列が必要です.
違い点:
一次元配列名.lengthは配列長を直接表します.
二次元配列の中の配列名.lengthは行数データ名[].lengthは列数を表します.
優勢
アクセス速度が速い 同じタイプのデータを複数記憶できます.
劣勢
同じタイプのデータのみ保存できます.
スペースがロードできません.または短縮できません.
同じタイプの配列しか相手に与えられません.
キュー
パッケージの種類は配列の操作に対して解決します.配列中の空間問題は一つのデータタイプの問題しか記憶できません.
汎型Eという概念を使って、多様なデータ記憶を実現します.
タスク:
1.ランダム2000-3000間のデータは、1次元配列に保存され、3つの方法で配列を並べ替えます.
2.二次元配列を実例化し、配列の各要素に値を割り当て、そして最大値の要素を探し出すが、配列を変更しないことを覚えておく.
3.共通のキューを実現する
4.行列と行列のまとめ
1ランダム2000-3000間のデータは1次元配列に保存され、3つの方法で配列を並べ替えます.
アイデアは、最初に行列オブジェクトを作成します.
その後、循環とランダム関数を利用して一次元配列に値を割り当てます.
並べ替えの考えを挿入
外層循環選択要素は第二の要素から最後の要素まで選択されます.
現在の要素のメモリサイクルに入る要素を選択します.
前の元素が整然としていると仮定して、この元素を前のものと比較して大きくすればメモリが循環します.
終了後は、前の要素より小さいものを比較し続けます.
泡を並べて二つを並べて順番に交換します.
外層循環制御の本数は全部でこの配列の長さ-1回のメモリ循環制御と2つの比較を行います.
最初に一番大きな数を順番に並べて、二番目に大きいものを順番に並べます.
並べ替えを選択
現在の要素を変数に下付きし、変数として下付きする要素は他の要素と比較するとより小さい要素がスケールされます. の変数に入れて、最後に変数と要素の小スケールと現在の要素の下付きが同じかどうかを判断します. 小さいの
考え方を二次元配列に例証し、2層の循環割当値を利用する.
循環を利用して最大値を探し出します.具体的には、まず最初の要素を最大の変数として仮定して、循環を利用して表量と他の要素と比較して大きな変数に入れます. 最後の出力
まず一つのインターフェースを定義して、列の中で実現する方法を書いてからテストクラスが必要です.
列の中の方法が正しいかどうかを見ます.
元の配列の実際化をキューに配置する関数は、OLL.lengthとinitcountの違いを区別します.
OB.lengthは配列の長さを表します. initcount新規要素の個数にコンストラクションを加えた与えられた既存の要素の個数
配列は参照データの種類です.線形構造です.
lengthは、その唯一の属性の下付き操作です.
一次元配列
プラクティック配列
具体化配列のいくつかのタイプ---具体化した後、値を付与するにはループしなければなりません.
データタイプ[]配列名=newデータタイプ[長さ];-----声明の同時実装
データタイプ[]配列名;
配列名==newデータタイプ[長さ]先に声明して実用化する.
割り当ての種類
データタイプ[]配列名=newデータタイプ[長さ]{値...-----を実装し、値を割り当てます.
データタイプ[]配列名={値...}----直接割当オープンスペース
データタイプ[]配列名;
配列名==newデータタイプ[長さ]{値...;先に声明した後に、具体的な割り当てを行います.
二次元配列
実用化の面では、一次元配列と同じです. 二つに変更すればいいです.また{値}行列が必要です.
違い点:
一次元配列名.lengthは配列長を直接表します.
二次元配列の中の配列名.lengthは行数データ名[].lengthは列数を表します.
優勢
アクセス速度が速い 同じタイプのデータを複数記憶できます.
劣勢
同じタイプのデータのみ保存できます.
スペースがロードできません.または短縮できません.
同じタイプの配列しか相手に与えられません.
キュー
パッケージの種類は配列の操作に対して解決します.配列中の空間問題は一つのデータタイプの問題しか記憶できません.
汎型Eという概念を使って、多様なデータ記憶を実現します.
タスク:
1.ランダム2000-3000間のデータは、1次元配列に保存され、3つの方法で配列を並べ替えます.
2.二次元配列を実例化し、配列の各要素に値を割り当て、そして最大値の要素を探し出すが、配列を変更しないことを覚えておく.
3.共通のキューを実現する
4.行列と行列のまとめ
1ランダム2000-3000間のデータは1次元配列に保存され、3つの方法で配列を並べ替えます.
アイデアは、最初に行列オブジェクトを作成します.
その後、循環とランダム関数を利用して一次元配列に値を割り当てます.
並べ替えの考えを挿入
外層循環選択要素は第二の要素から最後の要素まで選択されます.
現在の要素のメモリサイクルに入る要素を選択します.
前の元素が整然としていると仮定して、この元素を前のものと比較して大きくすればメモリが循環します.
終了後は、前の要素より小さいものを比較し続けます.
泡を並べて二つを並べて順番に交換します.
外層循環制御の本数は全部でこの配列の長さ-1回のメモリ循環制御と2つの比較を行います.
最初に一番大きな数を順番に並べて、二番目に大きいものを順番に並べます.
並べ替えを選択
現在の要素を変数に下付きし、変数として下付きする要素は他の要素と比較するとより小さい要素がスケールされます. の変数に入れて、最後に変数と要素の小スケールと現在の要素の下付きが同じかどうかを判断します. 小さいの
package cn.tjn.study0713;
import java.util.Random;
public class Text1Array {
public static void main(String[] args) {
int array[] = creatArray(10);
print(array);
System.out.println("=================== =================");
charu(array);
print(array);
System.out.println("=================== =================");
maopao(array);
print(array);
System.out.println("=================== =================");
xuanze(array);
print(array);
}
public static int[] creatArray(int length) {
int array[] = new int[length];
Random rand = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = rand.nextInt(1000) + 2000;
}
return array;
}
public static void print(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + "\t");
}
System.out.println();
}
//
public static void charu(int[] array) {
for (int i = 1; i < array.length; i++) {
int k = array[i];
for (int j = i; j >= 1; j--) {
if (k < array[j - 1]) {
array[j] = array[j-1];
array[j-1] = k;
}
}
}
}
//
public static void maopao(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
//
public static void xuanze(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
int k = i;
for (int j = i+1; j < array.length; j++) {
if (array[j] < array[k]) {
k = j;
}
if (k != i) {
int temp = array[i];
array[i] = array[k];
array[k] = temp;
}
}
}
}
}
考え方を二次元配列に例証し、2層の循環割当値を利用する.
循環を利用して最大値を探し出します.具体的には、まず最初の要素を最大の変数として仮定して、循環を利用して表量と他の要素と比較して大きな変数に入れます. 最後の出力
ackage cn.tjn.study0713;
import java.util.Random;
public class Text2Array {
public static void main(String[] args) {
int[][] array = creat(5,5);
print(array);
max(array);
}
public static int[][] creat(int row, int column){
int[][] array = new int [row][column];
Random rand = new Random();
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
array[i][j]=rand.nextInt(100);
}
}
return array;
}
public static void max(int[][] array){
int k=array[0][0];
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
if(k<=array[i][j]){
k=array[i][j];
}
}
}
System.out.println(k);
}
public static void print(int[][] array){
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
}
まず一つのインターフェースを定義して、列の中で実現する方法を書いてからテストクラスが必要です.
列の中の方法が正しいかどうかを見ます.
元の配列の実際化をキューに配置する関数は、OLL.lengthとinitcountの違いを区別します.
OB.lengthは配列の長さを表します. initcount新規要素の個数にコンストラクションを加えた与えられた既存の要素の個数
package cn.tjn.study0713;
/**
* SamlpList
*
* @author Administrator
*
*/
public class SampleList<E> implements Spl<E> {
//
private Object[] obl = null;
//
private int initCount = 0;
private int incresCount = 1;
//
public SampleList() {
obl = new Object[0];
}
//
public SampleList(int initCount) {
this.initCount = initCount;
obl = new Object[initCount];
}
// ，
public SampleList(int initCount, int incresCount) {
this.initCount = initCount;
obl = new Object[initCount];
this.incresCount = incresCount;
}
// +1
public void add(E e) {
Object[] temp = new Object[obl.length + incresCount];
for (int i = 0; i < obl.length; i++) {
temp[i] = obl[i];
}
temp[obl.length] = e;
this.initCount++;
obl = temp;
}
//
public void addall(SampleList<E> list) {
Object[] temp = new Object[obl.length + list.size()];
for (int i = 0; i < obl.length; i++) {
temp[i] = obl[i];
}
for (int i = 0; i < list.size(); i++) {
temp[i + obl.length] = list.get(i);
this.initCount++;
}
obl = temp;
}
// -1
public E delete(int index) {
E item = (E) obl[index];
for (int i = index; i < obl.length; i++) {
obl[i] = obl[i + 1];
}
this.initCount--;
return item;
}
//
public E get(int index) {
if (index < 0 || index > initCount)
return null;
E item = (E) obl[index];
return item;
}
//
public void insert(E str, int index) {
obl[index] = str;
}
//
public int size() {
return initCount;
}
}
package cn.tjn.study0713;
/**
*
*
* @author NetJava
*
*/
public interface Spl<E> {
//
public void insert(E str, int index);
// +1
public void add(E str);
//
public E get(int index);
//
public int size();
// -1
public E delete(int index);
//
public void addall(SampleList<E> list);
}
package cn.tjn.study0713;
/**
* @author
*/
public class Splmain {
/**
*
*/
public static void main(String[] args) {
//
SampleList spll1= new SampleList();
SampleList spll2= new SampleList(5);
// spll1 2
String str1=" ";
int i1=5;
spll1.add(str1);
spll1.add(i1);
//
for(int i=0;i<spll1.size();i++){
System.out.println(spll1.get(i));
}
System.out.println("spll1 ："+spll1.size());
System.out.println("===========================================");
String str2=" ";
int i2=3;
spll2.add(str2);
spll2.add(i2);
//
for(int i=0;i<spll1.size();i++){
System.out.println(spll2.get(i));
}
System.out.println("spll2 ："+spll2.size());
System.out.println("===========================================");
spll2.addall(spll1);
//
for(int i=0;i<spll2.size();i++){
System.out.println(spll2.get(i));
}
System.out.println(spll2.size());
System.out.println("===========================================");
}
}