C#编程(五十一)----------链表

原文链接: http://blog.csdn.net/shanyongxu/article/details/47024865

链表

LinkedList<T>集合类没有非泛型类的版本,它是一个双向链表,他的元素指向元素的前一个与后一个元素.

链表的有点事:如果要插入一个元素到链表的中间位置,效率很高,因为如果插入一个元素,只需要修改上一个元素的Next与下一个元素的Previous的引用即可.

链表的缺点是,链表只能是一个接着一个访问,这样就要用更长的时间来查找定位位于链表中间的元素.

LinkedListNode<T>被LinkedList<T>类包含,用LinkedListNode<T>类,可以获得元素的上一个与下一个元素的引用.

LinkedList<T>的属性


属性名


说明


Count


返回链表中的元素个数


First


返回链表中的第一个节点,其返回类型是一个节点类LinkedListNode<T>,用它可以迭代集合中的其他节点


Last


返回最后一个节点

LinkedList<T>的方法


方法名


说明


AddAfter(),

AddBefore(),

AddFirst(),

AddLast


使用这西方法,可以在变表中添加元素分别是链表的头部和尾部,还有一个节点的前面与后面


Remove(),

RemoveFirst(),

RemoveLast()


First与Last分别删除链表的头部元素与尾部元素,Remove是删除指定的一个匹配对象


CLear()


清除所有的元素


Contains()


搜索一个元素,如果找到返回True,找不到返回False


Find()


从链表头开始找一个元素,并返回他的节点类,LinkedListNode<T>


FindLast()


与Find()类似,不同的是从尾部来搜

案例:使用一个链表LinkedList<T>和一个列表List<T>,链表包含文档,与我们上一个队列的但文档有一个优先级,文档按优先级来排序,如查多个文档优先级相同.则按插入时间决定优先排序.

链表添加文档对象时,它们应放在优先级相同的最后一个文档后面,例如:要加一个文档,优先级数是3,那么,我们应放在3级文档组的最后一个,因为此时它是最晚插入的.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace 链表

{

class Program

{

static void Main(string[] args)

{

PriorityDocumentManager man = new PriorityDocumentManager();

man.AddDocument(new Document("一", "nihao", 8));

man.AddDocument(new Document("二", "nihao", 3));

man.AddDocument(new Document("三", "nihao", 4));

man.AddDocument(new Document("四", "nihao", 8));

man.AddDocument(new Document("五", "nihao", 1));

man.AddDocument(new Document("六", "nihao", 9));

man.AddDocument(new Document("七", "nihao", 1));

man.AddDocument(new Document("八", "nihao", 1));

man.DispalyAllNodes();

Console.Read();

}

}

public class Document

{

private string title;

public string Title

{

get { return title; }

set { title = value; }

}

private string content;

public string Content

{

get { return content; }

set { content = value; }

}

private int priority;

public int Priority

{

get { return priority; }

set { priority = value; }

}

public Document(string title, string content, byte priority)

{

this.title = title;

this.content = content;

this.priority = priority;

}

}

public class PriorityDocumentManager

{

//documentList包含所有的文档

private readonly LinkedList<Document> documentList;

//priorityNodes包含最多10个元素的引用

private readonly List<LinkedListNode<Document>> priorityNodes;

public PriorityDocumentManager()

{

//初始化

documentList = new LinkedList<Document>();

priorityNodes = new List<LinkedListNode<Document>>(10);

for (int i = 0; i < 10; i++)

{

priorityNodes.Add(new LinkedListNode<Document>(null));

}

}

/// <summary>

/// 添加文档

/// </summary>

/// <param name="d">要添加的文档对象</param>

public void AddDocument(Document d)

{

if (d==null)

{

//如果文档为空,抛出异常

throw new ArgumentNullException("d");

}

//调用添加方法

AddDocumentToPriorityNode(d, d.Priority);

}

private void AddDocumentToPriorityNode(Document doc, int priority)

{

if (priority>9||priority<0)

{

throw new ArgumentException("优先级异常");

}

if (this.priorityNodes[priority].Value==null)

{

priority--;

if (priority>=0)

{

AddDocumentToPriorityNode(doc, priority);

}

else

{

this.documentList.AddLast(doc);

this.priorityNodes[doc.Priority] = this.documentList.Last;

}

return;

}

else

{

LinkedListNode<Document> priorityNode=this.priorityNodes[priority];

if (priority==doc.Priority)

{

this.documentList.AddAfter(priorityNode, doc);

this.priorityNodes[doc.Priority] = priorityNode.Next;

}

else

{

LinkedListNode<Document> firstPriorityNode = priorityNode;

while (firstPriorityNode.Previous != null && firstPriorityNode.Previous.Value.Priority == priorityNode.Value.Priority)

{

firstPriorityNode = priorityNode.Previous;

}

this.documentList.AddBefore(firstPriorityNode, doc);

priorityNodes[doc.Priority] = firstPriorityNode.Previous;

}

}

}

public void DispalyAllNodes()

{

foreach (Document doc in this.documentList)

{

Console.WriteLine("文档标题:{0} 文档内容:{1} 优先级:{2}", doc.Title, doc.Content, doc.Priority);

}

}

}

}

