线性结构
线性结构是数据结构里面最基础和最简单的数据类型，下面让我们看看线性表及其实现吧
线性表及其实现：
例1：一元多项式及其运算：
一元多项式：
他的主要运算为：多项式相加，相减，相乘等等。
那么作为数据计算，我们用C#语言怎么表示多项式？
首先分析多项式的关键数据：
①项数 n
②各项系数ai及指数i
由此便不难想到表示方式，这里笔者给出三种表示方法：
方法1：
顺序存储结构直接表示
数组各分量对应多项式的各项：a[i]表示项X^i的系数ai
因此，有关的操作也容易实现：两个多项式相加，两个数组对应分量相加
但是这方法也有缺点！！
当面对多项式 X+3X^2000的时候，要用到2001个分量的数组大小~~（注意！！不是2000个，数组索引从0开始）~~ ，而且很浪费1—2000之间的为零项的空间。
这种方法虽然方便，但是却把零项和非零项都表示进来了，有没有更好的改进方法呢？
那肯定是有的
方法2：
顺序存储结构表示非零项
上面提到了，对于每个非零项都只有系数ai和指数i，因此可以将一个多项式子看成是一个（ai，i）二元组的集合，既然谈到集合，不免让人联想到数组，那么用结构数组表示的话，数组分量是系数ai和指数i组成的结构，一个数组分量组对应一个非零项。
他们相加过程：
注意：这两个方法的要点在于按指数大小有序存储！！上篇数据基础学习篇已经说过了：顺序存储，利用数组实现，前两个方法都是使用数组。除此之外，还可以用链表来做
在这里提一下单向链表的结构
这里本文是把第一个数据作为头结点，有数据和指针的，因此当删除了第一个结点的时候，整个链表都会找不到，这点需要注意一下
方法3：
链表结构存储非零项
其中，因为C#是没有链表的，所以需要自己定义一个链表，定义结点，这里以单链表为例：
结点类：
public class Node<T>
{
private T value1;//存储数据1
public T Value1
{
get { return value1; }
set { value1 = value; }//**注意 value1 = Value1这样写是写不进值的**
}
private T value2;//存储数据2
public T Value2
{
get { return value2; }
set { value2 = value; }
}
private Node<T> next;//指针 用来指向下一个元素
public Node<T> Next
{
get { return next; }
set { next = value; }
}
public Node()//结构函数
{
value1 = default(T);
value2 = default(T);
next = null;
}
public Node(T Value1,T Value2,Node<T> Next)//结点定义
{
value1 = Value1;
value2 = Value2;
this.next = Next;
}
}
链表类：
class LinkList<T>
{
private Node<T> m_head;
public LinkList()
{
m_head = null;
}
public void Add(T m_value1,T m_value2)//增加链表数据
{
Node<T> dataNode = new Node<T>(m_value1, m_value2);
Node<T> newNode = new Node<T>();
if (m_head == null)
{
m_head = dataNode;
return;
}
newNode = m_head;
while (newNode.Next != null)
{
newNode = newNode.Next; //指向下一个结点
}
newNode.Next = dataNode;
}
public void Insert(T m_value1, T m_value2, int index)//插值
{
Node<T> current = m_head;
if (index == 0)
{
if (m_head.Next!=null)
{
Node<T> next = m_head.Next;
m_head.Next = current;
current.Next = next;
}
else
{
m_head.Next = current;
}
current.Value1 = m_value1;
current.Value2 = m_value2;
}
else
{
for (int i = 0; i < index; i++)
{
current = current.Next;
}
Node<T> dataValue = new Node<T>(m_value1, m_value2);
dataValue.Next = current.Next;
current.Next = dataValue;
}
}
public T[] Delete(int index)//做删除操作时，一般需要返回所删除结点的数据
{
T[] data = new T[2];
Node<T> current = m_head;
if (index == 0)
{
m_head.Value1 = data[0];
m_head.Value2 = data[1];
m_head = m_head.Next;
}
else
{
for (int i = 0; i < index-1; i++)
{
current = current.Next;
}
Node<T> preNode = current;
Node<T> currteNode = current.Next;
preNode.Next = currteNode.Next;
data[0]=currteNode.Value1;
data[1]=currteNode.Value2;
}
return data;
}
public int GetLength()//得到总长度
{
Node<T> current = m_head;
int count = 1;
if (m_head.Next == null)
{
return 0;
}
else
{
while (true)
{
if (current.Next !=null)
{
current = current.Next;
count++;
}
else
{
break;
}
}
return count;
}
}
public void Clear()
{
m_head = null;//头结点为空，整个链表找不到，编辑器会自动删除链表
}
public T[] GetValues(int Index)//根据索引查值
{
T[] data = new T[2];
Node<T> current = m_head;
if (Index == 0)
{
data[0] = m_head.Value1;
data[1] = m_head.Value2;
}
else
{
for (int i = 1; i <= Index; i++)
{
current = current.Next;
}
data[0] = current.Value1;
data[1] = current.Value2;
}
return data;
}
}
现在我们定义好了，让我们看看效果如何？
static void Main(string[] args)
{
LinkList<int> linklist = new LinkList<int>();
for (int i = 0; i < 10; i++)
{
linklist.Add(i, i + 1);
}
int[] data = new int[2];
for (int i = 0; i < 10; i++)
{
int j = 0;
data = linklist.GetValues(i);
Console.WriteLine("{0}个结点的值是{1}和{2}", i + 1, data[j], data[j + 1]);
}
var deletevalue = linklist.Delete(4);
var length = linklist.GetLength();
linklist.Insert(99, 100, 3);
Console.WriteLine("deletevalue = {0}和{1}，length = {2}", deletevalue[0],deletevalue[1], length);
Console.WriteLine("-------------------重新输出一遍-----------------------");
for (int i = 0; i < 10; i++)
{
int j = 0;
data = linklist.GetValues(i);
Console.WriteLine("{0}个结点的值是{1}和{2}", i + 1, data[j], data[j + 1]);
}
Console.WriteLine("-------------------进行清零操作-----------------------");
linklist.Clear();
Console.WriteLine("-------------------重新输出一遍-----------------------");**//下面会正常报错为逻辑正确**
for (int i = 0; i < 10; i++)
{
int j = 0;
data = linklist.GetValues(i);
Console.WriteLine("{0}个结点的值是{1}和{2}", i + 1, data[j], data[j + 1]);
}
Console.ReadKey();
}
在清零操作后重新输出程序会报错：
嗯，很好，达到目的了
这里附上一篇讲单向链表还不错的文章，这篇文章的头结点是只有指针的，可以看一下做一下对比。
https://blog.csdn.net/qq_36981814/article/details/80604607
注意：
1.单向链表在访问值时，只能从头结点访问下去，通过前一结点访问到下一个结点。
2.单向链表的添加可以是尾插方式，也可以是头插方式，如果采用头插方式，就相当于使用insert（0），创建出的是一个逆序表，先输入的在最后。
3.如果头结点被删除，整个链表会找不到，编辑器会自动将链表删除。
1603
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
