莊周夢蝶

??? 放假這幾天，喝了很多酒，讀完一本書，想念一個(gè)人，花了不少錢
????3月1號(hào)上班了，明天提前出發(fā)去適應(yīng)氣候（見鬼，明明是想MM嘛......），昨天在china-pub上訂的書也到了。計(jì)劃下最近的學(xué)習(xí)計(jì)劃，把3本書掃尾：《javascript高級程序設(shè)計(jì)》剩下兩章，《數(shù)據(jù)結(jié)構(gòu)與算法》排序和圖論還沒讀完，另外有空再有選擇地重讀一遍《設(shè)計(jì)模式》。用ruby重寫osworkflow，開始寫吧，不知道能不能寫出來

1。概念：堆是一種特殊的二叉樹，具備以下兩種性質(zhì)
1）每個(gè)節(jié)點(diǎn)的值都大于（或者都小于，稱為最小堆）其子節(jié)點(diǎn)的值
2）樹是完全平衡的，并且最后一層的樹葉都在最左邊
這樣就定義了一個(gè)最大堆。

2。堆可以用一個(gè)數(shù)組表示，有如下性質(zhì)：
heap[i]>=heap[2*i+1]? 其中0<=i<=(n-1)/2
heap[i]>=heap[2*i+2]? 其中0<=i<=(n-2)/2

3。用數(shù)組實(shí)現(xiàn)堆，
1）插入操作
自頂向下，偽代碼：

自底向上，偽代碼：
??
2)moveDown的方法實(shí)現(xiàn)，此方法是堆排序的關(guān)鍵，也是刪除操作的關(guān)鍵。刪除操作，將根節(jié)點(diǎn)刪除，并把最末的樹葉換到根節(jié)點(diǎn)，通過moveDown方法找到正確的位置，恢復(fù)堆性質(zhì)。

4。堆的一個(gè)實(shí)現(xiàn)：

// heap.java
// demonstrates heaps
// to run this program: C>java HeapApp
import java.io.*;
////////////////////////////////////////////////////////////////
class Node
   {
   private int iData;             // data item (key)
// -------------------------------------------------------------
   public Node(int key)           // constructor
      { iData = key; }
// -------------------------------------------------------------
   public int getKey()
      { return iData; }
// -------------------------------------------------------------
   public void setKey(int id)
      { iData = id; }
// -------------------------------------------------------------
   }  // end class Node
