第十五天作业

老郭 · 发表于 2019-4-19 16:33:55

今日学习内容

15.1 栈的基本概念动手实现一个栈

15.2 FCL中的栈类使用 - 栈练习 - 匹配符号

15.3 队列的基本概念 - 动手实现一个顺序队列

15.4 动手实现链表队列 - 顺序队列与链表队列的区别

今日作业:

栈是一种___的结构?
请实现一个链表栈(泛型)
队列是一种___的结构?
顺序队列与链表队列的区别?

Sunny安慕希 · 发表于 2019-6-10 23:08:16

66666666666666666666666666

鱼塘是我的 · 发表于 2019-6-10 14:14:54

本帖最后由鱼塘是我的于 2019-6-10 14:19 编辑

[md]- 今日作业:

栈是一种___的结构?
- 栈是一种先进后出的结构
队列是一种___的结构?
- 队列是一种先进先出的结构
顺序队列与链表队列的区别?
- 顺序队列优点是访问速度快，缺点是插入、删除耗时
- 链表队列是节点的集合，优点是插入、删除快，访问速度不及循序存储,因为访问每一个成员都需要一个节点一个节点······
请实现一个链表栈(泛型)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Say {
    class Program {
        static void Main (string[] args) {
            LinkStark<char> stack = new LinkStark<char> ();
            stack.Push ('a');
            stack.Push ('b');
            stack.Push ('c');
            Console.WriteLine ("push后的数据个数" + stack.Count);
            char temp = stack.Pop ();
            Console.WriteLine ("pop 之后数据是：" + temp);
            Console.WriteLine ("pop 之后数据个数" + stack.Count);
            char temp2 = stack.Peek ();
            Console.WriteLine ("Peek 之后数据是：" + temp2);
            Console.WriteLine ("Peek 之后数据个数" + stack.Count);
        }
    }
    class Node<T> {
        private T data;
        private Node<T> next;
        public Node () {
            data = default (T);
            next = null;
        }
        public Node (T data) {
            this.data = data;
            next = null;
        }
        public Node (T data, Node<T> index) {
            this.data = data;
            this.next = index;
        }
        public Node (Node<T> index) {
            data = default (T);
            next = index;
        }
        public T Data {
            get { return data; }
            set { data = value; }
        }
        public Node<T> Next {
            get { return next; }
            set { next = value; }
        }
    }

    class LinkStark<T> {
        private Node<T> top;
        private int count = 0;
        public int Count {
            get {
                return count;
            }
        }
        public void Clear () {
            count = 0;
            top = null;
        }
        public int GetLength () {
            return Count;
        }
        public bool IsEmpty () {
            return count == 0;
        }
        public T Peek () {
            return top.Data;
        }
        public T Pop () {
            T data = top.Data;
            top = top.Next;
            count--;
            return data;
        }
        public void Push (T item) {
            Node<T> newNode = new Node<T> (item);
            newNode.Next = top;
            top = newNode;
            count++;
        }

        internal interface IStackDS<T> { }
    }

}

曜石头 · 发表于 2019-5-4 21:00:34

1、栈是一种___的结构?
只有一个口用于进出所以后进先出

2、请实现一个链表栈(泛型)
class Node{
public T Data { get; set; }
public Node Next { get; set; }
public Node(T data){
            this.Data = data;
            this.Next = null;
         }
}
class LinkStack{
private Node<T> _top;
private int _count = 0;
public int Count{get { return _count; }}
public void Enqueue(T item){
            Node newNode = new Node(item);
            if (Count == 0){
Top = newNode;
_count = 1;
            }
            else{
newNode.Next = Top;
Top = newNode;
_count++;
            }
}
public T Dequeue(){
            if (Count == 0) return default(T);
            else {
Node temp = Top;
Top = Top.Next;
_count--;
return temp.Data;
            }
      }
}

3、队列是一种___的结构?
先进先出

4、顺序队列与链表队列的区别?
顺序存储的有点在于访问上速度特别快 , 缺点的话就是在插入或删除成员时特别耗时
链表的话是节点的集合,在插入或删除数据时效率较高在访问效率上不及循序存储,因为访问每一个成员都需要一个节点一个节点，
但如果遵讯队列和栈的原则，存储好第一个和最后一个位置访问无需访问每一个，在队列这一块效率不比数组差

