From 42f24a75b4c6bbe95c149be2b1c7f88ed44c0940 Mon Sep 17 00:00:00 2001
From: MYP <yanpengma@163.com>
Date: Mon, 19 Oct 2020 18:41:09 +0800
Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E8=AF=BE=E7=A8=8B=E5=86=85?=
 =?UTF-8?q?=E5=AE=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../12 数组与稀疏矩阵.md                      | 710 ++++++++++++++++++
 .../{12 字符串.md => 13 字符串.md}            |   0
 2 files changed, 710 insertions(+)
 create mode 100644 DataStructureAndAlgorithm/12 数组与稀疏矩阵.md
 rename DataStructureAndAlgorithm/{12 字符串.md => 13 字符串.md} (100%)

diff --git a/DataStructureAndAlgorithm/12 数组与稀疏矩阵.md b/DataStructureAndAlgorithm/12 数组与稀疏矩阵.md
new file mode 100644
index 0000000..43093c7
--- /dev/null
+++ b/DataStructureAndAlgorithm/12 数组与稀疏矩阵.md	
@@ -0,0 +1,710 @@
+# 12 ������ϡ�����
+
+**֪ʶ�ṹ��**
+
+![ͼ1 ֪ʶ�ṹ](https://img-blog.csdnimg.cn/20201019145851727.png)
+
+## 1. ����
+
+### 1.1 ����Ķ���
+
+�����Ǿ���һ��˳���ϵ�����ɶ�����ɵļ��ϣ��������Ķ����Ϊ����Ԫ�ء�
+
+���磺
+- ������Ӧһά����
+
+```math
+A=(a_0,a_1,\cdots,a_{n-1})
+```
+
+- �����Ӧ��ά����
+
+```math
+A_{m \times n} =\begin{bmatrix}
+a_{00}&a_{01} &\cdots &a_{0n-1}\\
+a_{10}&a_{11} &\cdots &a_{1n-1}\\
+\cdots& \cdots &\cdots &\cdots\\
+a_{m-10}&a_{m-11}& \cdots &a_{m-1n-1}\\
+\end{bmatrix}
+```
+
+
+��������ʾȺ��Ĺ��ԣ�������ͬһ���������ͣ�
+
+�±��ʾ����ĸ��ԣ�������ռ�ж����ĵ�Ԫ��
+
+
+### 1.2 ����Ĵ洢
+
+**��1��`$n$`ά����Ķ���**
+
+�±���`$n$`������ɵ������Ϊ`$n$`ά���顣
+
+���磺
+```c
+//һά���飨�ߣ�
+int[] a = new int[10]; 
+
+//��ά���� ���棩
+int[ , ] a = new int[2,3];
+
+//��ά���� ���壩����ȣ��飨�壩��2.ҳ�� 3.�� 4.�С� 
+int[ , , ] a = new int[2,3,4];
+```
+
+**��2������洢���ص�**
+- ����Ԫ�����ڴ��а�˳�������洢��
+- ����Ĵ洢���䰴���У�C��C++��C#�ȣ����У�Forturn�ȣ����С�
+- ��������ʾ��������׵�ַ���dz�����
+
+**��3����������Ĵ洢**
+
+<u>һά����`a[n]`</u>
+
+��Ԫ�ذ��½DZ����δ�š�
+
+����`int[] a = new int[5];`
+
+![ͼ2 һά����洢](https://img-blog.csdnimg.cn/20191218195949938.png)
+
+<u>������`a[m,n]`</u>
+
+����`int[ , ] a = new int[2,3];`
+
+![ͼ3 ��ά����洢](https://img-blog.csdnimg.cn/20191218200106993.png)
+
+
+<u>������`a[m,n,l]`</u>
+
+��һά�±�仯����������ά�����һά���±�仯��졣
+
+����`int[ , , ] a = new int[2,3,4];`
+
+![ͼ4 ��ά����Ĵ洢](https://img-blog.csdnimg.cn/20191218200209131.png)
+
+**ע�⣺**
+
+C#��`int[,]`��`int[][]`�������������
+
+- `int[,]` ����������ȷ��
+
+
+```c
+static void Main(string[] args)
+{
+
+    int[,] Arr = new int[2, 5] { { 1, 2, 3, 5, 6 }, { 1, 2, 3, 4, 5 } };
+            
+    for (int i = 0; i < 2; ++i)
+    {
+        for (int j = 0; j < 5; ++j)
+        {
+            Console.Write(Convert.ToString(Arr[i, j]) + " ");
+        }
+        Console.WriteLine();
+    }
+    // 1 2 3 5 6
+    // 1 2 3 4 5
+}
+```
+
+- `int[][]` ����ȷ������������
+
+```c
+static void Main(string[] args)
+{
+
+    int[][] Arr = new int[3][];  //��ʾ��������һά���������
+    Arr[0] = new int[5] { 1, 2, 3, 4, 5 };
+    Arr[1] = new int[2] { 0, 1 };
+    Arr[2] = new int[0] { };
+
+    for (int i = 0; i < Arr.Length; ++i)
+    {
+        foreach (int j in Arr[i])
+        {
+            Console.Write(j + " ");
+        }
+        Console.WriteLine();
+    }
+    // 1 2 3 4 5
+    // 0 1
+    // 
+}
+```
+
+### 1.3 ����ķ���
+
+����ɷ�Ϊ��̬����Ͷ�̬�������ࡣ
+
+**��1����̬����**
+
+�ڳ������ʱ����ռ�����顣
+
+����
+```
+//��̬���飨����֮�����鳤�Ȳ��ɸı䣩
+int[] a = new int[10];
+```
+
+**��2����̬����**
+
+�ڳ�������ʱ����ռ�����飨����֮�����鳤�ȿɸ����������������
+
+![ͼ5 ��̬������ͼ](https://img-blog.csdnimg.cn/20201019105328214.png)
+
+
+```c
+using System;
+
+namespace LinearStruct
+{
+    /// <summary>
+    /// ��̬����ij�����������ʵ��
+    /// </summary>
+    /// <typeparam name="T">��̬������Ԫ�ص�����</typeparam>
+    public class DArray<T> where T : IComparable<T>
+    {
+        private T[] _array;
+
+        /// <summary>
+        /// ��ȡ��̬����ĵ�ǰ����
+        /// </summary>
+        public int Size { get; private set; }
+
+        /// <summary>
+        /// ��ʼ��DArray�����ʵ��
+        /// </summary>
+        /// <param name="size">��̬����ij�ʼ����</param>
+        public DArray(int size)
+        {
+            if (size <= 0)
+                throw new ArgumentOutOfRangeException();
+
+            Size = size;
+            _array = new T[Size];
+        }
+
+        /// <summary>
+        /// �ı䶯̬����ij���
+        /// </summary>
+        /// <param name="newSize">��̬������³���</param>
+        public void ReSize(int newSize)
+        {
+            if (newSize <= 0)
+                throw new ArgumentOutOfRangeException();
+
+            if (Size != newSize)
+            {
+                T[] newArray = new T[newSize];
+                int n = newSize < Size ? newSize : Size;
+                for (int i = 0; i < n; i++)
+                {
+                    newArray[i] = _array[i];
+                }
+                _array = newArray;
+                Size = newSize;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ������ָ����������Ԫ��
+        /// </summary>
+        /// <param name="index">Ҫ��û����õ�Ԫ�ش��㿪ʼ������</param>
+        /// <returns>ָ����������Ԫ��</returns>
+        public T this[int index]
+        {
+            get
+            {
+                if (index < 0 || index > Size - 1)
+                    throw new IndexOutOfRangeException();
+                return _array[index];
+            }
+            set
+            {
+                if (index < 0 || index > Size - 1)
+                    throw new IndexOutOfRangeException();
+                _array[index] = value;
+            }
+        }
+    }
+}
+```
+
+### 1.4 ��̬�����Ӧ��
+
+��дһ�δ��룬Ҫ������һ������`N`���ö�̬����`A`�����`2~N`֮������5��7�ı�������������顣
+
+���磺`N=100`
+
+�������5 7 10 14 15 20 21 25 28 30 35 40 42 45 49 50 55 56 60 63 65 70 75 77 80 84 85 90 91 95 98 100
+
+�ο��������£�
+
+![ͼ6 ��̬����ʵ�����](https://img-blog.csdnimg.cn/20201019105841792.png#pic_center)
+
+```c
+static void Main(string[] args)
+{
+    Console.WriteLine("N=");
+    string s = Console.ReadLine();
+    int n;
+    if (int.TryParse(s, out n))
+    {
+        DArray<int> arr = new DArray<int>(10);
+        int j = 0;
+        for (int i = 2; i <= n; i++)
+        {
+            if (i % 5 == 0 || i % 7 == 0)
+            {
+                if (j == arr.Size)
+                    arr.ReSize(arr.Size + 10);
+
+                arr[j] = i;
+                j++;
+            }
+        }
+        for (int i = 0; i < j; i++)
+        {
+            Console.Write(arr[i] + " ");
+        }
+    }
+}
+```
+
+---
+## 2. ϡ�����
+
+
+### 2.1 ϡ�����Ķ��������
+
+**��1��ϡ�����Ķ���**
+
+������`$A$`�з���Ԫ�صĸ���ԶԶС����Ԫ�صĸ��������`$A$`Ϊϡ�����
+
+����
+
+```math
+A = \begin {bmatrix}
+50 & 0 & 0 & 0\\
+10 & 0 & 20 & 0\\
+0 & 0 & 0 & 0\\
+-30 & 0 & -60 & 5
+\end{bmatrix}
+```
+
+���ö�ά����洢����̫�˷Ѵ洢�ռ䡣
+
+
+**��2��ϡ�����IJ���**
+
+- ��ȡ���������
+- ��ȡ���������
+- ��ȡ������ָ����������Ԫ��
+- ����ӷ�
+- ����ת��
+- ����˷�
+
+
+
+
+![ͼ7 ����ӿ�](https://img-blog.csdnimg.cn/20201019111305663.png)
+
+```c
+namespace LinearStruct
+{
+    /// <summary>
+    /// ����ij�����������
+    /// </summary>
+    public interface IMatrix<T>
+    {
+        /// <summary>
+        /// ��ȡ���������
+        /// </summary>
+        int Rows { get; }
+
+        /// <summary>
+        /// ��ȡ���������
+        /// </summary>
+        int Cols { get; }
+
+        /// <summary>
+        /// ��ȡ������ָ����������Ԫ��
+        /// </summary>
+        /// <param name="i">Ҫ��ȡ�����õ�Ԫ�ش��㿪ʼ��������</param>
+        /// <param name="j">Ҫ��ȡ�����õ�Ԫ�ش��㿪ʼ��������</param>
+        /// <returns></returns>
+        T this[int i, int j] { get; set; }
+
+        /// <summary>
+        /// ����ӷ�
+        /// </summary>
+        /// <param name="b">��֮��ӵ���һ������</param>
+        /// <returns>��Ӻ���¾���</returns>
+        IMatrix<T> Add(IMatrix<T> b);
+        
+        /// <summary>
+        /// ����ת��
+        /// </summary>
+        /// <returns>ת�ú���¾���</returns>
+        IMatrix<T> Transpose();
+        
+        /// <summary>
+        /// ����˷�
+        /// </summary>
+        /// <param name="b">��֮�ҳ˵���һ������</param>
+        /// <returns>��˺���¾���</returns>
+        IMatrix<T> Multiply(IMatrix<T> b);
+    }
+}
+```
+
+### 2.2 ϡ�����Ĵ洢��ʵ��
+
+��������`��Row��Col��Value��`�ķ�ʽ�洢�Ͷ�λϡ������еķ���Ԫ�أ����ִ洢ϡ�������ķ�ʽ��Ϊ��Ԫ�飨Triple����
+
+
+![ͼ8 ϡ�������Ĵ洢](https://img-blog.csdnimg.cn/20201019111609268.png)
+
+����˳��ķ�ʽ���д洢��
+
+![ͼ9 ˳��ʽ�洢ϡ�����](https://img-blog.csdnimg.cn/20201019111704277.png)
+
+������ʽ�ķ�ʽ���д洢��
+
+![ͼ10 ��ʽ��ʽ�洢ϡ�����](https://img-blog.csdnimg.cn/20201019111738648.png)
+
+**��1���Խ��ķ�װ**
+
+![ͼ11 ϡ���������ͼ](https://img-blog.csdnimg.cn/20201019143656996.png)
+
+```c
+using System;
+
+namespace LinearStruct
+{
+    /// <summary>
+    /// ϡ�������
+    /// </summary>
+    public class Triple : IComparable<Triple>
+    {
+        /// <summary>
+        /// ��ȡ������ھ����е�������
+        /// </summary>
+        public int Row { get; }
+
+        /// <summary>
+        /// ��ȡ������ھ����е�������
+        /// </summary>
+        public int Col { get; }
+
+        /// <summary>
+        /// ��ȡ�����ý���ھ����е�ֵ
+        /// </summary>
+        public double Value { get; set; }
+
+        /// <summary>
+        /// ��ʼ��Triple�����ʵ��
+        /// </summary>
+        /// <param name="i">������ھ����е�������</param>
+        /// <param name="j">������ھ����е�������</param>
+        /// <param name="value">����ھ����е�ֵ</param>
+        public Triple(int i, int j, double value)
+        {
+            if (i < 0 || j < 0)
+                throw new Exception("����Ԫ��λ����Ч.");
+
+            Row = i;
+            Col = j;
+            Value = value;
+        }
+        
+        /// <summary>
+        /// Triple�������ַ���
+        /// </summary>
+        /// <returns>Triple�������ַ���</returns>
+        public override string ToString()
+        {
+            return string.Format("({0},{1},{2})", Row, Col, Value);
+        }
+        
+        /// <summary>
+        /// �Ƚ���Ԫ�������ݵĴ�С
+        /// </summary>
+        /// <param name="other">���Ƚϵ���Ԫ��</param>
+        /// <returns></returns>
+        public int CompareTo(Triple other)
+        {
+            if (Value < other.Value) return -1;
+            if (Value > other.Value) return 1;
+            return 0;
+        }
+    }
+}
+```
+
+
+**��2����ϡ�����ķ�װ**
+
+![ͼ12 ϡ�������ͼ](https://img-blog.csdnimg.cn/20201019114927840.png)
+
+
+```c
+using System;
+
+namespace LinearStruct
+{
+    /// <summary>
+    /// ��������������͵�ʵ��--ϡ�����
+    /// </summary>
+    public class SparseMatrix : IMatrix<double>
+    {
+        private readonly DLinkList<Triple> _lst;
+
+        /// <summary>
+        /// ��ȡϡ����������
+        /// </summary>
+        public int Rows { get; }
+
+        /// <summary>
+        /// ��ȡϡ����������
+        /// </summary>
+        public int Cols { get; }
+
+        /// <summary>
+        /// ��ʼ��SparseMatrix�����ʵ��
+        /// </summary>
+        /// <param name="rows">ϡ����������</param>
+        /// <param name="cols">ϡ����������</param>
+        public SparseMatrix(int rows, int cols)
+        {
+            if (rows <= 0 || cols <= 0)
+                throw new ArgumentOutOfRangeException();
+            Rows = rows;
+            Cols = cols;
+            _lst = new DLinkList<Triple>();
+        }
+
+        private DNode<Triple> GetIndex(int i, int j)
+        {
+            DNode<Triple> temp = _lst.PHead;
+            while (temp != null)
+            {
+                if (temp.Data.Row == i && temp.Data.Col == j)
+                    break;
+                temp = temp.Next;
+            }
+            return temp;
+        }
+
+        private void RemoveNode(DNode<Triple> node)
+        {
+            if (node.Next == null)
+            {
+                _lst.Remove(_lst.Length - 1);
+            }
+            else if (node.Prior == null)
+            {
+                _lst.Remove(0);
+            }
+            else
+            {
+                node.Prior.Next = node.Next;
+                node.Next.Prior = node.Prior;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ������ָ����������Ԫ��
+        /// </summary>
+        /// <param name="i">Ҫ��ȡ�����õ�Ԫ�ش��㿪ʼ��������</param>
+        /// <param name="j">Ҫ��ȡ�����õ�Ԫ�ش��㿪ʼ��������</param>
+        /// <returns></returns>
+        public double this[int i, int j]
+        {
+            get
+            {
+                if (i < 0 || i > Rows - 1 || j < 0 || j > Cols - 1)
+                    throw new IndexOutOfRangeException();
+                DNode<Triple> node = GetIndex(i, j);
+
+                return node == null ? 0.0 : node.Data.Value;
+            }
+            set
+            {
+                if (i < 0 || i > Rows - 1 || j < 0 || j > Cols - 1)
+                    throw new IndexOutOfRangeException();
+
+                DNode<Triple> node = GetIndex(i, j);
+
+                if (node == null)
+                {
+                    if (value != 0.0)
+                    {
+                        _lst.InsertAtRear(new Triple(i, j, value));
+                    }
+                }
+                else
+                {
+                    if (value != 0.0)
+                    {
+                        node.Data.Value = value;
+                    }
+                    else
+                    {
+                        RemoveNode(node);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// ����ӷ�
+        /// </summary>
+        /// <param name="b">��֮��ӵ���һ������</param>
+        /// <returns>��Ӻ���¾���</returns>
+        public SparseMatrix Add(SparseMatrix b)
+        {
+            if (b == null)
+                throw new ArgumentNullException();
+            if (b.Rows != Rows || b.Cols != Cols)
+                throw new Exception("�����������.");
+
+            SparseMatrix temp = new SparseMatrix(Rows, Cols);
+            for (int i = 0; i < Rows; i++)
+                for (int j = 0; j < Cols; j++)
+                    temp[i, j] = this[i, j] + b[i, j];
+            return temp;
+        }
+
+        /// <summary>
+        /// ����ת��
+        /// </summary>
+        /// <returns>ת�ú���¾���</returns>
+        public SparseMatrix Transpose()
+        {
+            SparseMatrix temp = new SparseMatrix(Cols, Rows);
+            for (int i = 0; i < temp.Rows; i++)
+                for (int j = 0; j < temp.Cols; j++)
+                    temp[i, j] = this[j, i];
+            return temp;
+        }
+
+        /// <summary>
+        /// ����˷�
+        /// </summary>
+        /// <param name="b">��֮�ҳ˵���һ������</param>
+        /// <returns>��˺���¾���</returns>
+        public SparseMatrix Multiply(SparseMatrix b)
+        {
+            if (b == null)
+                throw new ArgumentNullException();
+            if (Cols != b.Rows)
+                throw new Exception("�����������.");
+
+            SparseMatrix temp = new SparseMatrix(Rows, b.Cols);
+            for (int i = 0; i < Rows; i++)
+            {
+                for (int j = 0; j < b.Cols; j++)
+                {
+                    double value = 0.0;
+                    for (int k = 0; k < Cols; k++)
+                        value += this[i, k] * b[k, j];
+
+                    temp[i, j] = value;
+                }
+            }
+            return temp;
+        }
+
+        /// <summary>
+        /// ����ӷ�����
+        /// </summary>
+        /// <param name="a">��һ������</param>
+        /// <param name="b">�ڶ�������</param>
+        /// <returns>��Ӻ���¾���</returns>
+        public static SparseMatrix operator +(SparseMatrix a, SparseMatrix b)
+        {
+            if (a == null || b == null)
+                throw new ArgumentNullException();
+            return a.Add(b);
+        }
+
+        /// <summary>
+        /// ����˷�����
+        /// </summary>
+        /// <param name="a">��ߵľ���</param>
+        /// <param name="b">�ұߵľ���</param>
+        /// <returns>��˺���¾���</returns>
+        public static SparseMatrix operator *(SparseMatrix a, SparseMatrix b)
+        {
+            if (a == null || b == null)
+                throw new ArgumentNullException();
+
+            return a.Multiply(b);
+        }
+
+        /// <summary>
+        /// SparseMatrix�������ַ���
+        /// </summary>
+        /// <returns>SparseMatrix�������ַ���</returns>
+        public override string ToString()
+        {
+            string str = string.Empty;
+            DNode<Triple> temp = _lst.PHead;
+            while (temp != null)
+            {
+                str += temp.Data + "\n";
+                temp = temp.Next;
+            }
+            return str;
+        }
+
+        IMatrix<double> IMatrix<double>.Add(IMatrix<double> b)
+        {
+            return Add((SparseMatrix)b);
+        }
+
+        IMatrix<double> IMatrix<double>.Transpose()
+        {
+            return Transpose();
+        }
+
+        IMatrix<double> IMatrix<double>.Multiply(IMatrix<double> b)
+        {
+            return Multiply((SparseMatrix)b);
+        }
+    }
+}
+```
+
+������
+```c
+static void Main(string[] args)
+{
+    IMatrix<double> a = new SparseMatrix(2, 3);
+    IMatrix<double> b = new SparseMatrix(3, 2);
+    SparseMatrix c = new SparseMatrix(2, 2);
+    a[0, 2] = 1;
+    a[1, 0] = 1;
+    b[1, 1] = 4;
+    b[2, 0] = 1;
+    c[0, 1] = 1;
+    c[1, 0] = 1;
+    SparseMatrix d = (SparseMatrix)a * (SparseMatrix)b + c;
+    IMatrix<double> e = a.Multiply(b).Add(c);
+    Console.WriteLine("D:\n{0}", d);
+    Console.WriteLine("E:\n{0}", e);
+    
+    // D:
+    // (0, 0, 1)
+    // (0, 1, 1)
+    // (1, 0, 1)
+    // E:
+    // (0, 0, 1)
+    // (0, 1, 1)
+    // (1, 0, 1)
+}
+```
+
+
diff --git a/DataStructureAndAlgorithm/12 字符串.md b/DataStructureAndAlgorithm/13 字符串.md
similarity index 100%
rename from DataStructureAndAlgorithm/12 字符串.md
rename to DataStructureAndAlgorithm/13 字符串.md