从上可以看出,

链表不仅能在列表中存储元素,还可以给每个元素存储下一个元素和上一个元素的信息.这就是LinkedList<T>包含LinkedListNode<T>类型的元素而定原因.使用LinkedListNode<T>类,可以获得列表中的下一个元素和上一个元素.

案例:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace 链表测试

{

public struct test

{

public string name;

public string num;

}

public struct test1

{

public test st;

public string name;

}

class Program

{

static void Main(string[] args)

{

LinkedList<test> t = new LinkedList<test>();

test t1, t2;

test1 tt1, tt2;

t1.name = "t1";

t2.name = "t2";

t1.num = "1";

t2.num = "2";

t.AddFirst(t1);

t.AddFirst(t2);

tt1.st = t1;

tt2.st = t2;

tt1.name = "tt1";

tt2.name = "tt2";

LinkedList<test1> tt = new LinkedList<test1>();

tt.AddFirst(tt1);

tt.AddFirst(tt2);

LinkedListNode<test1> current11 = tt.FindLast(tt1);

test1 tr1 = current11.Value;

LinkedListNode<test> current1 = t.FindLast(t1);

test tr = current1.Value;

string[] words = { "the", "fox", "jumped", "over", "the", "dog" };

LinkedList<string> sentence = new LinkedList<string>(words);

Display(sentence);

Console.WriteLine("sentence.Contain(\"jumped\")={0}", sentence.Contains("jumped"));

sentence.AddFirst("today");

Display(sentence);

LinkedListNode<string> mark1 = sentence.First;

sentence.RemoveFirst();

sentence.AddLast(mark1);

Display(sentence);

sentence.RemoveLast();

sentence.AddLast("yesterday");

Display(sentence);

mark1 = sentence.Last;

sentence.RemoveLast();

sentence.AddFirst(mark1);

Display(sentence);

sentence.RemoveFirst();

LinkedListNode<string> current = sentence.FindLast("the");

Display(sentence);

sentence.AddAfter(current, "old");

sentence.AddAfter(current, "lazy");

DIsplayNode(current);

current = sentence.Find("fox");

DIsplayNode(current);

sentence.AddBefore(current, "quick");

sentence.AddBefore(current, "brown");

DIsplayNode(current);

mark1 = current;

LinkedListNode<string> mark2 = current.Previous;

current = sentence.Find("dog");

DIsplayNode(current);

try

{

sentence.AddBefore(current, mark1);

}

catch (InvalidOperationException ex)

{

Console.WriteLine("Exception message: {0}", ex.Message);

}

sentence.Remove(mark1);

sentence.AddBefore(current, mark1);

DIsplayNode(current);

sentence.Remove(current);

DIsplayNode(current);

sentence.AddAfter(mark2, current);

DIsplayNode(current);

sentence.Remove("old");

Display(sentence);

sentence.RemoveLast();

ICollection<string> icoll = sentence;

icoll.Add("rhinoceros");

Display(sentence);

Console.WriteLine("\nCopy the list to an array.");

string[] sArray = new string[sentence.Count];

sentence.CopyTo(sArray, 0);

foreach (var item in sArray)

{

Console.WriteLine(item);

}

sentence.Clear();

}

private static void Display(LinkedList<string> words)

{

foreach (var item in words)

{

Console.WriteLine(item + " ");

}

Console.WriteLine();

}

private static void DIsplayNode(LinkedListNode<string> node)

{

if (node.List == null)

{

Console.WriteLine("Node \"{0}\" is not in a list.", node.Value);

return;

}

StringBuilder result = new StringBuilder("(" + node.Value + ")");

LinkedListNode<string> nodeP = node.Previous;

while (nodeP != null)

{

result.Insert(0, nodeP.Value + " ");

nodeP = nodeP.Previous;

}

node = node.Next;

while (node != null)

{

result.Append(" " + node.Value);

node = node.Next;

}

Console.WriteLine(result);

}

}

}