////////////////////////////////////////////////////////////////
class Heap
   {
   private Node[] heapArray;
   private int maxSize;           // size of array
   private int currentSize;       // number of nodes in array
// -------------------------------------------------------------
   public Heap(int mx)            // constructor
      {
      maxSize = mx;
      currentSize = 0;
      heapArray = new Node[maxSize];  // create array
      }
// -------------------------------------------------------------
   public boolean isEmpty()
      { return currentSize==0; }
// -------------------------------------------------------------
   public boolean insert(int key)
      {
      if(currentSize==maxSize)
         return false;
      Node newNode = new Node(key);
      heapArray[currentSize] = newNode;
      trickleUp(currentSize++);
      return true;
      }  // end insert()
// -------------------------------------------------------------
   public void trickleUp(int index)
      {
      int parent = (index-1) / 2;
      Node bottom = heapArray[index];

      while( index > 0 &&
             heapArray[parent].getKey() < bottom.getKey() )
         {
         heapArray[index] = heapArray[parent];  // move it down
         index = parent;
         parent = (parent-1) / 2;
         }  // end while
      heapArray[index] = bottom;
      }  // end trickleUp()
// -------------------------------------------------------------
   public Node remove()           // delete item with max key
      {                           // (assumes non-empty list)
      Node root = heapArray[0];
      heapArray[0] = heapArray[--currentSize];
      trickleDown(0);
      return root;
      }  // end remove()
// -------------------------------------------------------------
   public void trickleDown(int index)
      {
      int largerChild;
      Node top = heapArray[index];       // save root
      while(index < currentSize/2)       // while node has at
         {                               //    least one child,
         int leftChild = 2*index+1;
         int rightChild = leftChild+1;
                                         // find larger child
         if(rightChild < currentSize &&  // (rightChild exists?)
                             heapArray[leftChild].getKey() <
                             heapArray[rightChild].getKey())
            largerChild = rightChild;
         else
            largerChild = leftChild;
                                         // top >= largerChild?
         if( top.getKey() >= heapArray[largerChild].getKey() )
            break;
                                         // shift child up
         heapArray[index] = heapArray[largerChild];
         index = largerChild;            // go down
         }  // end while
      heapArray[index] = top;            // root to index
      }  // end trickleDown()
// -------------------------------------------------------------
   public boolean change(int index, int newValue)
      {
      if(index<0 || index>=currentSize)
         return false;
      int oldValue = heapArray[index].getKey(); // remember old
      heapArray[index].setKey(newValue);  // change to new

      if(oldValue < newValue)             // if raised,
         trickleUp(index);                // trickle it up
      else                                // if lowered,
         trickleDown(index);              // trickle it down
      return true;
      }  // end change()
// -------------------------------------------------------------
   public void displayHeap()
      {
      System.out.print("heapArray: ");    // array format
      for(int m=0; m<currentSize; m++)
         if(heapArray[m] != null)
            System.out.print( heapArray[m].getKey() + " ");
         else
            System.out.print( "-- ");
      System.out.println();
                                          // heap format
      int nBlanks = 32;
      int itemsPerRow = 1;
      int column = 0;
      int j = 0;                          // current item
      String dots = "...............................";
      System.out.println(dots+dots);      // dotted top line

      while(currentSize > 0)              // for each heap item
         {
         if(column == 0)                  // first item in row?
            for(int k=0; k<nBlanks; k++)  // preceding blanks
               System.out.print(' ');
                                          // display item
         System.out.print(heapArray[j].getKey());

         if(++j == currentSize)           // done?
            break;

         if(++column==itemsPerRow)        // end of row?
            {
            nBlanks /= 2;                 // half the blanks
            itemsPerRow *= 2;             // twice the items
            column = 0;                   // start over on
            System.out.println();         //    new row
            }
         else                             // next item on row
            for(int k=0; k<nBlanks*2-2; k++)
               System.out.print(' ');     // interim blanks
         }  // end for
      System.out.println("/n"+dots+dots); // dotted bottom line
      }  // end displayHeap()
// -------------------------------------------------------------
   }  // end class Heap
////////////////////////////////////////////////////////////////
class HeapApp
   {
   public static void main(String[] args) throws IOException
      {
      int value, value2;
      Heap theHeap = new Heap(31);  // make a Heap; max size 31
      boolean success;

      theHeap.insert(70);           // insert 10 items
      theHeap.insert(40);
      theHeap.insert(50);
      theHeap.insert(20);
      theHeap.insert(60);
      theHeap.insert(100);
      theHeap.insert(80);
      theHeap.insert(30);
      theHeap.insert(10);
      theHeap.insert(90);

      while(true)                   // until [Ctrl]-[C]
         {
         System.out.print("Enter first letter of ");
         System.out.print("show, insert, remove, change: ");
         int choice = getChar();
         switch(choice)
            {
            case 's':                        // show
               theHeap.displayHeap();
               break;
            case 'i':                        // insert
               System.out.print("Enter value to insert: ");
               value = getInt();
               success = theHeap.insert(value);
               if( !success )
                  System.out.println("Can't insert; heap full");
               break;
            case 'r':                        // remove
               if( !theHeap.isEmpty() )
                  theHeap.remove();
               else
                  System.out.println("Can't remove; heap empty");
               break;
            case 'c':                        // change
               System.out.print("Enter current index of item: ");
               value = getInt();
               System.out.print("Enter new key: ");
               value2 = getInt();
               success = theHeap.change(value, value2);
               if( !success )
                  System.out.println("Invalid index");
               break;
            default:
               System.out.println("Invalid entry/n");
            }  // end switch
         }  // end while
      }  // end main()
//-------------------------------------------------------------
   public static String getString() throws IOException
      {
      InputStreamReader isr = new InputStreamReader(System.in);
      BufferedReader br = new BufferedReader(isr);
      String s = br.readLine();
      return s;
      }
//-------------------------------------------------------------
   public static char getChar() throws IOException
      {
      String s = getString();
      return s.charAt(0);
      }
//-------------------------------------------------------------
   public static int getInt() throws IOException
      {
      String s = getString();
      return Integer.parseInt(s);
      }
//-------------------------------------------------------------
  }  // end class HeapApp
