美文网首页
C#数据结构之单链表

C#数据结构之单链表

作者: 银河的精神家园 | 来源:发表于2018-05-18 11:12 被阅读0次

链表是用一组任意的存储单元来存储线性表中的数据元素(这组存储单元可以是连续的,也可以是不连续的)。
单链表节点定义
//定义线性表的行为,可供顺序表类和单链表类继承
public interface IListDS<T>
{
int GetLength();
void Insert(T item,int i);
void Add(T item);
bool IsEmpty();
T GetElement(int i);
void Delete(int i);
void Clear();
int LocateElement(T item);
void Reverse();
}
单链表操作实现


public class Node<T>
{
    private T data;//数据域
    private Node<T> next;//引用域

    //构造器:数据域和引用域,普通结点
    public Node(T val, Node<T> p)
    {
        data = val;
        next = p; 
    }
    //构造器:引用域,头结点
    public Node(Node<T> p)
    {
        next = p;
    }
    //构造器:数据域,尾结点
    public Node(T val)
    {
        data = val;
        next = null;
    }
    //构造器:无参数
    public Node()
    {
        data = default(T);
        next = null;
    }
    //数据域属性
    public T Data
    {
        get
        {
            return data;
        }
        set
        {
            data = value;
        }
    }
    //引用域属性
    public Node<T> Next
    {
        get
        {
            return next;
        }
        set
        {
            next = value;
        }
    }

}

//链表类,包含链表定义及基本操作方法
public class MyLinkList<T>
{
    private Node<T> head; //单链表的头结点
    
    //头结点属性
    public Node<T> Head
    {
        get { retrun head; }
        set { head = value; }
    }
    //构造器
    public MyLinkList()
    {
        head = null;
    }
    //求单链表的长度
    public int GetLength()
    {
        Node<T> p = head;
        int len = 0;
        while(p!=null)
        {
            ++len;
            p = p.Next;
        }
        return len;
    }
    //清空单链表
    public void Clear()
    {
        head = null;
    }
    //判断单链表是否为空
    public bool IsEmpty()
    {
        if (head == null) { return true; }
        else { return false; }
    }
    //在单链表的末尾添加新元素
    public void Append(T item)
    {
        Node<T> q = new Node<T>(item);
        Node<T> p = new Node<T>();
        if(head==null)
        {
            head = q;
            return;
        }
        p = head;
        while(p.Next!=null)
        {
            p = p.Next;
        }
        p.Next = q;
    }
    //在单链表的第i个结点的位置前插入一个值为item的结点  
    public void Insert(T item, int i)
    {
        if (IsEmpty() || i < 1 || i > GetLength())
        {
            Console.WriteLine("LinkList is empty or Position is error!");
            return;
        }
        if (i == 1)
        {
            Node<T> q = new Node<T>(item);
            q.Next = head;
            head = q;
            return;
        }
        Node<T> p = head;
        Node<T> r = new Node<T>();
        int j = 1;
        while (p.Next != null && j < i)
        {
            r = p;
            p = p.Next;
            ++j;
        }
        if (j == i)
        {
            Node<T> q = new Node<T>(item);
            q.Next = p;
            r.Next = q;
        }
    }
    //在单链表的第i个结点的位置后插入一个值为item的结点  
    public void InsertPost(T item, int i)
    {
        if (IsEmpty() || i < 1 || i > GetLength())
        {
            Console.WriteLine("LinkList is empty or Position is error!");
            return;
        }
        if (i == 1)
        {
            Node<T> q = new Node<T>(item);
            q.Next = head.Next;
            head.Next = q;
            return;
        }
        Node<T> p = head;
        int j = 1;
        while (p != null && j < i)
        {
            p = p.Next;
            ++j;
        }
        if (j == i)
        {
            Node<T> q = new Node<T>(item);
            q.Next = p.Next;
            p.Next = q;
        }
    }
    //删除单链表的第i个结点  
    public T Delete(int i)
    {
        if (IsEmpty() || i < 0 || i > GetLength())
        {
            Console.WriteLine("LinkList is empty or Position is error!");
            return default(T);
        }
        Node<T> q = new Node<T>();
        if (i == 1)
        {
            q = head;
            head = head.Next;
            return q.Data;
        }
        Node<T> p = head;
        int j = 1;
        while (p.Next != null && j < i)
        {
            ++j;
            q = p;
            p = p.Next;
        }
        if (j == i)
        {
            q.Next = p.Next;
            return p.Data;
        }
        else
        {
            Console.WriteLine("The " + i + "th node is not exist!");
            return default(T);
        }
    }
    //获得单链表的第i个数据元素  
    public T GetElem(int i)
    {
        if (IsEmpty() || i < 0)
        {
            Console.WriteLine("LinkList is empty or position is error! ");
            return default(T);
        }
        Node<T> p = new Node<T>();
        p = head;
        int j = 1;
        while (p.Next != null && j < i)
        {
            ++j;
            p = p.Next;
        }
        if (j == i)
        {
            return p.Data;
        }
        else
        {
            Console.WriteLine("The " + i + "th node is not exist!");
            return default(T);
        }
    }
    //在单链表中查找值为value的结点  
    public int Locate(T value)
    {
        if (IsEmpty())
        {
            Console.WriteLine("LinkList is Empty!");
            return -1;
        }
        Node<T> p = new Node<T>();
        p = head;
        int i = 1;
        while (!p.Data.Equals(value) && p.Next != null)
        {
            p = p.Next;
            ++i;
        }
        return i;
    }
    //显示链表  
    public void Display()
    {
        Node<T> p = new Node<T>();
        p = this.head;
        while (p != null)
        {
            Console.Write(p.Data + " ");
            p = p.Next;
        }
    }
}

