常見的4類數據結構： 1.集合。 2.線性結構。3.樹形結構。4.圖狀結構。

數據結構(Data Structure)簡記為 DS，是一個二元組，DS = (D,R)

其中：D 是數據元素的有限集合，R 是數據元素之間關系的有限集合。

數據的存儲結構包括順序存儲結構和鏈式存儲結構兩種。C#語言中用數組來實現順序存儲結構。

算法的5個重要特征： 1.有窮性。2.確定性。3.可行性。4.輸入。5.輸出。

線性表：存在一對一的線性關系，一對一的關系指的是數據元素之間的位置關系

特點：（1）除第一個位置的數據 元素外，其它數據元素位置的前面都只有一個數據元素

　　　（2）除最後一個位置的 數據元素外，其它數據元素位置的後面都只有一個元素

線性表(List)是由 n(n≥0)個相同類型的數據元素構成的有限序列。線性表通常記為：L=(a1,a2,…,ai-1,ai, ai+1,…,an)，a1是線性 表中第一個位置的數據元素。an是線性表中最後一個位置 的數據元素，。n為線性表的表長，n=0 時的線性表被稱 為空表（Empty List）。

線性表的接口如下所示。

public interface IListDS<T> 
{
    int GetLength();    //求長度
    void Clear();    //清空操作
    bool IsEmpty();    //
 
判斷線性表是否為空
    void Append(T item);    //附加操作 
    void Insert(T item, int i);    //插入操作 
    T Delete(int i);    //刪除操作 
    T GetElem(int i);    //取表元 
    int Locate(T value);    //按值查找
}

線性表的順序存儲是指在內存中用一塊地址連續的空間依次存放線性表的數據元素， 用這種方式存儲的線性表叫順序表(Sequence List)。順序表的特點 是表中相鄰的數據元素在內存中存儲位置也相鄰。數據元素占w個存儲單元，設第i個數據元素的存儲地址為Loc(ai)，則有：Loc(ai)= Loc(a1)+(i-1)*w 1≤i≤n。

由於計算順序表中每個數據元素存儲地址的時間相同，所以順序表 具有隨機存取的特點。數組具有表示順序表的數據存儲區域的特 性。

last 表示順序 表中最後一個數據元素在數組中的位置。如果順序表中有數據元素時，last 的變 化範圍是 0 到 maxsize-1，如果順序表為空，last=-1

順序表類 SeqList<T>的實現說明如下所示。

public class SeqList<T> : IListDS<T>
{
    private int maxsize;    //順序表的容量
    private T[] data;    //數組，用於存儲順序表中的數據元素
    private int last;    //指示順序表最後一個元素的位置
    //索引器
    public T this[int index]
    {
        get { return data[index]; }
        set { data[index] = value; }
    }
    //最後一個數據元素位置屬性
    public int Last
    {
        get { return last; }
    }
    //容量屬性
    public int Maxsize
    {
        get { return maxsize; }
        set { maxsize = value; }
    }
    //構造器
    public SeqList(int size)
    {
        data = new T[size];
        maxsize = size;
        last = -1;
    }
    //求順序表的長度
    public int GetLength()
    {
        return last + 1;
    }
    //清空順序表
    public void Clear()
    {
        last = -1;
    }
    //判斷順序表是否為空
    public bool IsEmpty()
    {
        if (last == -1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //判斷順序表是否為滿
    public bool IsFull()
    {
        if (last == maxsize - 1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //在順序表的末尾添加新元素
    public void Append(T item)
    {
        if (IsFull())
        {
            System.Console.WriteLine("滿了");
            return;
        }
        data[++last] = item;
    }
    //在順序表的第i位置插入一個數據元素
    public void Insert(T item, int i)
    {
        if (IsFull())
        {
            System.Console.WriteLine("滿了");
            return;
        }
        if (i < 1 || i> last+2)
        {
            System.Console.WriteLine("越界");
            return;
        }
        if(i==last+2)
        {
            data[last+1]=item;
        }
        else
        {
            for (int j = last; j >= i - 1; --j)
            {
                data[j + 1] = data[j];
            }
            data[i - 1] = item;
        }
        ++last;
    }
    //刪除順序表的第i個數據元素
    public T Delete(int i)
    {
        T tmp = default(T);
        if (IsEmpty())
        {
            Console.WriteLine("List is empty");
            return tmp;
        }
        if (i < 1 || i > last + 1)
        {
            Console.WriteLine("Position is error!");
            return tmp;
        }
        if (i == last + 1)
        {
            tmp = data[last--];
        }
        else
        {
            tmp = data[i - 1];
            for (int j = i; j <= last; ++j)
            {
                data[j] = data[j + 1];
            }
        }
        --last;
        return tmp;
    }
    //獲得順序表的第i個數據元素
    public T GetElem(int i)
    {
        if (IsEmpty() || (i < 1) || (i > last + 1))
        {
            Console.WriteLine("List is empty or Position is error!");
            return default(T);
        }
        return data[i - 1];
    }
    //在順序表中查找值為value的數據元素
    public int Locate(T value)
    {
        if (IsEmpty())
        {
            Console.WriteLine("List is Empty!");
            return -1;
        }
        int i = 0;
        for (i = 0; i <= last; ++i)
        {
            if (value.Equals(data[i]))
            {
                break;
            }
        }
        if (i > last)
        {
            return -1;
        }
        return i;
    }
}
 

順序表的倒置 算法思路：把第一個元素與最後一個元素交換，把第二個元素與倒數第二個元素交換。一般地，把第 i 個元素與第 n-i 個元素交換，i 的取值範圍是 0 到 n/2（n 為順序表的長度）。算法實現如下：

public void ReversSeqList(SeqList<int> L)
{
    int tmp = 0;
    int len = L.GetLength();
    for (int i = 0; i<= len/2; ++i)
    {
        tmp = L[i];
        L[i] = L[len - i]; 
　　　　 L[len - i] = tmp;
    }
}
        

C#數據結構_01