第三章单链表(带有头结点的尾插法实现)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

   /// <summary>
    /// 节点类
    /// </summary>
    /// <typeparam name="T"></typeparam>

在这里插入代码片

    class Node<T>
    {
        private T date; //数据域
        private Node<T> next;//指针域

        public T Date { get => date; set => date = value; }
        internal Node<T> Next { get => next; set => next = value; }

        public Node()
        {
            Next = null;
            Date = default(T);
        }

        public Node(T date,Node<T> next)
        {
            this.Date = date;
            this.Next = next;
        }

        public Node(T date)
        {
            Next = null;
            this.Date = date;
        }
        public Node(Node<T> next)
        {
            this.Date = default(T);
            this.Next = next;
        }
    }
 /// <summary>
    /// 链表类
    /// </summary>
    class LinkList<T>
    {
        private Node<T> head; //头指针
        private int count;  //链表元素个数

        public LinkList()
        {
            head=new Node<T>();//指向头结点
            count = 0;
        }


        //尾插法创建链表
        public LinkList(params T[] list):this()
        {
            Node<T> last = head;
            for (int i = 0; i < list.Length; i++)
            {
                Node<T> newNode = new Node<T>(list[i]);
                last.Next = newNode;
                last = last.Next;
            }
            count = list.Length;
        }
       
      

        //遍历单链表的元素
        public void Traverse()
        {
            Node<T> temp = head;  
            for (int i = 0; i < count; i++)
            {             
                temp = temp.Next;
                Console.Write(temp.Date+"  ");
            }

            Console.WriteLine();
        }

在这里插入代码片

        //判断是否为空
        public bool IsEmepty()
        {
            return head.Next == null;
        }


        //获取链表长度
        public int GetLength()
        {
            return count;
        }


在这里插入代码片
在这里插入图片描述

        //获取元素索引位置
        public int Index(T elem)
        {
            Node<T> temp = head;
            for (int i = 0; i < count; i++)
            {
                temp = temp.Next;
                if (temp.Date.Equals(elem))
                {
                    return i;
                }

            }
             
            Console.WriteLine("elem:{0}不在链表中", elem);
            return -1;
        }


在这里插入代码片
在这里插入图片描述

        //通过索引器获取元素
        public T this[int index]
        {
            get
            {
                if (index>=count||index<0)
                {
                    throw new IndexOutOfRangeException();
                }
                Node<T> temp = head;
                for (int i = 0; i <=index; i++)
                {
                    temp = temp.Next;
                }

                return temp.Date;
            }
        }

在这里插入代码片

        //插入元素
        public void Insert(int index,T elem)
        {
            Node<T> temp = head;
            Node<T> newNode=new Node<T>(elem,null);         
            if (index >= count || index < 0)
            {
                throw new IndexOutOfRangeException();
            }                                 

               //当为空链表的时候
                if (temp.Next == null)
                {
                    temp.Next = newNode;
                    count++;
                  
                }

                else
               {
                 for (int i = 0; i < index; i++)
                  {
                    temp = temp.Next;
                 }
                newNode.Next = temp.Next;
                temp.Next = newNode;
                count++;
               }     
        }



在这里插入代码片

        //删除元素
        public void Delete(int index)
        {
            Node<T> temp = head;
            if (head.Next == null)
            {
                Console.WriteLine("空表无法删除");
            }
            if (index >= count || index < 0)
            {
                throw new IndexOutOfRangeException();
            }
        
            for (int i = 0; i < index; i++)
            {
                temp = temp.Next;
            }

            temp.Next = temp.Next.Next;
            count--;
        }
    }
LinkList<int> sum=new LinkList<int>(1,2,5,8,5,888,555);
            sum.Traverse();
            Console.WriteLine(sum.IsEmepty());
            Console.WriteLine(sum.GetLength());
            Console.WriteLine(sum.Index(8));
            Console.WriteLine(sum[6]);
            //sum.Insert(2, 120);
            //sum.Traverse();
            sum.Delete(100);
            sum.Traverse();
            Console.ReadKey();
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. 经过以下栈运算后,x的值是( )。 InitStack(s); Push(s,'a'); Push(s,'b'); Pop(s,x); Gettop(s,x); A. a B. b C. 1 D. 0 2.循环队列存储在数组A[0..m]中,则入队时的操作为( )。 A.rear=rear+1 B. rear=(rear+1) mod(m-1) C. rear=(rear+1)mod m D. rear=(rear+1) mod(m+1) 3. 栈和队列的共同点是( )。 A.都是先进先出 B.都是先进后出 C.只允许在端点处插入和删除元素 D.没有共同点 4. 若用一个大小为6的数组来实现循环队列,且当 rear 和 front 的值分别为 0 和 3。当从队列中删除一个元素,再插入两个元素后,rear 和 front 的值分别为:( )。 A.1 和 5 B.2 和 4 C.4 和 2 D.5 和 1 5. 程序填顺序循环队列的类型定义如下: typedef int ET; typedef struct{ ET *base; int Front; int Rear; int Size; }Queue; Queue Q; 队列 Q 是否“满”的条件判断为( C )。 A.(Q.Front+1)=Q.Rear B.Q.Front=(Q.Rear+1) C.Q.Front=(Q.Rear+1)% Q.size D.(Q.Front+1) % Q.Size=(Q.Rear+1)% Q.size 6. 若进栈序列为1,2,3,4,进栈过程中可以出栈,则( )不可能是一个出栈序列。 A.3,4,2,1 B.2,4,3,1 C.1,4,2,3 D.3,2,1,4 7. 向顺序存储的循环队列 Q 中插入元素的过程分为三步: ( )。 A.进行队列是否空的判断,存入新元素,移动队指针 B.进行队列是否满的判断,移动队指针,存入新元素 C.进行队列是否空的判断,移动队指针,存入新元素 D.进行队列是否满的判断,存入新元素,移动队指针 8. 关于栈和队列,( )说法不妥。 A. 栈是后进先出表 B. 队列是先进先出表 C. 递归函数在执行时用到栈 D. 队列非常适用于表达式求值的算符优先法 9. 若用数组S[0..m]作为两个栈S1和S2的共同存储结构,对任何一个栈,只有当S全满时才不能作入栈操作。为这两个栈分配空间的最佳方案是( )。 A.S1的栈底位置为0,S2的栈底位置为m B.S1的栈底位置为0,S2的栈底位置为m/2 C.S1的栈底位置为1,S2的栈底位置为m D.S1的栈底位置为1,S2的栈底位置为m/2 二、程序填空题(没特别标注分数的空的为3分,共 23 分)。 1.下面的算法是将一个整数e压入堆栈S,请在空格处填上适当的语句实现该操作。 typedef struct{ int *base; int *top; int stacksize; }SqStack; int Push(SqStack S,int e) { if ( S.top- S.base>= S.stacksize ) { S.base=(int *) realloc(S.base,(S.stacksize+1)*sizeof(int)); if( !S.base ) { printf(“Not Enough Memory!\n”); return(0); } S.top= S.base+ S.stacksize ; S.stacksize= S.stacksize+1 ; } * S.top++=e ; return 1; } 2. 在表达式:6+5+3*7/(4+9/3-2)求值过程中,处理到2时刻,运算符栈的状态为: + / ( - (4分),操作数栈的内容为11,21,7,2(4分)。 3. 递调用时,处理参数及返回地址,要用一种称为 栈 的数据结构。 4. 设循环队列中数组的下标范围是1-n,其头指针分别为f和r,则其元素个数为_(r-f+n) mod n。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值