public class Program
{
    static void Main(string[] args)
    {
        MyLinkList<string> myLinkList = new MyLinkList<string>(); //实例化一个单链表  
        Console.WriteLine(myLinkList.GetLength());   //获取长度  
                                                     //添加元素  
        myLinkList.Append("good");
        myLinkList.Append("monring");
        myLinkList.Append("lwk");
        myLinkList.Insert("!", 5);  //在i结点前插元素,位置错误测试  
        myLinkList.InsertPost("!", 5);  //在i结点后插元素,位置错误测试  
        myLinkList.InsertPost("!", 3);  //后插元素  
        myLinkList.Insert(",", 3);  //前插元素  
        myLinkList.Display();  //显示链表元素  
        Console.WriteLine(myLinkList.GetElem(4));//获取结点,并显示  
        myLinkList.Delete(1);  //删除结点  
        myLinkList.Display();
        Console.WriteLine(myLinkList.GetLength()); //显示链表长度  
        Console.Read();
    }
}

相关文章

  • 数据结构 | 其二 链表

    冰河winner - 数据结构之链表 2.1 单向链表 数据结构(一) 单链表的实现-JAVA 2.2 双端链表 ...

  • C#数据结构之单链表

    链表是用一组任意的存储单元来存储线性表中的数据元素(这组存储单元可以是连续的,也可以是不连续的)。单链表节点定义/...

  • 数据结构与算法之链表(三)单链表的常用操作

    引言 在上篇文章数据结构与算法之链表(二)单链表的基本实现中我们学习了单链表的基本概念,本篇我们在此基础之上研究单...

  • iOS 数据结构之链表

    iOS 数据结构之链表 iOS 数据结构之链表

  • 数据结构——Golang实现单链表

    转载请注明出处:数据结构——Golang实现单链表 1. 单链表 1.1. 定义 单向链表(单链表)是链表的一种,...

  • 算法与数据结构知识汇总(二、链表)

    1、概念 2、链表的数据结构 单向链表的数据结构如下图: 上图数据结构为单向链表,简称单链表,该数据结构由若干个节...

  • 数据结构--单链表

    数据结构--单链表 单链表:单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素。链表中...

  • 2018-12-01

    数据结构使用二级指针创建单链表以及单链表的各种操作 //单链表创建 #include #include #incl...

  • 数据结构笔记

    数据结构课程概览 ================== 1.顺序表 2.链表:单链表,单向循环链表,双链表...

  • 常见数据结构和算法

    常见数据结构 线性数据结构(按顺序具有数据元素的数据结构):数组,堆栈,链表(单链表 双链表),队列非线性数据结...

网友评论

      本文标题:C#数据结构之单链表

      本文链接:https://www.haomeiwen.com/subject/sgzwdftx.html