////////////////////////////////////////////////////////////////

樹的平衡，我們已經(jīng)知道DWL算法，不過DWL算法需要從整體上平衡樹，但是樹的平衡也可以局部的進(jìn)行，由Adel'son-Vel'skii-Landis提出了一種經(jīng)典方法，稱為AVL樹。

1。概念：AVL樹，或者說可適應(yīng)樹，是指樹中每個(gè)節(jié)點(diǎn)的的平衡因子的絕對值不大于1，即只能為-1，0，1
平衡因子：節(jié)點(diǎn)的右子樹的高度減去左子樹的高度

2。AVL樹的插入：從新插入節(jié)點(diǎn)到根的路徑上，修改遇到的節(jié)點(diǎn)的平衡因子即可，對其他部分沒影響
1）向右子女的右子樹插入一個(gè)節(jié)點(diǎn)，單旋轉(zhuǎn)就可以
2）向右子女的左子樹插入一個(gè)節(jié)點(diǎn)，雙旋轉(zhuǎn)，先圍繞父節(jié)點(diǎn)，再圍繞祖父節(jié)點(diǎn)

3。AVL樹的刪除：從刪除節(jié)點(diǎn)到根的路徑上，任何不平衡因子的節(jié)點(diǎn)都需要修改，與插入不同，需要O(lgn)次旋轉(zhuǎn)。

4。一個(gè)java實(shí)現(xiàn)：
http://www.koders.com/java/fid3B5247D34968077A6EFD4216589026D343559FF9.aspx?s=avl%2Btree

1。遞歸的定義：
遞歸的定義由兩部分組成：
1）稱作定位點(diǎn)（anchor）或者基本情況（ground case），它們是一些基本元素，這些基本元素是集合序列中其他所有對象的基礎(chǔ)。
2）給出除基本元素或者已創(chuàng)建對象之外的新對象的構(gòu)造規(guī)則，可以再三使用這個(gè)規(guī)則不斷產(chǎn)生新的對象。

2。遞歸的實(shí)現(xiàn)：一般是由操作系統(tǒng)完成的，但是大部分的計(jì)算機(jī)系統(tǒng)的遞歸定義都是利用運(yùn)行時(shí)堆棧實(shí)現(xiàn)的。在系統(tǒng)內(nèi)，無論何時(shí)調(diào)用一個(gè)方法都會(huì)創(chuàng)建一個(gè)活動(dòng)記錄。一個(gè)遞歸調(diào)用并不僅僅是一個(gè)方法調(diào)用其自身，而是方法的一個(gè)instance調(diào)用相同方法的另一個(gè)instance，在計(jì)算機(jī)內(nèi)部，這些調(diào)用是用不同的活動(dòng)記錄表示，并由系統(tǒng)區(qū)分。

3。尾遞歸：
僅在方法的末尾實(shí)行一次遞歸調(diào)用，這樣的遞歸叫尾遞歸。尾遞歸很容易被循環(huán)所替換，或者說它只是一個(gè)名字比較好聽的循環(huán)，如：

替換為循環(huán)：


尾遞歸對一些沒有顯式循環(huán)結(jié)構(gòu)的語言（如Prolog）特別重要

4。非尾遞歸：
遞歸相比于迭代結(jié)構(gòu)的優(yōu)點(diǎn)就是非常清晰并易于理解，這一點(diǎn)可以在二叉樹遍歷上得到體現(xiàn)。3種遍歷方式的遞歸版本與迭代版本在可讀性上不可同日而語。
問題：逆序輸出一行輸入（以ruby語言為例）



運(yùn)行此程序，輸入一行字符，將逆序輸出，本質(zhì)上是利用運(yùn)行時(shí)堆棧完成的遞歸調(diào)用

