第八天 线性表【下】

最新推荐文章于 2024-05-07 09:59:59 发布
最新推荐文章于 2024-05-07 09:59:59 发布
阅读量41 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/KohnKong/articles/2308566.html
版权

一：线性表的简单回顾

       上一篇跟大家聊过“线性表"顺序存储，通过实验，大家也知道，如果我每次向

顺序表的头部插入元素，都会引起痉挛，效率比较低下，第二点我们用顺序存储时，容

易受到长度的限制，反之就会造成空间资源的浪费。

 

二：链表

      对于顺序表存在的若干问题，链表都给出了相应的解决方案。

1. 概念：其实链表的“每个节点”都包含一个”数据域“和”指针域“。

            ”数据域“中包含当前的数据。

            ”指针域“中包含下一个节点的指针。

            ”头指针”也就是head，指向头结点数据。

            “末节点“作为单向链表，因为是最后一个节点，通常设置指针域为null。

代码段如下：

#region 链表节点的数据结构
/// <summary>
/// 链表节点的数据结构
/// </summary>
     public class Node<T>
     {
/// <summary>
/// 节点的数据域
/// </summary>
         public T data;

/// <summary>
/// 节点的指针域
/// </summary>
         public Node<T> next;
     }
#endregion

2.常用操作：

    链表的常用操作一般有：

           ①添加节点到链接尾，②添加节点到链表头，③插入节点。

           ④删除节点，⑤按关键字查找节点，⑥取链表长度。

   

<1> 添加节点到链接尾：

          前面已经说过，链表是采用指针来指向下一个元素，所以说要想找到链表最后一个节点，

       必须从头指针开始一步一步向后找,少不了一个for循环，所以时间复杂度为O(N)。

 

代码段如下：

#region 将节点添加到链表的末尾
/// <summary>
/// 将节点添加到链表的末尾
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListAddEnd<T>(Node<T> head, T data)
         {
             Node<T> node = new Node<T>();

             node.data = data;
             node.next = null;

///说明是一个空链表
             if (head == null)
             {
                 head = node;
return head;
             }

//获取当前链表的最后一个节点
             ChainListGetLast(head).next = node;

return head;
         }
#endregion
#region 得到当前链表的最后一个节点
/// <summary>
/// 得到当前链表的最后一个节点
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <returns></returns>
         public Node<T> ChainListGetLast<T>(Node<T> head)
         {
if (head.next == null)
return head;
return ChainListGetLast(head.next);
         }
#endregion

<2> 添加节点到链表头:

          大家现在都知道，链表是采用指针指向的，要想将元素插入链表头，其实还是很简单的，

      思想就是：① 将head的next指针给新增节点的next。②将整个新增节点给head的next。

      所以可以看出，此种添加的时间复杂度为O(1)。

 

效果图：

代码段如下：

#region 将节点添加到链表的开头
/// <summary>
/// 将节点添加到链表的开头
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="chainList"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListAddFirst<T>(Node<T> head, T data)
         {
             Node<T> node = new Node<T>();

             node.data = data;
             node.next = head;

             head = node;

return head;

         }
#endregion