课上还有个小瑕疵
string str = "30*(20+30)/(30+(20-3))";
foreach (var item in str){
if (item == '(') s1.Push(1);
if (item == ')') s1.Pop();
}
如果字符串中先多个）右括号会直接报异常，这个不好，加个判断不要出异常
foreach (var item in str){
if (item == '(') s1.Push(1);
if（s1.count!=0）if (item == ')') s1.Pop();
}

曜石头 · 发表于 2019-5-4 19:50:06

发现一个问题在15.3
      SeqQueue<string> q = new SeqQueue<string>();
         q.Enqueue("1");
         q.Enqueue("2");
      Console.WriteLine(q.Dequeue());
         Console.WriteLine(q.Dequeue());
         q.Enqueue("3");
         q.Enqueue("4");
         q.Enqueue("5");
         q.Enqueue("1");
         q.Enqueue("2");
         Console.WriteLine(q.Dequeue());
         Console.WriteLine(q.Dequeue());
         Console.WriteLine(q.Dequeue());
         Console.WriteLine(q.Dequeue());
         Console.WriteLine(q.Dequeue());
         q.Enqueue("3");
         q.Enqueue("4");
         q.Enqueue("5");
         Console.WriteLine(q.Dequeue());
         Console.WriteLine(q.Dequeue());
         Console.WriteLine(q.Dequeue());
主程序这么写就会发现队列并不是先进先出，趁老师生病找老师毛病

夜鬼 · 发表于 2019-4-20 11:33:24

qingshanlushui 发表于 2019-4-20 10:40
1、栈是一种___的结构?
先进后出

真好

qingshanlushui · 发表于 2019-4-20 10:40:57

本帖最后由 qingshanlushui 于 2019-4-20 10:42 编辑

1、栈是一种___的结构?
先进后出

2、请实现一个链表栈(泛型)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 链表栈的实现
{
class Program
{
      static void Main(string[] args)
      {
         LinkStack linkstack = new LinkStack();
         linkstack.Enqueue("1");
         linkstack.Enqueue("2");
         linkstack.Enqueue("3");
         linkstack.Enqueue("4");
         linkstack.Enqueue("5");
         linkstack.Enqueue("6");
         linkstack.Enqueue("7");
         linkstack.Enqueue("6");
         linkstack.Enqueue("7");
         linkstack.Enqueue("6");
         linkstack.Enqueue("7");
         linkstack.Enqueue("6");
         linkstack.Enqueue("7");
         linkstack.Enqueue("6");
         linkstack.Enqueue("7");
         linkstack.Enqueue("6");
         linkstack.Enqueue("7");
         int len = linkstack.Count;
         for (int i = 0; i < len; i++)
         {
            Console.WriteLine(linkstack.Dequeue());
         }
         Console.Read();
      }
      class Node
      {
         public T Data { get; set; }
         public Node Next { get; set; }
         public Node(T data)
         {
            this.Data = data;
            this.Next = null;
         }
      }
      class LinkStack
      {
         public Node Top { get; set; }
         private int _count = 0;
         public Node First { get; set; }
         public int Count
         {
            get { return _count; }
         }
         ///

         /// 加入新的节点
         ///
         ///
         public void Enqueue(T item)
         {
            Node newNode = new Node(item);
            if (Count == 0)
            {
                  Top = newNode;
                  First = newNode;
                  _count = 1;
            }
            else
            {
                  Top.Next = newNode;
                  Top = newNode;
                  ++_count;
            }
         }
         ///
         /// 删除最新节点
         ///
         ///
         public T Dequeue()
         {
            if (Count == 0)
            {
                  return default(T);
            }
            else if (Count == 1)
            {
                  Node temp = First;
                  Top = First = null;
                  _count = 0;
                  return temp.Data;
            }
            else{
                  Node temp1 = First;
                  Node temp2 = null;
                  //Node temp3 = null;
                  while (temp1.Next != null){
                     temp2 = temp1;
                     temp1 = temp1.Next;
                  }
                  temp2.Next = null;
                  --_count;
                  return temp1.Data;
            }
         }
      }
}
}

3、队列是一种___的结构?
先进先出

4、顺序队列与链表队列的区别?
顺序队列一次性分配固定的空间，效率较高，基于数组的，长度也是固定的。

链表队列基于链表的，要动态创建和删除节点，效率较低，但是可以动态增长。

		自动登录	找回密码
密码			注册

[C#作业] 第十五天作业

评分

点评

评分