自定义链表:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace 自定义链表

{

class Program

{

static void Main(string[] args)

{

}

}

public class Node<T>

{

public T data;

public Node()

{ }

public Node(T data)

{

this.data = data;

}

public Node<T> next = null;

}

public class Link<T>

{

//定义链表的头节点

private Node<T> head;

//链表初始化

public Link()

{

head = null;

}

/// <summary>

/// 链表的长度,遍历整个链表,知道链表结尾

/// </summary>

/// <returns></returns>

public int Count()

{

//定义一个节点

Node<T> p = head;

int count = 0;//链表计数器

//遍历链表

while (p!=null)

{

count++;

p = p.next;//移到下一个节点

}

return count;

}

/// <summary>

/// 取链表的第i个节点的值

/// </summary>

/// <param name="i">第i个节点</param>

/// <returns></returns>

public T GetElem(int i)

{

//定义一个节点

Node<T> p = head;

int k = 0;//计数器

//如果i大于链表的长度或i小于0,则报出异常

if (i>=Count()||i<0)

{

throw new Exception("error");

}

//如果i大于0且小于链表长度,则遍历链表知道第i个节点为止

while (k<i)

{

k++;

p = p.next;

}

return p.data;

}

/// <summary>

/// 在链表的第i个位置上插入新的节点

/// </summary>

/// <param name="e">要插入节点的值</param>

/// <param name="i">链表的第i个节点</param>

public void Insert(T e, int i)

{

Node<T> p = new Node<T>(e);//要插入的节点

Node<T> q = head;

int k = 0;//计数器

//如果i大于链表的长度或i小于0,则抛出异常

if (i>=Count()||i<0)

{

Console.WriteLine("Error");

return;

}

//如果再链表头插入,移动头指针

if (i==0)

{

p.next = head;

head = p;

return;

}

//遍历链表直到i-1个节点为止

while (k<i-1)

{

k++;

q = q.next;

}

//把新节点插入在第i以个点的位置

p.next = q.next;

q.next = p;

}

/// <summary>

/// 删除第i个节点

/// </summary>

/// <param name="i">链表的第i个节点</param>

public void RemoveAt(int i)

{

Node<T> p = head;

int k = 0;//计数器

// //如果i大于链表的长度或i小于0,则抛出异常

if (i >= Count() || i < 0)

{

Console.WriteLine("Error");

return;

}

//如果删除链表头,移动头指针

if (i==0)

{

head.next = head.next.next;

return;

}

//遍历链表直到第i-1个节点为止

while (k<i-1)

{

k++;

p = p.next;

}

//删除第i个节点

p.next = p.next.next;

}

/// <summary>

/// 在链表尾加入一个新的节点

/// </summary>

/// <param name="e">新的节点的值</param>

public void Add(T e)

{

Node<T> p = new Node<T>(e);//创建一个新的节点

Node<T> q = new Node<T>();

//如果链表为空,则将新的节点作为头

if (head==null)

{

head = p;

return;

}

//如果链表不为空,则在链表尾加入新的节点

//从头指针开始遍历,直至链表尾

q = head;

while (q.next!=null)

{

q = q.next;

}

//在链表尾插入新节点

q.next = q;

}

/// <summary>

/// 查找某个元素在立案表中第一次出现的位置

/// </summary>

/// <param name="e">要查找的元素</param>

/// <returns></returns>

public int IndexOf(T e)

{

Node<T> p = head;

int k = 0;//计数器

/*

* 遍历整个链表,知道找到第一个节点的值

* 与钙元素相等退出,并返回相应的位置索引.

* 如果没有找到,则返回-1

*/

//从头指针开始遍历,找到退出,并返回相应的位置索引

while (p.next!=null)

{

if (p.data.Equals(e))

{

return k;

}

k++;

p = p.next;

}

if (!p.data.Equals(e))

{

k++;

}

//如果没有找到,则返回-1

return k >= Count() ? -1 : k;

}

/// <summary>

/// 查找某个元素在链表中最后一次出现的位置

/// </summary>

/// <param name="e">要查找的元素</param>

/// <returns>这个元素在链表中最后一次出现的位置的索引</returns>

public int LastIndexOf(T e)

{

Node<T> p = head;

int index = -1;//最后一次出现的位置索引

int k = 0;//计数器

/*

* 遍历整个链表,每发现相应节点的值与该元素相等

* 则将该节点的位置所以赋给index,

* 这样index的值就是最后一次的值.如果没有,则返回-1

*

*/

while (p.next!=null)

{

if (p.data.Equals(e))

{

index = k;

}

k++;

p = p.next;

}

if (p.data.Equals(e))

{

index = k;

}

return index;

}

/// <summary>

/// 判断链表是否为空

/// </summary>

/// <returns></returns>

public bool Empty()

{

return head == null ? true : false;

}

/// <summary>

/// 清空链表

/// </summary>

public void Clear()

{

head = null;

}

/// <summary>

/// 将链表转成数组

/// </summary>

/// <returns>转换后的数组</returns>

public T[] ToArray()

{

T[] array = new T[Count()];//定义一个与链表长度相同的数组

/*

* 遍历链表,将链表的每个节点的值放到相应的数组里

*

*/

Node<T> p = head;

int i = 0;//数组下标计数器

while (p.next!=null)

{

array[i++] = p.data;

p = p.next;

}

array[Count() - 1] = p.data;

return array;

}

/// <summary>

/// 将一个数组加到链表中

/// </summary>

/// <param name="a">要加入链表的数组</param>

public void AddRange(T[] a)

{

//遍历整个数组,将数组中的每个元素作为一个新的节点加入到链表中

for (int i = 0; i < a.Length; i++)

{

Add(a[i]);

}

}

/// <summary>

/// 删除链表中值为某个元素的所有节点

/// </summary>

/// <param name="e">要删除节点的值</param>

public void Remove(T e)

{

//如果头指针的值等于这个元素,则删除这个元素,并将头指针后移

while (head.data.Equals(e))

{

head = head.next;

}

//如果不是头指针,则删除该节点

Node<T> p = head;

while (p.next.next!=null)

{

if (p.next.data.Equals(e))

{

p.next = p.next.next;

continue;

}

p = p.next;

}

if (p.next.data.Equals(e))

{

p.next = null;

}

}

/// <summary>

///将链表中所有为某个值的节点替换为另一个值

/// </summary>

/// <param name="first"></param>

/// <param name="second"></param>

public void Replace(T first, T second)

{

Node<T> p = head;

while (p.next!=null)

{

if (p.data.Equals(first))

{

p.data = second;

}

p = p.next;

}

if (p.data.Equals(first))

{

p.data = second;

}

}

/// <summary>

/// 链表反转

/// </summary>

public void Reverse()

{

Node<T> p = head;

Node<T> newhead = head;

Node<T> q = p;

p = p.next;

newhead.next = null;

while (p.next!=null)

{

q = p;

p = p.next;

q.next = newhead;

newhead = q;

}

q = p;

q.next = newhead;

newhead = p;

head = newhead;

}

}

}

