1.前言:
最近比较浮躁,想学习一门新的技术却总是浅尝辄止,遇到不懂的地方就想跳过去,时间长了,心态就有点崩了。静下心来,去喝了几碗心灵鸡汤。鸡汤博主感动到了我:"无专注，无风景。不要太贪心，一次只做一件事，而且只做最重要的事。".于是乎,我把家里翻了个底朝天,找到了我垫在床底下的《数据结构》这本书,觉得自己是时候静下心来好好复习一下基础了。今天刚看到顺序表和链表,把我的学习心得记录在这里。也希望自己能坚持,老老实实的把这本书复习完。
2.数据结构的重要性:
讲一门知识之前,通常流程都是要是先吹一波这个东西的重要性,数据结构和算法虽然已经被吹上天了,我还是觉得有必要:众所周知,数据结构是计算机专业中最重要的课程之一,可是为什么呢?用处太多难以列举,总结成一句话就是：可以让你的程序跑更快。今天主要一下顺序表和单链表的原理和实现
3.顺序表:
顺序表是最简单,最常用,最基本的数据结构
特点:1.结构中的元素存在1对1的线性关系，这种1对1的关系指的是数据元素之间的关系
2.位置有先后关系,除第一个位置的元素外,其他位置的元素前面都只有一个数据元素,相反除最后一个位置的数据元素外，其他位置的数据元素后面都只有一个元素。
CLR中的实现:List<T>
顺序表存储结构:
c#实现顺序表(代码中只实现了顺序表的基本功能,没有去做健壮性处理):
/// <summary>
/// 顺序表
/// </summary>
/// <typeparam name="T"></typeparam>
public class ListDS<T> : IListDS<T>
{
#region 初始化--2019年1月6日23:20:11
/// <summary>
///存储数据
/// </summary>
private T[] Data;
/// <summary>
/// 表示存储了多少数据
/// </summary>
private int Count;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="size">数据大小</param>
public ListDS(int size)
{
Data = new T[size];
Count = 0;
}
public ListDS() : this(10)
{
}
#endregion
#region 索引器--2019年1月6日23:20:06
/// <summary>
/// 索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T this[int index] => GetEle(index);
#endregion
#region 添加--2019年1月6日23:20:03
/// <summary>
/// 添加方法
/// </summary>
/// <param name="item">添加的元素</param>
public void Add(T item)
{
if (Count == Data.Length)
{
Console.WriteLine("当前顺序表已存满");
return;
}
Data[Count] = item;
Count++;
}
#endregion
#region 清空--2019年1月6日23:19:58
/// <summary>
/// 清空
/// </summary>
public void Clear()
{
Count = 0;
}
#endregion
#region 插入数据--2019年1月6日23:19:54
/// <summary>
/// 插入数据 数组向后移动
/// </summary>
/// <param name="item"></param>
/// <param name="index"></param>
public void Insert(T item, int index)
{
for (int i = Count - 1; i >= index; i--)
{
Data[i + 1] = Data[i];
}
Data[index] = item;
Count++;
}
#endregion
#region 删除--2019年1月6日23:19:51
/// <summary>
/// 删除 删除数据后 数组从后往前移动
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T Delete(int index)
{
T temp = Data[index];
for (int i =index+1 ; i < Count; i++)
{
Data[i - 1] = Data[i];
}
Count--;
return temp;
}
#endregion
#region 根据索引获取顺序表元素--2019年1月6日23:19:46
/// <summary>
/// 根据索引获取顺序表元素
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T GetEle(int index)
{
//判断元素是否存在
if (index >= 0 && index <= Count - 1)
{
return Data[index];
}
return default(T);
}
#endregion
#region 获取数组长度--2019年1月6日23:19:43
/// <summary>
/// 获取数组长度
/// </summary>
/// <returns></returns>
public int GetLength()
{
return Count;
}
#endregion
#region 是否为空--2019年1月6日23:19:40
/// <summary>
/// 是否为空
/// </summary>
/// <returns></returns>
public bool IsEmpty()
{
return Count == 0;
}
#endregion
#region 根据元素获取索引--2019年1月6日23:19:36
/// <summary>
/// 根据元素获取索引
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int Locate(T value)
{
for (int i = 0; i < Count-1; i++)
{
if (Data[i].Equals(value))
{
return i;
}
}
return -1;
}
#endregion
}
4.链表
顺序表使用地址连续的存储单元顺序存储线性表中的各个数据元素,逻辑上想来的数据元素在物理位置上也相邻,因此,在顺序表中查找任何一个位置上的数据元素非常方便,这是顺序表的有点,BUT，顺序表插入/删除时,需要通过移动数据元素,影响了运行效率,线性表的另外一种存储结构--链式存储（Linkend Storage）这样的线性表叫链表。因此，对链表进行插入和删除时,不需要移动数据元素,但同时也失去了顺序表可随机存储的优点
CLR中的实现:LinkedList<T>
链式存储结构:
c#实现单链表节点:
/// <summary>
/// 单链表节点
/// </summary>
class Node<T>
{
#region 初始化
public T data;//存储数据
public Node<T> next;//指针 指向下一个元素
public Node(T _data)
{
this.data = _data;
next = null;
}
public Node(T _data,Node<T> _node)
{
this.data = _data;
next = _node;
}
public Node()
{
this.data = default(T);
this.next = null;
}
public T Data
{
get { return data; }
set { data = value; }
}
public Node<T> Next
{
get { return next; }
set { next = value; }
}
#endregion
}
c#实现单链表:
/// <summary>
/// 单链表
/// </summary>
/// <typeparam name="T"></typeparam>
public class LinkList<T> : IListDS<T>
{
#region 初始化
/// <summary>
/// 头节点
/// </summary>
private Node<T> _head;
public LinkList()
{
_head = null;
}
#endregion
#region 索引器
/// <summary>
/// 索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T this[int index] => GetEle(index);
#endregion
#region 添加
/// <summary>
/// 添加
/// </summary>
/// <param name="item"></param>
public void Add(T item)
{
//1. 创建一个新节点
//2. 如果头节点为空,赋值给头节点 return
//3.1 如果头节点不为空
//3.2 创建一个节点指向头节点
//3.3 循环找到尾节点
//3.4 新节点放在尾部
Node<T> newNode = new Node<T>(item);
if (_head == null)
{
_head = newNode;
return;
}
Node<T> temp = _head;
while (true)
{
if (temp.Next != null)
{
temp = temp.Next;
}
else
{
break;
}
}
temp.Next = newNode;
}
#endregion
#region 清空
/// <summary>
/// 清空
/// </summary>
public void Clear()
{
//清空头节点,垃圾回收器自动回收所有未引用的对象
_head = null;
}
#endregion
#region 删除
/// <summary>
/// 删除
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T Delete(int index)
{
//1.如果是头节点,讲指针指向下一个元素
//2.如果不是头节点,找到要删除节点的前一个节点和要删除的节点
//3.将引用指向要删除的节点的后一个节点
T data = default(T);
//删除头节点
if (index == 0)
{
data = _head.Data;
_head = _head.Next;
return data;
}
Node<T> temp =_head;
for (int i = 1; i < index - 1; i++)
{
temp = temp.Next;
}
Node<T> preNode = temp;//要删除的节点的前一个节点
Node<T> currentNode = temp.Next;//要删除的节点
data = currentNode.Data;
Node<T> nextNode = temp.Next.Next;
preNode.Next = nextNode;
return data;
}
#endregion
#region 根据索引访问
/// <summary>
/// 根据索引访问
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T GetEle(int index)
{
Node<T> temp = _head;
for (int i = 1; i <=index; i++)
{
temp = temp.Next;
}
return temp.Data;
}
#endregion
#region 获取长度
/// <summary>
/// 获取长度
/// </summary>
/// <returns></returns>
public int GetLength()
{
if (_head == null)
{
return 0;
}
int count = 1;
Node<T> temp = _head;
while (true)
{
if (temp.Next != null)
{
count++;
temp = temp.Next;
}
else
{
break;
}
}
return count;
}
#endregion
#region 插入
/// <summary>
/// 插入
/// </summary>
/// <param name="item">数据</param>
/// <param name="index">位置</param>
public void Insert(T item, int index)
{
//1. 创建一个新节点
//2. 如果索引为0(头节点) 赋值给头节点 return
//3.1 如果不是头节点,找到要插入的节点的前一个节点和要插入的节点
//3.2 前一个节点指向新节点
//3.3 新节点指向前一个节点
Node<T> newNode = new Node<T>(item);
if (index== 0)
{
newNode.Next = _head;
_head = newNode;
return;
}
Node<T> temp = new Node<T>();
for (int i = 1; i < index-1; i++)
{
temp = temp.Next;
}
Node<T> preNode = temp;//要插入的节点的前一个节点
Node<T> curentNode = temp.Next;//要插入的节点
preNode.next = newNode;
newNode.Next = curentNode;
}
#endregion
#region 清空
/// <summary>
/// 清空
/// </summary>
/// <returns></returns>
public bool IsEmpty()
{
return _head == null;
}
#endregion
#region 根据数据访问索引
/// <summary>
/// 根据数据访问索引
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int Locate(T value)
{
Node<T> temp = _head;
if (temp.Data == null)
{
return -1;
}
int index = 0;
while (true)
{
if (temp.Data.Equals(value))
{
return index;
}
else
{
if (temp.Next != null)
{
temp = temp.Next;
}
else
{
break;
}
}
}
return -1;
}
#endregion
}
原文地址：https://www.cnblogs.com/quebra/p/10231046.html
时间： 2024-11-18 01:34:43