可随机访问的双向链表(C#实现)

可随机访问的双向链表(C#实现)

 
using System;
namespace MyTest
{
 
//节点
    class Node<T>
    {
        public T value;			//值域
        //指针域
        public Node<T> prev;	//前驱指针
        public Node<T> next;	//后继指针
        public Node()		//构造重载
        {
            this.prev = null;
            this.next = null;
        }
        public Node(T v)  	//构造重载
        {
            this.value = v;
            this.prev = null;
            this.next = null;
        }
        public Node(T v, Node<T> p, Node<T> n) //构造重载
        {
            this.value = v;
            this.prev = p;
            this.next = n;
        }
    }
 


 
class MyList<T>		//泛型T
    {
        private Node<T> head;  //头节点
        private Node<T> end;   //尾节点
        private int size;
        //构造函数
        public MyList()
        {
            this.head = null;	//指针置空
            this.end = null;
            this.size = 0;		//长度为0
        }
 



 
// 尾插
        public void push_back(T val)
        {
            Node<T> temp = new Node<T>(val);  //定义新节点 将value作为值域的值
            //如果原链表为空
            if (head == null)
            {
                this.head = temp;	//头结点 尾结点为同一个  
                this.end = temp;
                this.size++;    //个数+1
                return;
            }
            //如果原链表不为空
            this.end.next = temp;	//尾结点的下一个指向新节点
            temp.prev = this.end;	//新节点的前驱指针指向‘原’尾结点
            this.end = this.end.next; // end指向新插入的结点
            //this.end = temp;        // end指向新插入的结点

            this.size++;    //个数+1

        }
 

 
//头插
        public void push_front(T val)
        {
            Node<T> temp = new Node<T>(val);//定义新节点 将value作为值域的值
             //如果原链表为空
            if (head == null)
            {
                this.head = temp;
                this.end = temp;
                this.size++;    //个数+1
                return;
            }
            //如果原链表不为空
            this.head.prev = temp;	//头节点的前驱指针指向新节点
            temp.next = this.head;	//新节点的后继指针指向‘原’头节点
            this.head = temp; // 头部前移

            this.size++; //个数+1
        }
 

 
 //尾删
        public void pop_back()
        {
            //如果链表为空 或者只有一个结点
            if (size <= 1)
            {
                this.Clear();//直接清空链表(clear方法在下方声明) 
                return;
            }
            //如果size>=2
            this.end = this.end.prev; 	//让尾结点前移 
            this.end.next = null;		//尾结点的后继指针滞空  让垃圾回收器回收删除的节点

            this.size--;	//长度--
        }
 


 
 //头删
        public void pop_front()
        {
            //如果链表为空 或者只有一个结点
            if (size <= 1)
            {
                this.Clear();//直接清空链表
                return;
            }
            //size>=2
            this.head = this.end.next;	//让头结点后移 
            this.head.prev = null;		//头结点的前驱指针滞空  让垃圾回收器回收删除的节点

            this.size--;				//长度--
        }
 

//中间插入
        public void Insert(int index, T val)// index从0开始
        {
            if (index > this.size - 1 || index < 0)	//插入的位置小于0 或者大于链表长度
            {
                Console.WriteLine("Error:Invalid Index!");
                return;
            }
            if (index == 0)	//如果为空链表   直接头插(尾插)该节点
            {
                this.push_front(val);
                return;
            }
            Node<T> newNode = new Node<T>(val); // 创建新节点
            Node<T> temp = this.head;			//创建临时节点 用于迭代找到要插入的位置
            for (int i = 0; i < index; i++)
            {
                temp = temp.next;	//后移
            }//循环结束 找到要插入的位置
            //在该位置的前面插入新结点
            newNode.prev = temp.prev; 	//新结点的前驱指向指定位置的前驱
            newNode.next = temp;		//新结点的后继指向指定位置的节点

            temp.prev.next = newNode;	//新结点的前一个节点的后继指向新结点
            temp.prev = newNode;		//指定位置的节点的前驱指向新结点 

        }
 

 //清空链表
        public void Clear()
        {
            if (size == 0) return;   //长度为零 退出函数
            if (size == 1)			//长度为1  将头结点和尾结点置空 
            {
                this.head = this.end = null;
                return;
            }
            Node<T> temp = this.head;
            Node<T> _next = temp.next;
            while (_next != null)
            {
                temp.prev = null;
                temp.next = null;
                temp = _next;
                _next = _next.next;
            }
            temp.prev = null;
            temp.next = null;
            this.head = this.end = null;

            this.size = 0;
        }
 



 //获取节点个数
        public int Size()
        {
            return this.size;
        }
 


//判断是否为空
        public bool Empty()
        {
            if (size == 0)
                return true;
            return false;
        }
 


 
 //输出所有节点
        public void PrintAll()
        {
            Node<T> temp = this.head;
            while (temp != null)
            {
                Console.Write(temp.value + " ");
                temp = temp.next;
            }
            Console.WriteLine();
        }

/索引器
        public T this[int index]
        {

            get			//get访问器
            {
                if (index + 1 > this.size)
                    return (T)new Object();
                Node<T> node = this.head;
                for (int i = 0; i < index; i++)
                {
                    node = node.next;
                }
                return node.value;
            }
            set			//set设置
            {
                Node<T> node = this.head;
                if (index + 1 <= this.size)
                {
                    for (int i = 0; i < index; i++)
                    {
                        node = node.next;
                    }
                    node.value = value;	
                }
                else
                {
                    Console.WriteLine("Error:Invalid Index!");
                }
            }
        }
    }
}