时间: 2024-10-25 18:34:46

C#编程(五十一)----------链表的相关文章

QT开发(五十一)——QtQuick基础

QT开发(五十一)--QtQuick基础 一.QtQuick简介 QT提供了两种独立的方法创建用户界面. QtQuick模块为创建流畅.鲜活的用户界面提供了一种标记语言.QtQuick模块适合需要动画元素的界面,以及应用程序主要运行在小屏幕和多点触控的设备上的场景. QtWidgets模块针对传统桌面提供了更多的支持,和目标平台做了更多的集成,无论目标平台是MacOSX.Windows.KDE.GNome.QtWidgets是一个非常高效的基于C++的类库,包含很多常见的用户界面组件,可以非常容

第十五章 链表

/** 数组与链表的区别:数组易随机访问,链表易插入和删除 链表组成:储存数据元素的数据域,储存下一结点地址的指针域 链表易于插入与删除 lists 的用法????????????????????? *///建立一个图书链表 #include<iostream> #include <string> using namespace std; struct book //第一步: 用于建立节点. class 默认为私有 struct 默认为公有 //节点组成:①数据域 ②指针域(*ne

Win32 Windows编程 五

一 Win32消息机制 1 消息机制 过程驱动:程序是按照我们预先定义好的顺序执行,每执行一步,下一步都已经按照预定的顺序继续执行,直到程序结束 事件驱动: 程序的执行顺序是无序的.某个事件点所执行的代码,是由外界通知.由于我们无法决定用户执行顺序,所以代码的执行也是无序 Win32的消息机制 - 事件驱动 2 Win32消息程序 2.1 Win32 窗口注册 2.2 Win32窗口创建 2.3 Win32消息循环 2.3.1 GetMessage BOOL GetMessage( LPMSG

Linux网络编程 五种I/O 模式及select、epoll方法的理解

Linux网络编程 五种I/O 模式及select.epoll方法的理解 web优化必须了解的原理之I/o的五种模型和web的三种工作模式 五种I/O 模式--阻塞(默认IO模式),非阻塞(常用语管道),I/O多路复用(IO多路复用的应用场景),信号I/O,异步I/OLinux网络编程 五种I/O 模式及select.epoll方法的理解

shell编程(十一)---- case判断

case的语法格式: case $arg in       pattern | sample) # arg in pattern or sample       ;;       pattern1) # arg in pattern1       ;;       *) #default       ;;   esac  说明:arg是您所引入的参数,如果arg内容符合pattern项目的话,那么便会执行pattern以下的代码段,而该段代码则以两个分号";;"做结尾. shell编程

