C# 数据结构--单链表

什么是单链表

　　这两天看到很多有关单链表的面试题，对单链表都不知道是啥的我。经过学习和整理来分享一下啥是单链表和单链表的一些基本使用方法。最后看些网上有关单链表的面试题代码实例。

啥是单链表?

　　单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。这组存储单元既可以是连续的，也可以是不连续的。

　　链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

　　链表的结点结构：

┌───┬───┐

│data│next│

└───┴───┘

　　data域--存放结点值的数据域[元素]

　　next域--存放结点的直接后继的地址（位置）的指针域（链域）[指针]

　　用张图来说明一下上面的定义：

在VS中看到单链表的结构如下图：

实例代码

单键表结点类-泛型

public class Node<T>
{
    public T Data { set; get; }          //数据域,当前结点数据
    public Node<T> Next { set; get; }    //位置域,下一个结点地址

    public Node(T item)
    {
        this.Data = item;
        this.Next = null;
    }

    public Node()
    {
        this.Data = default(T);
        this.Next = null;
    }
}

public class LinkList<T>
{
    public Node<T> Head { set; get; } //单链表头

    //构造
    public LinkList()
    {
        Head=null;
    }

    /// <summary>
    /// 增加新元素到单链表末尾
    /// </summary>
    public void Append(T item)
    {
        Node<T> foot = new Node<T>(item);
        Node<T> A = new Node<T>();
        if (Head == null)
        {
            Head = foot;
            return;
        }
        A = Head;
        while (A.Next != null)
        {
            A = A.Next;
        }
        A.Next = foot;
    }
}

1.如果增加的是头结点。直接把数据域（Data）给Head，Next为空。因为只有一个头结点，没有对应的下结点。

2.单链表是”不走回头路“，所以每次增加都要从单链表的头开始找到单链表最后一个结点（最后一个结点就是Next为NULL），然后把最后一个结点的Next设置成需增加的结点,这时要需增加的结点变身为最后一结点，他的Next为NULL。

public class LinkList<T>
{
    public Node<T> Head { set; get; } //单链表头

    //构造
    public LinkList()
    {
        Head=null;
    }
    public void Delete(int i)
    {
        Node<T> A = new Node<T>();
        if (i == 1)   //删除头
        {
            A = Head;
            Head = Head.Next;
            return;
        }
        Node<T> B = new Node<T>();
        B = Head;
        int j = 1;
        while (B.Next != null && j < i)
        {
            A = B;
            B = B.Next;
            j++;
        }
        if (j == i)
        {
            A.Next = B.Next;
        }
    }
}

1.如果删除的是头结点，那现在的头结点就应该是头结点的下一结点。

2.删除结点如果不是头结点。从单链表头开始查询要删除结点的位置。并记录删除的前一结点值A和所要删除的结点B。因为结点B被删除了,所以结点A的Next就应该为B的Next。把结点A的Next设置为结点B的Next。

单链表类

public class LinkList<T>
{
    public Node<T> Head { set; get; } //单链表头

    //构造
    public LinkList()
    {
        Clear();
    }

    /// <summary>
    /// 求单链表的长度
    /// </summary>
    /// <returns></returns>
    public int GetLength()
    {
        Node<T> p = Head;
        int length = 0;
        while (p != null)
        {
            p = p.Next;
            length++;
        }
        return length;
    }

    /// <summary>
    /// 判断单键表是否为空
    /// </summary>
    /// <returns></returns>
    public bool IsEmpty()
    {
        if (Head == null)
            return true;
        else
            return false;
    }

    /// <summary>
    /// 清空单链表
    /// </summary>
    public void Clear()
    {
        Head = null;
    }

    /// <summary>
    /// 获得当前位置单链表中结点的值
    /// </summary>
    /// <param name="i">结点位置</param>
    /// <returns></returns>
    public T GetNodeValue(int i)
    {
        if (IsEmpty() || i<1 || i>GetLength())
        {
            Console.WriteLine("单链表为空或结点位置有误！");
            return default(T);
        }

        Node<T> A = new Node<T>();
        A = Head;
        int j = 1;
        while (A.Next!=null && j<i)
        {
            A = A.Next;
            j++;
        }

        return A.Data;
    }