5。間接遞歸：
方法通過一連串的調(diào)用，然后間接地調(diào)用它自身，這樣的遞歸稱為間接遞歸。
6。嵌套遞歸
一般出現(xiàn)在函數(shù)的定義中，如果這個(gè)函數(shù)不僅用它自身定義，而且還江它自身作為一個(gè)參數(shù)，如：
???? 0????? ???? ?n=0
h(n)=n??? ???? n>4
h(2+h(2n))?? n<=4

7。過分遞歸：遞歸帶來的邏輯簡單性和可讀性的代價(jià)是拖長了運(yùn)行時(shí)間并且相對于非遞歸方法，它占用了更多的運(yùn)行時(shí)堆棧空間。如果遞歸層次太深，可能導(dǎo)致運(yùn)行時(shí)堆棧溢出，程序非正常結(jié)束的錯(cuò)誤。

8。回溯（backtracking技術(shù)）：在某點(diǎn)有多條道路供選擇的時(shí)候，但不清楚哪一條能解決問題。在嘗試一條道路失敗后，返回岔口再試另一條道路。但是必須確定所有的道路都是可嘗試的，可返回的。這種技術(shù)成為回溯。
在迷宮問題中和8皇后問題中使用此技術(shù)。具體程序不再列出（好長@_@）

一。直接插入排序
1。直接插入排序：直接插入排序是一種簡單的排序方法，它的基本思想是將待排序的記錄按照其值的大小插入到已排好序的有序表的適當(dāng)位置，直到全部插入完為止。舉個(gè)整型的排序例子
2。直接插入排序的偽代碼：

insertionsort(data[])
???for?i=1?to?data.length-1
???????tmp=data[i];
???????將所有大于tmp的元素data[j]向后移動(dòng)一位;
???????將tmp放在正確的位置上;

3.簡單例子，以整型為例。
A）ruby語言實(shí)現(xiàn)：
?

def?insertion_sort(a)
??i=1
??while?i<a.length
????tmp=a[i]
????j=i
????while?j>0
??????break?if?tmp>a[j-1]
??????a[j]=a[j-1]
??????j-=1
????end
????a[j]=tmp
????i+=1
??end
end???????
a=[10,2,3]
insertion_sort(a)
a.each{|i?|?print?i.to_s+"?"}

B）java語言實(shí)現(xiàn)：

package?com.sohu.blog.denns_zane.sort;

public?class?InsertSort{
????public?static?void?main(String?args[]){
????????int?[]data={12,2,3,56,90};
????????insertsort(data);
????????for(int?i=0;i<data.length;i++){
????????????System.out.print(data[i]+"?");
????????}
????}
????public?static?void?insertsort(int?[]data){
????????for(int?i=1,j;i<data.length;i++){
????????????int?tmp=data[i];
????????????for(j=i;j>0&&tmp<data[j-1];j--)
???????????????data[j]=data[j-1];
????????????data[j]=tmp;???
????????}
????}
}

5。算法復(fù)雜度：
最好情況：進(jìn)行n-1次比較和2(n-1)次移動(dòng)，盡管他們其實(shí)都是多余的，復(fù)雜度O(n)
最壞情況：具體計(jì)算略，O(n*n)
平均情況：O(n*n)，也就是接近最壞情況，在平均情況下，數(shù)組大小翻倍，它的排序工作將是原來的4倍。

二。選擇排序
1。算法描述：選擇算法試圖先查找一個(gè)放錯(cuò)位置的元素并將它放到最終位置上，以此來局部化數(shù)組元素的交換。選擇值最小的元素并將它和第一個(gè)位置上的元素交換。在第i步中，查找data[i],...,data[n-1]中的最小元素，并將它和data[i]進(jìn)行交換。重復(fù)此過程，直到所有的元素都放入正確的位置為止。

2。偽代碼描述：

selectionsort(data[])
?????for?i=0?to?data.length-2
????????從data[i],,data[n-1]中選取最小的元素
????????將它和data[i]交換

?
3。實(shí)現(xiàn)，以整型數(shù)組為例：
1)ruby語言實(shí)現(xiàn)：