五十一、php-fpm的pool、php-fpm慢执行日志、open_basedir、php-fpm

五十一.php-fpm的pool.php-fpm慢执行日志.open_basedir.php-fpm进程管理 一.php-fpm的pool pool:右侧.ps aux最右侧的那一列.就是它的池子. # cd /usr/local/php-fpm/etc # cat php-fpm.conf    //支持定义多个池子 [global] pid = /usr/local/php-fpm/var/run/php-fpm.pid error_log = /usr/local/php-fpm/var/

LeetCode开心刷题五十一天——118. Pascal&#39;s Triangle 接触跳转表概念,不知用处 lamda逗号导致表达式加法奇怪不理解119. Pascal&#39;s Triangle II

118. Pascal's Triangle Easy 87984FavoriteShare Given a non-negative integer numRows, generate the first numRows of Pascal's triangle. In Pascal's triangle, each number is the sum of the two numbers directly above it. Example: Input: 5 Output: [ [1],

Linux网络编程学习(十一) ----- 五种I/O模式(第六章)

1.五种I/O模式是哪几个? 阻塞I/O,非阻塞I/O,I/O多路复用,信号驱动I/O(SIGIO),异步I/O 一般来讲程序进行输入操作有两个步骤,一是等待有数据可读,二是将数据从系统内核中拷贝到程序的数据集区. 对于一个套接字的数据操作,第一步就是等待数据从网络上传到本地,当数据包到达时,数据将会从网络层拷贝到内核的缓冲中,第二步就是从内核中将数据拷贝到程序的数据区中. 2.五种阻塞模式简介 1)阻塞I/O模式 套接字建立后默认的模式就是阻塞I/O模式,对于UDP而言,数据就绪的标志比较简单

ActionScript3游戏中的图像编程(连载五十一)

3.2.2 高强度的斜角模拟所谓的"雕刻清晰" 不少ActionScript图书或者网上教程在介绍斜角滤镜时都喜欢拿高强度的参数作为例子来讲解雕刻清晰的实现方法(图 3.38). 图 3.38 用高强度的斜角滤镜实现雕刻清晰 实际上,这种做法并不经得起推敲.首先,两光面和两暗面之间并无分界,其次,实例中的图形恰好是矩形,如果换成轮廓复杂点的文字,这个所谓的清晰就显得比较突兀了(图 3.39). 图 3.39 用Flash模拟的雕刻清晰字母O 而Photoshop在这两细节效果的处理上都