人工智能 源 设计2

Linux：要义：一切都是文件。

Ruby：解说：把（linux）操作系统放入最基层的最稳定的四种算法之中构成源。

要义：一切皆文件

要义：每个人都能进入第一层，任何一个人都是造物主。

要义：一个终结者。

进行Ruby系统的Java的概念设计：

1.public class User{
  int id;
  String name;
  String pwd;

//1 号：排序
void bubbleSort1(int[] arr) {
    int A = 0;
    boolean swap;
    for (int i = arr.length - 1; i > 0; i--) { // 每次需要排序的长度
        swap=false;
        for (int j = 0; j < i; j++) { // 从第一个元素到第i个元素
            if (arr[j] > arr[j + 1]) {
                A = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = B;
                swap=true;
            }
        }//
        if (swap==false){
            break;
        }
    }//
}// 

//2号 两个排序相加

void bubbleSort2(int[] arr) {
    int B = A;
    boolean swap;
    for (int i = arr.length - 1; i > 0; i--) { // 每次需要排序的长度
        swap=false;
        for (int j = 0; j < i; j++) { // 从第一个元素到第i个元素
            if (arr[j] > arr[j + 1]) {
                B = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = B;
                if(swap==true){
        B=B+A;
    }
    
            }
        }//
        if (swap==false){
            break;
        }
    }//
}// 

Sxtstu(){
    
    

}

//3号 验证排序相加的结果，并把A，B，C都变成C。

void  bubbleSort3(int[] arr) {
int C = A;
    boolean swap;
    for (int i = arr.length - 1; i > 0; i--) { // 每次需要排序的长度
        swap=false;
        for (int j = 0; j < i; j++) { // 从第一个元素到第i个元素
            if (arr[j] > arr[j + 1]) {
                C = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = C;
                if(swap=true){
        C=(A+B)*2;
        }
    
            }
        }//
        if (swap==false){
            break;
        }
    
 }//
}// 

main函数
public class void main(String[] args){

SxtStu stu = new SxtStu();
stu.id = 1001;
stu.sname="命";
stu.age = 18;

stu.bubbleSort1();  
stu.bubbleSort2();
stu.bubbleSort3();  
}
抛弃A和B。取C。
C进入下一个工作站。

2 负责继承1
（1，2）【螺旋1】
1.1号[]是[（1号，2号）【不动】，（1号 , 2号），.....]

public static void insertionSort(int[] arr){
    for (int i=1; i<arr.length; ++i){
        int value = arr[i];
        int position=i;
        while (position>0 && arr[position-1]>value){
            arr[position] = arr[position-1];
            position--;
        }
        arr[position] = value;
    }//loop i
}

3.

public static void mergeSort(int[] arr){
    int[] temp =new int[arr.length];
    internalMergeSort(arr, temp, 0, arr.length-1);
}
private static void internalMergeSort(int[] arr, int[] temp, int left, int right){
    //当left==right的时，已经不需要再划分了
    if (left<right){
        int middle = (left+right)/2;
        internalMergeSort(arr, temp, left, middle);          //左子数组(螺旋数组A)
        internalMergeSort(arr, temp, middle+1, right);       //右子数组（螺旋数组B）
        mergeSortedArray(arr, temp, left, middle, right);    //合并两个子数组A+B
    }
}
// 合并两个有序子序列
private static void mergeSortedArray(int arr[], int temp[], int left, int middle, int right){
    int i=left;      
    int j=middle+1;
    int k=0;
    while (i<=middle && j<=right){
        temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
    }
    while (i <=middle){
        temp[k++] = arr[i++];
    }
    while ( j<=right){
        temp[k++] = arr[j++];
    }
    //把数据复制回原数组
    for (i=0; i<k; ++i){
        arr[left+i] = temp[i];

4.public abstract class Sorter {
     public abstract void sort(int[] array);
}
 
public class RadixSorter extends Sorter {
     
     private int radix;
     
     public RadixSorter() {
          radix = 10;
     }
     
     
     public void sort(int[] array) {
          // 数组的第一维表示可能的余数0-radix，第二维表示array中的等于该余数的元素
          // 如：十进制123的个位为3，则bucket[3][] = {123}
          int[][] bucket = new int[radix][array.length];
          int distance = getDistance(array); // 表示最大的数有多少位
          int temp = 1;
          int round = 1; // 控制键值排序依据在哪一位
          while (round <= distance) {
               // 用来计数：数组counter[i]用来表示该位是i的数的个数(螺旋1)
               int[] counter = new int[radix];
               // 将array中元素分布填充到bucket中，并进行计数
               for (int i = 0; i < array.length; i++) {
                    int which = (array[i] / temp) % radix;
                    bucket[which][counter[which]] = array[i];
                    counter[which]++;
               }
               int index = 0;
               // 根据bucket中收集到的array中的元素，根据统计计数，在array中重新排列
               for (int i = 0; i < radix; i++) {
                    if (counter[i] != 0)
                         for (int j = 0; j < counter[i]; j++) {
                              array[index] = bucket[i][j];
                              index++;
                         }
                    counter[i] = 0;
               }
               temp *= radix;
               round++;
          }
     }
     
     private int getDistance(int[] array) {
          int max = computeMax(array);
          int digits = 0;
          int temp = max / radix;
          while(temp != 0) {
               digits++;
               temp = temp / radix;
          }
          return digits + 1;
     }
     
     private int computeMax(int[] array) {
          int max = array[0];
          for(int i=1; i<array.length; i++) {
               if(array[i]>max) {
                    max = array[i];
               }
          }
          return max;
     }
}

由于linux是由c语言和汇编语言构成的，java的运行也需要虚拟机。很多人认为Linux编程的系统修改必须要依托c或者从汇编的开始写。我们可以用以上稳定的四种算法来设计一个平衡体。或者说这个平衡体已经完成。

下一次，我将把Linux的内核放进去。