<3> 插入节点:

           其实这个思想跟插入到”首节点“是一个模式，不过多了一步就是要找到当前节点的操作。然后找到

      这个节点的花费是O(N）。上图上代码，大家一看就明白。

 

效果图：

代码段：

#region 将节点插入到指定位置
/// <summary>
/// 将节点插入到指定位置
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <param name="currentNode"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListInsert<T, W>(Node<T> head, string key, Func<T, W> where, T data) where W : IComparable
         {
if (head == null)
return null;

if (where(head.data).CompareTo(key) == 0)
             {
                 Node<T> node = new Node<T>();

                 node.data = data;

                 node.next = head.next;

                 head.next = node;
             }

             ChainListInsert(head.next, key, where, data);

return head;
         }
#endregion

<4> 删除节点:

        这个也比较简单，不解释，图跟代码更具有说服力，口头表达反而让人一头雾水。

        当然时间复杂度就为O(N)，N是来自于查找到要删除的节点。

 

效果图：

代码段：

#region 将指定关键字的节点删除
/// <summary>
/// 将指定关键字的节点删除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="W"></typeparam>
/// <param name="head"></param>
/// <param name="key"></param>
/// <param name="where"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListDelete<T, W>(Node<T> head, string key, Func<T, W> where) where W : IComparable
         {
if (head == null)
return null;

//这是针对只有一个节点的解决方案
             if (where(head.data).CompareTo(key) == 0)
             {
if (head.next != null)
                     head = head.next;
else
return head = null;
             }
else
             {
//判断一下此节点是否是要删除的节点的前一节点
                 while (head.next != null && where(head.next.data).CompareTo(key) == 0)
                 {
//将删除节点的next域指向前一节点
                     head.next = head.next.next;
                 }
             }

             ChainListDelete(head.next, key, where);

return head;
         }
#endregion

<5> 按关键字查找节点：

         这个思想已经包含到“插入节点”和“删除节点”的具体运用中的，其时间复杂度为O(N)。

 

代码段：

#region 通过关键字查找指定的节点
/// <summary>
/// 通过关键字查找指定的节点
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="W"></typeparam>
/// <param name="head"></param>
/// <param name="key"></param>
/// <param name="where"></param>
/// <returns></returns>
         public Node<T> ChainListFindByKey<T, W>(Node<T> head, string key, Func<T, W> where) where W : IComparable
         {
if (head == null)
return null;

if (where(head.data).CompareTo(key) == 0)
return head;

return ChainListFindByKey<T, W>(head.next, key, where);
         }
#endregion


<6> 取链表长度:

          在单链表的操作中，取链表长度还是比较纠结的，因为他不像顺序表那样是在内存中连续存储的，

      因此我们就纠结的遍历一下链表的总长度。时间复杂度为O(N)。

 

代码段：

#region 获取链表的长度
/// <summary>
///// 获取链表的长度
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <returns></returns>
         public int ChanListLength<T>(Node<T> head)
         {
int count = 0;

while (head != null)
             {
                 ++count;
                 head = head.next;
             }

return count;
         }
#endregion

好了，最后上一下总的运行代码：

View Code 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ChainList
 {
class Program
     {
static void Main(string[] args)
         {
             ChainList chainList = new ChainList();

             Node<Student> node = null;

             Console.WriteLine("将三条数据添加到链表的尾部:\n");

//将数据添加到链表的尾部
             node = chainList.ChainListAddEnd(node, new Student() { ID = 2, Name = "hxc520", Age = 23 });
             node = chainList.ChainListAddEnd(node, new Student() { ID = 3, Name = "博客园", Age = 33 });
             node = chainList.ChainListAddEnd(node, new Student() { ID = 5, Name = "一线码农", Age = 23 });

             Dispaly(node);

             Console.WriteLine("将ID=1的数据插入到链表开头:\n");

//将ID=1的数据插入到链表开头
             node = chainList.ChainListAddFirst(node, new Student() { ID = 1, Name = "i can fly", Age = 23 });

             Dispaly(node);

             Console.WriteLine("查找Name=“一线码农”的节点\n");

//查找Name=“一线码农”的节点
             var result = chainList.ChainListFindByKey(node, "一线码农", i => i.Name);

             DisplaySingle(node);

             Console.WriteLine("将”ID=4“的实体插入到“博客园”这个节点的之后\n");

//将”ID=4“的实体插入到"博客园"这个节点的之后
             node = chainList.ChainListInsert(node, "博客园", i => i.Name, new Student() { ID = 4, Name = "51cto", Age = 30 });

             Dispaly(node);

             Console.WriteLine("删除Name=‘51cto‘的节点数据\n");

//删除Name=‘51cto‘的节点数据
             node = chainList.ChainListDelete(node, "51cto", i => i.Name);

             Dispaly(node);

             Console.WriteLine("获取链表的个数:" + chainList.ChanListLength(node));
         }

//输出数据
         public static void Dispaly(Node<Student> head)
         {
             Console.WriteLine("******************* 链表数据如下 *******************");
var tempNode = head;

while (tempNode != null)
             {
                 Console.WriteLine("ID:" + tempNode.data.ID + ", Name:" + tempNode.data.Name + ",Age:" + tempNode.data.Age);
                 tempNode = tempNode.next;
             }

             Console.WriteLine("******************* 链表数据展示完毕 *******************\n");
         }

//展示当前节点数据
         public static void DisplaySingle(Node<Student> head)
         {
if (head != null)
                 Console.WriteLine("ID:" + head.data.ID + ", Name:" + head.data.Name + ",Age:" + head.data.Age);
else
                 Console.WriteLine("未查找到数据！");
         }
     }

#region 学生数据实体
/// <summary>
/// 学生数据实体
/// </summary>
     public class Student
     {
public int ID { get; set; }

public string Name { get; set; }

public int Age { get; set; }
     }
#endregion

#region 链表节点的数据结构
/// <summary>
/// 链表节点的数据结构
/// </summary>
     public class Node<T>
     {
/// <summary>
/// 节点的数据域
/// </summary>
         public T data;

/// <summary>
/// 节点的指针域
/// </summary>
         public Node<T> next;
     }
#endregion

#region 链表的相关操作
/// <summary>
/// 链表的相关操作
/// </summary>
     public class ChainList
     {
#region 将节点添加到链表的末尾
/// <summary>
/// 将节点添加到链表的末尾
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListAddEnd<T>(Node<T> head, T data)
         {
             Node<T> node = new Node<T>();

             node.data = data;
             node.next = null;

///说明是一个空链表
             if (head == null)
             {
                 head = node;
return head;
             }

//获取当前链表的最后一个节点
             ChainListGetLast(head).next = node;

return head;
         }
#endregion

#region 将节点添加到链表的开头
/// <summary>
/// 将节点添加到链表的开头
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="chainList"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListAddFirst<T>(Node<T> head, T data)
         {
             Node<T> node = new Node<T>();

             node.data = data;
             node.next = head;

             head = node;

return head;

         }
#endregion

#region 将节点插入到指定位置
/// <summary>
/// 将节点插入到指定位置
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <param name="currentNode"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListInsert<T, W>(Node<T> head, string key, Func<T, W> where, T data) where W : IComparable
         {
if (head == null)
return null;

if (where(head.data).CompareTo(key) == 0)
             {
                 Node<T> node = new Node<T>();

                 node.data = data;

                 node.next = head.next;

                 head.next = node;
             }

             ChainListInsert(head.next, key, where, data);

return head;
         }
#endregion

#region 将指定关键字的节点删除
/// <summary>
/// 将指定关键字的节点删除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="W"></typeparam>
/// <param name="head"></param>
/// <param name="key"></param>
/// <param name="where"></param>
/// <param name="data"></param>
/// <returns></returns>
         public Node<T> ChainListDelete<T, W>(Node<T> head, string key, Func<T, W> where) where W : IComparable
         {
if (head == null)
return null;

//这是针对只有一个节点的解决方案
             if (where(head.data).CompareTo(key) == 0)
             {
if (head.next != null)
                     head = head.next;
else
return head = null;
             }
else
             {
//判断一下此节点是否是要删除的节点的前一节点
                 if (head.next != null && where(head.next.data).CompareTo(key) == 0)
                 {
//将删除节点的next域指向前一节点
                     head.next = head.next.next;
                 }
             }

             ChainListDelete(head.next, key, where);

return head;
         }
#endregion

#region 通过关键字查找指定的节点
/// <summary>
/// 通过关键字查找指定的节点
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="W"></typeparam>
/// <param name="head"></param>
/// <param name="key"></param>
/// <param name="where"></param>
/// <returns></returns>
         public Node<T> ChainListFindByKey<T, W>(Node<T> head, string key, Func<T, W> where) where W : IComparable
         {
if (head == null)
return null;

if (where(head.data).CompareTo(key) == 0)
return head;

return ChainListFindByKey<T, W>(head.next, key, where);
         }
#endregion

#region 获取链表的长度
/// <summary>
///// 获取链表的长度
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <returns></returns>
         public int ChanListLength<T>(Node<T> head)
         {
int count = 0;

while (head != null)
             {
                 ++count;
                 head = head.next;
             }

return count;
         }
#endregion

#region 得到当前链表的最后一个节点
/// <summary>
/// 得到当前链表的最后一个节点
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="head"></param>
/// <returns></returns>
         public Node<T> ChainListGetLast<T>(Node<T> head)
         {
if (head.next == null)
return head;
return ChainListGetLast(head.next);
         }
#endregion

     }
#endregion
 }

运行结果：

 

当然，单链表操作中有很多是O(N)的操作，这给我们带来了尴尬的局面，所以就有了很多的

优化方案，比如：双向链表，循环链表。静态链表等等，这些希望大家在懂得单链表的情况下

待深一步的研究。

 













转载于:https://www.cnblogs.com/KohnKong/articles/2308566.html

weixin_30845171
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表算法
06-14
数据结构C++线性表算法
算法系列15天速成——第八天 线性表【下】
weixin_34279061的博客
11-30 263
  一：线性表的简单回顾        上一篇跟大家聊过“线性表"顺序存储，通过实验，大家也知道，如果我每次向 顺序表的头部插入元素，都会引起痉挛，效率比较低下，第二点我们用顺序存储时，容 易受到长度的限制，反之就会造成空间资源的浪费。   二：链表       对于顺序表存在的若干问题，链表都给出了相应的解决方案。 1. 概念：其实链表的“每个节点”都包含一个”数据域“和”指针域...
算法之线性表
weixin_43952158的博客
04-18 166
线性表的定义：零个或多个数据元素的有限序列。 存在多个元素，则第一个元素无前驱，最后一个元素无后继，其它每个元素都有且只有一个前驱和后继 若将线性表记为(1.2.3.4.5.6)3是的前驱元素，5是4的直接后继元素。 顺序存储结构的插入与删除 ...
线性表算法实现
qq_16739131的博客
10-27 611
1.设有两个无头结点的单链表，头指针分别为ha.hb.链中有数据域data链域next,两链表的数据都按递增序存放，现要求将hb表归到ha表中且归并后ha仍递增序，归并中ha表中已有的数据若hb中也有则hb中的数据不归并到ha中要求不申请额外的存储空间来完成。merge(hahb); linklist.h // // Linklist.h // Test // // Created...
数据结构——第二章 线性表
sunyanxian的博客
12-14 2163
目录线性表的定义和特点案例引入一元多项式的运算图书管理系统总结线性表的类型定义线性表的基本操作线性表的初始化线性表的销毁和重置判断线性表是否为空测量线性表的长度获取线性表中元素查找定位线性表中元素求线性表中元素前驱求线性表中元素前驱和后继在线性表中插入和删除元素遍历线性表的元素线性表的顺序表示和实现顺序存储结构顺序表中元素存储位置的计算顺序表的顺序存储表示一元多项式的顺序存储结构类型定义图书表的顺序存储结构类型定义顺序表基本操作的实现线性表的基本操作补充：操作算法中用到的预定义常量和类型※顺序表的初始化销毁
第三章 线性表
CyYu的博客
09-23 232
二、线性表 2.1 线性表的定义 线性表（list）：零个或多个数据元素的有限序列（数据类型相同） 序列，元素之间有顺序，有多个元素时，第一个无前驱，最后一个无后继，其他只有一个前驱和后继。 有限，元素个数有限。无限数列只存在于概念中。   若将线性表记为（a1a_1a1​,a2a_2a2​,…aia_iai​,…ana_nan​），则表中ai−1a_{i-1}ai−1​领先于aia_iai​，aia_iai​领先于ai+1a_{i+1}ai+1​，称ai−1a_{i-1}ai−1​是aia_iai​的
算法系列15天速成 第八天 线性表【下】
10-26
上一篇跟大家聊过“线性表"顺序存储，通过实验，大家也知道，如果我每次向顺序表的头部插入元素，都会引起痉挛，效率比较低下，第二点我们用顺序存储时，容易受到长度的限制，反之就会造成空间资源的浪费
第2章线性表作业1
08-08
要求： （1）对顺序表（1,1,2,2,2,3,4,5,5,5,6,6,7,7,8,8,8,9）模拟执行本算法，并统计移动元素的次数。2.22 设计算法将两个递
线性表 实验报告.docx
12-31
选题1：（易）实现顺序表各种基本运算的算法 参考实验指导书“实验题 1：实现顺序表各种基本运算的算法实现”。 选题2：（易）实现单链表各种基本运算的算法 ...参考课件“chap002线性表习题讲解.ppt”第35页例题。
完整详细版 C语言版 数据结构与算法课程 第2章 线性表 线性数据结构（共122页）.ppt
10-06
基于C语言的数据结构与算法课程，共8章，完整课程列表如下： C语言版 数据结构与算法课程 第1章 数据结构绪论（共73页）.ppt C语言版 数据结构与算法课程 第...C语言版 数据结构与算法课程 第8章 图算法（共84页）.ppt
C语言线性表结构实验
11-06
第1 行为集合A的元素，第二行为集合B元素。 结果输出: 将计算出的合并后的新集合A中元素输出到文件output.txt。 4． 输入文件范例 input.txt 2 6 3 9 8 6 3 5 2 3 5 5 6 6 输出文件范例 output.txt 2 6 3 9 8 6...
线性表常见算法实现
Hundreays
09-07 1208
常见算法实现线性表 线性表 设计一个算法，将顺序表中所有的元素逆置。 设计一个算法，从一给定的顺序表L中删除下标i~j(i<=j,包括i,j)的所有元素，假定i，j都是合法的。 有一个顺序表L，其元素为整型数据，设计一个算法，将L中所有小于表头元素的整数放在前半部分，大于表头无素的整数放在后半部分。 有一个递增非空单链表，设计一个算法删除值域重复的结点。例如，{1...
线性表之顺序表示算法实现（一）
洋仔的博客
09-27 1523
为了准备考研，重拾了数据结构的代码学习，看了大量的代码片段之后，我实在是受不了身为程序狗，不敲代码而去手写代码的烦躁，于是还是将今天晚上的学习内容敲在了编译器里面，重拾对代码最初的热爱。   严蔚敏版本的数据结构不愧为数据结构中的典范，我真的很是建议从严的书入手，辅以王道或者天勤。当然，我是不建议天勤的，极其的没有专业性，难怪号称出自学生之手。   不多说了，今天时间紧，只是测试书中算法2.3
（论文阅读-优化器）EFFICIENCY IN THE COLUMBIA DATABASE QUERY OPTIMIZER
junerli的博客
05-06 863
查询优化是一个数据库系统能够获得重要性能收益的领域。现代数据库应用通常要求优化器具有高可扩展性和效率。Columbia基于Cascades优化框架的自顶向下优化算法，通过对搜索空间结构和搜索算法的精心重构，简化了自顶向下优化器的设计。
Java | Leetcode Java题解之第62题不同路径
m0_57195758的博客
05-01 573
Java | Leetcode Java题解之第62题不同路径
【随想录】Day38—第九章 动态规划part01
最新发布
weixin_44382896的博客
05-07 621
爬楼梯每次只能走 1 或者 2 步，因此当前楼梯到达的方式取决于。爬楼梯每次只能走 1 或者 2。
数据结构与算法——栈和队列
2303_76624483的博客
05-02 442
栈和队列
拥有搜索结构子树的最大节点数(最大二叉搜索子树)
qinghehe198508的博客
05-02 152
如果x在这个最大的搜索结构中做头，那么这整棵树一定是搜索二叉树，需要左子树一定是搜索二叉树，右子树一定是搜索二叉树，左子树的最大值x，搜索结构的节点数就是左树size + 右数size +1。那么如果我们要向左子树和右子树分别要信息得到自身信息的话，要的信息就有，树中最大搜索结构的节点数(1)，树的最小值(2)，树的最大值(3)，树的大小size(4)，当前树是否是二叉搜索树(5)，又因为当前树是否是搜索二叉树可以通过(1)和(4)的大小是否相等得到，所以要的信息减少为前面4个信息。
C语言实现在线性表中第i个位置删除数据e的代码
09-10
在主函数中，我们初始化了一个包含 5 个数据元素的线性表，并调用 deleteElem 函数删除第 3 个位置的数据，然后输出删除结果和删除后的线性表。 ### 回答2： 下面是C语言实现在线性表中第i个位置删除数据e的代码：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值