def?selection_sort(a)
??least=0
??for?i?in?(0..(a.length-2))
????j=i+1
????least=i
????while?j<a.length
??????if?a[j]<a[least]
????????least=j
??????end
??????j+=1??
????end
????a[least],a[i]=a[i],a[least]?unless?least==i?#交換
??end
end
a=[12,4,34,23,45,35]
selection_sort(a)
a.each{|i|?print?i.to_s+"?"}

代碼很好理解，不做解釋。

2）java語言實(shí)現(xiàn)：

package?com.sohu.blog.denns_zane.sort;

public?class?SelectionSort{
????public?static?int[]?selection_sort(int?[]?data){
????????int?i,j,least=0;
????????for(i=0;i<data.length-1;i++){
????????
??????????for(j=i+1,least=i;j<data.length;j++)
????????????if?(data[j]<=data[least])
????????????????????least=j;
??????????if?(least!=i)
????????????swap(data,least,i);??//????data[i]oí×?D??a??
????????}????
????????return?data;???
????}
????public?static?void?swap(int[]data,int?least,int?i){
????????int?tmp=data[least];
????????data[least]=data[i];
????????data[i]=tmp;
????}
????public?static?void?main(String?args[]){
????????int[]?t={10,29,12,23,56};
????????selection_sort(t);
????????for(int?i:t){
????????????System.out.print(i+"?");
????????}?
????}
}

4.算法效率：
任何情況下，都需要進(jìn)行n*(n-1)/2次比較，也就是O(n*n)的復(fù)雜度
最好情況：數(shù)組已經(jīng)排序，不需要交換任何元素
最壞情況：最大元素在第一個(gè)位置而其他元素有序時(shí)，需要進(jìn)行3*(n-1)次交換，即O(n)，也是很好的結(jié)果

三。冒泡排序
1。算法偽代碼描述：

bubblesort(data[])
??for?i=0?to?data.length-2
?????for?j=data.length-1?downto?i+1
?????????如果順序錯(cuò)誤，就交換j和j-1位置上的元素

2。實(shí)現(xiàn)：
1)ruby語言實(shí)現(xiàn)：

def?bubble_sort(data)
??for?i?in?(0..(data.length-2))
?????j=data.length-1
?????while?j>i
????????if?data[j]<data[j-1]
???????????data[j],data[j-1]=data[j-1],data[j]???#交換
????????end
????????j-=1
?????end
??end
end
a=[12,3,56,7,89,87]
bubble_sort(a)
a.each{|i|?print?i.to_s+"?"}

2）java語言實(shí)現(xiàn)：

package?com.sohu.blog.denns_zane.sort;

public?class?BubbleSort{
????public?static?void?bubble_sort(int?[]?data){
????????for(int?i=0;i<data.length-1;i++)
????????????for(int?j=data.length-1;j>i;j--)
??????????????if(data[j]<data[j-1])
????????????????swap(data,j,j-1);
????????
????}
????public?static?void?swap(int[]data,int?least,int?i){
????????int?tmp=data[least];
????????data[least]=data[i];
????????data[i]=tmp;
????}
????public?static?void?main(String?args[]){
????????int[]?t={10,29,12,23,56};
????????bubble_sort(t);
????????for(int?i:t){
????????????System.out.print(i+"?");
????????}?
????}
}