    /// <summary>
    /// 增加新元素到单链表末尾
    /// </summary>
    public void Append(T item)
    {
        Node<T> foot = new Node<T>(item);
        Node<T> A = new Node<T>();
        if (Head == null)
        {
            Head = foot;
            return;
        }
        A = Head;
        while (A.Next != null)
        {
            A = A.Next;
        }
        A.Next = foot;
    }

    /// <summary>
    /// 增加单链表插入的位置
    /// </summary>
    /// <param name="item">结点内容</param>
    /// <param name="n">结点插入的位置</param>
    public void Insert(T item, int n)
    {
        if (IsEmpty() || n < 1 || n > GetLength())
        {
            Console.WriteLine("单链表为空或结点位置有误！");
            return;
        }

        if (n == 1)  //增加到头部
        {
            Node<T> H = new Node<T>(item);
            H.Next = Head;
            Head = H;
            return;
        }

        Node<T> A = new Node<T>();
        Node<T> B = new Node<T>();
        B = Head;
        int j = 1;
        while (B.Next != null && j < n)
        {
            A = B;
            B = B.Next;
            j++;
        }

        if (j==n)
        {
            Node<T> C = new Node<T>(item);
            A.Next = C;
            C.Next = B;
        }
    }

    /// <summary>
    /// 删除单链表结点
    /// </summary>
    /// <param name="i">删除结点位置</param>
    /// <returns></returns>
    public void Delete(int i)
    {
        if (IsEmpty() || i < 1 || i > GetLength())
        {
            Console.WriteLine("单链表为空或结点位置有误！");
            return;
        }

        Node<T> A = new Node<T>();
        if (i == 1)   //删除头
        {
            A = Head;
            Head = Head.Next;
            return;
        }
        Node<T> B = new Node<T>();
        B = Head;
        int j = 1;
        while (B.Next != null && j < i)
        {
            A = B;
            B = B.Next;
            j++;
        }
        if (j == i)
        {
            A.Next = B.Next;
        }
    }

    /// <summary>
    /// 显示单链表
    /// </summary>
    public void Dispaly()
    {
        Node<T> A = new Node<T>();
        A = Head;
        while (A != null)
        {
            Console.WriteLine(A.Data);
            A = A.Next;
        }
    }

    #region 面试题
    /// <summary>
    /// 单链表反转
    /// </summary>
    public void Reverse()
    {
        if (GetLength()==1 || Head==null)
        {
            return;
        }

        Node<T> NewNode = null;
        Node<T> CurrentNode = Head;
        Node<T> TempNode = new Node<T>();

        while (CurrentNode!=null)
        {
            TempNode = CurrentNode.Next;
            CurrentNode.Next = NewNode;
            NewNode = CurrentNode;
            CurrentNode = TempNode;
        }
        Head = NewNode;

        Dispaly();
    }

    /// <summary>
    /// 获得单链表中间值
    /// 思路：使用两个指针，第一个每次走一步，第二个每次走两步：
    /// </summary>
    public void GetMiddleValue()
    {
        Node<T> A = Head;
        Node<T> B = Head;

        while (B!=null && B.Next!=null)
        {
            A = A.Next;
            B = B.Next.Next;
        }
        if (B != null) //奇数
        {
            Console.WriteLine("奇数:中间值为：{0}", A.Data);
        }
        else    //偶数
        {
            Console.WriteLine("偶数:中间值为：{0}和{1}", A.Data, A.Next.Data);
        }
    }

    #endregion

}

调用实例

static void Main(string[] args)
{
    LinkList<string> link = new LinkList<string>();
    link.Append("A");
    link.Append("B");
    link.Append("C");
    link.Append("D");
    link.Append("E");
    link.Insert("Head", 1);
    Console.WriteLine("单链表内容：");
    link.Dispaly();
    link.Delete(5);
    Console.WriteLine("已完成删除单链表中第5行记录数");
    link.Dispaly();
    Console.WriteLine("查询单链表中第1:{0}.第3：{1}", link.GetNodeValue(1), link.GetNodeValue(3));
    Console.WriteLine("面试题-->单链表反转");
    link.Reverse();
    Console.WriteLine("面试题-->获得单链表中间值");
    link.GetMiddleValue();
}

输出结果：

时间： 2024-10-13 17:31:40

C# 数据结构--单链表的相关文章

python实现数据结构单链表