3。算法效率：
冒泡排序的比較次數(shù)近似是插入排序的兩倍，和選擇排序相同；移動(dòng)次數(shù)和插入排序相同，是選擇排序的n倍。可以說，插入排序比冒泡排序快兩倍。

     摘要: 一。棧1。概念：棧（stack）是一種線性數(shù)據(jù)結(jié)構(gòu)，只能訪問它的一端來存儲(chǔ)或者讀取數(shù)據(jù)。棧是一種后進(jìn)先出的結(jié)構(gòu)（LIFO)2。棧的主要操作：.clear()——清棧.isEmpty()——檢查棧是否為空.push(e)——壓棧.pop()——出棧.topEl()——返回棧頂元素3。棧的java實(shí)現(xiàn)：使用數(shù)組鏈表實(shí)現(xiàn)/**?*//**?*??*/package?com.sohu.blog.denns...  閱讀全文

     摘要: 一 樹、二叉樹和二叉查找樹 1。樹的概念： 遞歸定義： 1） 一個(gè)空結(jié)構(gòu)是一個(gè)空樹 2）如果t1,...,tk是分離的樹，那么以t1,...,tk的根為子節(jié)點(diǎn)的根結(jié)構(gòu)也是樹 3）只有按照1，2規(guī)則產(chǎn)生的結(jié)構(gòu)才是樹 樹的概念更多用于分層結(jié)構(gòu)，比如數(shù)據(jù)庫管理系統(tǒng)的分層模型。 2。二叉樹（binary tree）：所有節(jié)點(diǎn)都有兩個(gè)子節(jié)點(diǎn)（可以為空），并且每個(gè)子節(jié)...  閱讀全文

     摘要: 數(shù)組的兩大缺點(diǎn)： 1。若改變數(shù)組的大小就要?jiǎng)?chuàng)建一個(gè)新的數(shù)組，并需要從原數(shù)組復(fù)制所有的數(shù)據(jù)到新的數(shù)組 2。數(shù)組元素在內(nèi)存中依次順序存儲(chǔ)，這意味著向數(shù)組插入一項(xiàng)要移動(dòng)數(shù)組中的其他元素 因此，我們使用鏈?zhǔn)浇Y(jié)構(gòu)，鏈?zhǔn)浇Y(jié)構(gòu)是存儲(chǔ)數(shù)據(jù)的結(jié)點(diǎn)以及指向其他節(jié)點(diǎn)的指針的集合。如此一來，節(jié)點(diǎn)可以位于內(nèi)存的任意位置，而且從一個(gè)節(jié)點(diǎn)到另一個(gè)節(jié)點(diǎn)的傳遞可以通過在結(jié)構(gòu)中存儲(chǔ)節(jié)點(diǎn)間引用來實(shí)現(xiàn)。 一。單向...  閱讀全文

C#的using語句設(shè)計(jì)的蠻貼心，比java的import有趣一點(diǎn)。轉(zhuǎn)一篇文章.

C#中的using除了作為命名空間指示符(using System)，類型的別名指示符(using Dos=System.Console)，還有資源管理的語句功能：
using (R r1 = new R ()) {
? ?r1.F();
}
在C#中被翻譯為：

R?r1?=?new?R();
try?{
???r1.F();
}
finally?{
???if?(r1?!=?null)?((IDisposable)r1).Dispose();
}

r1當(dāng)然要支持Dispose()方法了

再來一個(gè)例子：

使用using會(huì)自動(dòng)調(diào)用MyObject的Dispose方法.

一.C#的統(tǒng)一類型系統(tǒng)
1.C#的類型系統(tǒng)是統(tǒng)一的，java的類型系統(tǒng)分為：基本類型（原生類型）和類類型，而C#的所有類型直接或間接地從object類類型派生而來，從類型系統(tǒng)上來看比java更OO。
2.C#的類型分為三類：
（1）值類型，一個(gè)值類型或是結(jié)構(gòu)類型，或是枚舉類型
（2）引用類型
（3）指針類型
值類型與引用類型的不同在于：值類型的變量直接包含其數(shù)據(jù)，而引用類型的變量存儲(chǔ)對其數(shù)據(jù)的引用(reference)，后者稱為對象(object)。對于引用類型，兩個(gè)變量可能引用同一個(gè)對象，因此對一個(gè)變量的操作可能影響另一個(gè)變量所引用的對象。對于值類型，每個(gè)變量都有自己的數(shù)據(jù)副本，對一個(gè)變量的操作不可能影響另一個(gè)變量。
二。值類型
1.所有值類型從類System.ValueType隱式繼承，后者又從類object繼承。任何類型都不可能從值類型派生。

2.所有值類型都隱式聲明一個(gè)稱為默認(rèn)構(gòu)造函數(shù)(default constructor)的公共無參數(shù)實(shí)例構(gòu)造函數(shù)。默認(rèn)構(gòu)造函數(shù)返回一個(gè)零初始化實(shí)例，它就是該值類型的默認(rèn)值(default value)：