#python实现数据结构单链表 # -*- coding: utf-8 -*- class Node(object): """节点""" def __init__(self, elem): self.elem = elem self.next = None # 节点一开始初始化的时候并不知道下一个元素的地址,所以先设置为空 class SingLinkList(object): """单链表""

数据结构—单链表（类C语言描写叙述）

单链表 1.链接存储方法 链接方式存储的线性表简称为链表(Linked List). 链表的详细存储表示为: ① 用一组随意的存储单元来存放线性表的结点(这组存储单元既能够是连续的.也能够是不连续的) ② 链表中结点的逻辑次序和物理次序不一定同样.为了能正确表示结点间的逻辑关系,在存储每一个结点值的同一时候,还必须存储指示其后继结点的地址(或位置)信息(称为指针(pointer)或链(link)) 注意: 链式存储是最经常使用的存储方式之中的一个.它不仅可用来表示线性表.并且可用来表示各种非线性

C# 数据结构 - 单链表 双链表 环形链表

链表特点(单链表 双链表) 优点:插入和删除非常快.因为单链表只需要修改Next指向的节点,双链表只需要指向Next和Prev的节点就可以完成插入和删除操作. 缺点:当需要查找某一个节点的时候就需要一个节点一个节点去访问,这样所花的时候就比较多了.(顺序表可以弥补这缺点,但插入和删除就非常耗性能) 单链表 单链表的构成:必须要有一个链表头(head),每个节点里面有一个Next用于指向下一个节点(类似于指针).最后一个节点的Next为null来标识链表的尾. 如下图 代码实现 1 /* ----

数据结构单链表实现

<数据结构>中单链表的实现c代码 转自:http://blog.chinaunix.net/uid-22750250-id-1769905.html include.h /******************************************************************      程序中要用的头文件******************************************************************/ #include<st

数据结构-单链表-类定义2-C++

上一次的C++链表实现两个单链表的连接不太理想,此次听了一些视频课,自己补了个尾插法,很好的实现了两个链表的连接,当然了,我也是刚接触,可能是C++的一些语法还不太清楚,不过硬是花了一些时间尽量在数据结构中将c++的语言特点表现出来.一开始也是不愿意读c++的数据结构,只是一种挑战心里,不想读着读着感觉自己太low了,c++的内容更加丰富,所以还得多多练习...... 头文件 1 #ifndef LIST_H 2 #define LIST_H 3 #include <iostream> 4 5

Java数据结构——单链表

一.单链表的概念 单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.这组存储单元可以是连续的,也可以是不连续的. 存储单元由两部分组成,数据源和指针,数据源放数据,指针指向下个存储单元. 二.单链表的结构 采用Node实体类类标识,其中data为存储的数据,next为下一个结点的指针. //链表的实体类 class Node{ public int data; public Node next; public Node(int data) { this.data =

大话数据结构---单链表

单链表在存储结构上与顺序存储的区别:不用开辟连续的存储空间,存储位置任意,只需要让数据的前驱知道它的位置就可以,而使用单链表示只需要知道单链表的第一个元素就能找到其他所有的元素,为了方便 一般会设置一个头指针指向第一个元素. 单链表的数据读取:通过头指针一个一个往后遍历 单链表的插入: 删除: 自定义单链表的简单实现: package com.neuedu.entity; /* * 项目名称:JavaSqList * @author:wzc * @date 创建时间:2017年9月2日 上午9:

C实现通用数据结构--单链表

单链表概述 单向链表(单链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始. 从概念上讲,可以把链表想象成一系列连续的元素,然而,由于这些元素是动态分配的(C语言中使用malloc),切记这些元素通常实际上都是分散在内存空间的 本文地址:http://www.cnblogs.com/archimedes/p/c-datastruct-linklist.html,转载请注明源地址. 单链表的接口定义: 1.list_init void list_init(Li

数据结构——单链表

1.对于一个有数据的单链表,如果要对其初始化,使用下列操作: 1 void initList(sqlist &L){ #对于需要改变的变量或链表,使用引用型 2 L.length==0; 3 } //单链表长度重置为0 2.单链表有4中操作:归并,插入,删除,查找 归并的实现:(链表A,B是有序的,且归并后的C也是有序的)如下: 1 void merge(LNode *A,LNode *B,LNode *&C){ //将A B两个链表归并为一个新的单链表(链表C采用引用型) 2 LNode