·???????? 對于所有simple-types，默認(rèn)值是將其所有位都置零的位模式所形成的值：

o??????? 對于sbyte、byte、short、ushort、int、uint、long和ulong，默認(rèn)值為0。

o??????? 對于char，默認(rèn)值為'\x0000'。

o??????? 對于float，默認(rèn)值為0.0f。

o??????? 對于double，默認(rèn)值為0.0d。

o??????? 對于decimal，默認(rèn)值為0.0m。

o??????? 對于bool，默認(rèn)值為false。

·???????? 對于enum-typeE，默認(rèn)值為0。

·???????? 對于struct-type，默認(rèn)值是通過將所有值類型字段設(shè)置為它們的默認(rèn)值、將所有引用類型字段設(shè)置為null而產(chǎn)生的值。

3.C#中有所謂的簡單類型概念（simple type），類似于java的基本類型，但又不同，C#的簡單類型本質(zhì)上都是結(jié)構(gòu)類型（預(yù)定義集合的結(jié)構(gòu)類型），所以還是值類型，從System.ValueType繼承而來。C#的簡單類型包括：

保留字	化名的類型
sbyte	System.SByte
byte	System.Byte
short	System.Int16
ushort	System.UInt16
int	System.Int32
uint	System.UInt32
long	System.Int64
ulong	System.UInt64
char	System.Char
float	System.Single
double	System.Double
bool	System.Boolean
decimal	System.Decimal

這些簡單類型都是System命名空間中預(yù)定義結(jié)構(gòu)類型的別名（ruby的別名實(shí)在貼心）

4.枚舉類型，枚舉類型是具有命名常量的獨(dú)特的類型。每個(gè)枚舉類型都有一個(gè)基礎(chǔ)類型，該基礎(chǔ)類型必須為 byte、sbyte、short、ushort、int、uint、long 或 ulong。如果沒有為枚舉類型中的元素指定基礎(chǔ)值，默認(rèn)是從0開始逐一遞增。

三。引用類型

1.引用類型是類類型、接口類型、數(shù)組類型或委托類型。

2.類類型：包括預(yù)定義的類類型和用戶通過class關(guān)鍵字的自定義類類型

3.對象類型：

object類類型是所有其他類型的最終基類。C# ?中的每種類型都是直接或間接從object類類型派生的。

關(guān)鍵字object只是預(yù)定義類System.Object的別名。

4.string類型:
string類型是直接從object繼承的密封類類型。關(guān)鍵字string只是預(yù)定義類System.String的別名.
5.接口類型：
與java中的接口概念基本一致，可以變相實(shí)現(xiàn)多重繼承。

類類型	說明
System.Object	所有其他類型的最終基類。
System.String	C# ?語言的字符串類型。
System.ValueType	所有值類型的基類。
System.Enum	所有枚舉類型的基類。
System.Array	所有數(shù)組類型的基類。
System.Delegate	所有委托類型的基類。
System.Exception	所有異常類型的基類。

四。裝箱、拆箱概念
1.裝箱和拆箱的概念是C# ?的類型系統(tǒng)的核心。它在 value-type 和 reference-type 之間的架起了一座橋梁，使得任何 value-type 的值都可以轉(zhuǎn)換為 object 類型的值，反過來轉(zhuǎn)換也可以。
2.裝箱：裝箱轉(zhuǎn)換允許將value-type隱式轉(zhuǎn)換為reference-type。
裝箱的行為可以用下面的過程描述：

sealed class T_Box: System.ValueType
{
T value;

public T_Box(T t) {
???? value = t;
}
}

分配一個(gè)對象實(shí)例，然后將value-type的值復(fù)制到該實(shí)例中
3.拆箱：拆箱轉(zhuǎn)換允許將reference-type顯式轉(zhuǎn)換為value-type。
從對象box到value-typeT的拆箱轉(zhuǎn)換相當(dāng)于執(zhí)行表達(dá)式((T_Box)box).value