精华内容
下载资源
问答
  • 在计算机科学中,链表是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针。 链表的优点 由于不必须按顺序存储,链表在插入的时候可以达到O(1)的...

    从博客查看此篇文章
    你好我是久远,我们先来复习一下上周我们讲的知识。

    • 什么是链表?

    在计算机科学中,链表是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针。

    • 链表的优点

    由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比数组快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而顺序表相应的时间复杂度分别是O(logn)和O(1)。使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。

    什么是栈

    栈有时也被称作堆栈或者堆叠。栈是有序集合,它的添加,移除操作总是发生在同一端,设这一端为顶端,则未执行操作的一端为底端。
    栈中的元素离底端越近,代表其在栈中的时间越长,最新添加的元素将被最先移除。这种排序原则被称作 LIFO(last-in first-out),即后进先出。它提供了一种基于在集合中的时间来排序的方式。最近添加的元素靠近顶端,旧元素则靠近底端。

    生活中的例子:

    在我们的生活中也很常见关于栈的例子,假设我们有一个放羽毛球的球桶,我们只能从桶的上面取出球,底部是不能取的,靠近开口的球,更先被取到。

    既然有取出的先后,那么我们的栈也算是有顺序的,我们依旧使用列表来实现栈的一些操作。

    举例来说,对于列表[1, 5, 3, 7, 8, 6],只需要考虑将它的哪一边视为栈的顶端。一旦确定了顶端,所有的操作就可以利用 append 和pop 等列表方法来实现。

    在这里我们视列表的尾部为栈顶,因此当进行 push 操作时,新的元素会被添加到列表的尾部。pop 操作同样会修改这一端。

    栈的操作

    我们前面已经介绍了栈的基本情况,既然我们要实现栈的操作,那我们肯定要新建一个栈,有了这个栈,我们肯定要做一些彰显出栈特性的事情————出栈,入栈。还有我们常见的操作,判断是否为空,判断栈的大小等等。

    以下是我们要实现的方法:

    • Stack()创建一个空栈。不传任何参数,返回空栈。
    • push(item)将一个元素添加到栈的顶端。它需要一个参数 item,且无返回值。
    • pop()将栈顶端的元素移除。它不需要参数,但会返回顶端的元素,并且修改栈的内容。
    • peek()返回栈顶端的元素,但是并不移除该元素。它不需要参数,也不会修改栈的内容。
    • isEmpty()检查栈是否为空。它不需要参数,且会返回一个布尔值。
    • size()返回栈中元素的数目。它不需要参数,且会返回一个整数。

    栈的定义

    class Stack:
        def __init__(self):
            self.items = []
    

    定义一个 stack 类来告诉计算机,我们现在定义了一个全新的类型叫做 stack ,每个类有一个定义方法即 init() ,我们使用 init 方法来定义栈的一些属性。我们新建一个栈,栈中最重要的就是元素,多个元素构成栈,而一开始当我们没有向栈中放入任何元素时,栈是空的,因此有 self.items = [],我们定义了一个空栈来作为栈的初始化。

    栈是否为空

    既然栈存在,我们就可以进行栈有无的判断,我们也像之前的数据结构类型一样,引入 isEmpty() 方法来判断栈中是否有元素,没有元素则为空栈,返回 true ;包含有元素,则说明栈不为空,返回 false。

    def isEmpty(self):
            return self.items == []
    

    栈的大小

    栈的大小实际上就是判断栈中有多少元素,而我们使用列表来进行栈的实现,因此我们只需要使用 len() 方法计算引入的列表的长度即可判断栈中元素的多少了,即栈的大小。

    def size(self):
            return len(self.items)
    

    入栈操作

    现在我们既可以判断栈中是否有元素,又可以判断栈的大小了,那么接下来就要实现栈最主要的两个操作了,入栈和出栈。

    进行入栈操作我们就要想到,既然要把元素加入到栈中,那么我们就要传入一个参数去表示要加入到栈中的元素,然后将这个参数加入到栈中即可。

    def push(self, item):
            self.items.append(item)
    

    我们传入一个 item 参数,为我们要加入到栈中的元素,然后将其加入到我们引入的 items 列表中即可完成栈中元素的加入了。

    出栈操作

    既然有元素加入到栈中,那我们就可以将元素从栈中删除,因此我们有了出栈的操作,出栈操作一般的思维是这样的:我们让栈顶的元素弹出,同时也要告诉大家,我弹出的是哪个元素。

    因此要返回弹出的那个元素。

    代码实现为:

    def pop(self):
            return self.items.pop()
    

    使用列表中的 pop方法,返回列表末尾的那个元素,并将该元素从列表中删除,实现出栈。

    查看栈顶

    我们的栈操作中通常还包含一项查看栈顶元素的操作,因为我们在此将引入的列表末尾视为栈顶,因此我们只需要返回所引入的列表的最后一个元素即可。

    def peek(self):
            return  self.items[len(self.items)-1]
    

    整体的代码如下:

    class Stack:
        def __init__(self):
            self.items = []
        def isEmpty(self):
            return self.items == []
        def size(self):
            return len(self.items)
        def push(self, item):
            self.items.append(item)
        def pop(self):
            return self.items.pop()
        def peek(self):
            return  self.items[len(self.items)-1]
    

    总结

    恭喜你又学完了一个知识点,栈是一个后进先出的数据类型,它有两个非常主要的操作,进栈和出栈:

    • 进栈:将资料放入栈的顶端,栈的顶端移到新放入的资料。
    • 出栈:将堆栈顶端资料移除,堆栈顶端移到移除后的下一笔资料。

    它可以用数组或者链表来实现,而由于 python 的特殊性,我们常使用列表来实现栈的操作。

    与栈相对的有队列,队列是一种先进先出的数据类型,我们下次会进行讲解。

    流沙团队联合AI悦创|久远·推出辅导班啦,包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发」,全部都是一对一教学:一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。QQ、微信在线,随时响应!


    在这里插入图片描述

    展开全文
  • 出栈:指数据的删除操作(出数据也在栈顶)。 栈的实现:一般可以用数组或者链表,但是用数组实现更优一点,因为数组在尾插尾删上的代价较小。 下面,我们来实现支持动态增长的栈: typedef int STData...
    • 首先,栈是一种特殊的线性表,只允许在固定的一端进行插入和删除元素的操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。
      压栈:指数据的插入操作(入数据在栈顶)。
      出栈:指数据的删除操作(出数据也在栈顶)。

    • 栈的实现:一般可以用数组或者链表,但是用数组实现更优一点,因为数组在尾插尾删上的代价较小。

    • 下面,我们来实现支持动态增长的栈:

    typedef int STDataType;
    /top永远指向栈顶元素,top可以反映出栈的元素的个数
    typedef struct Stack{
    	STDataType* _a;
    	int _top;
    	int _capacity;
    }Stack;
    
    /初始化时,可以不给数组开空间,可以直接在插入数据的时候进行数组空间的开辟和增容的考虑
    void StackInit(Stack* ps){
    	assert(ps);
    	ps->_a = NULL;
    	ps->_capacity = 0;
    	ps->_top = 0;
    }
    
    void StackDestory(Stack* ps){
    	assert(ps);
    	free(ps->_a);
    	ps->_capacity = 0;
    	ps->_top = 0;
    }
    
    /增容时要考虑到capacity为0的情况
    /一般以2倍速增容
    void StackPush(Stack* ps, STDataType x){
    	assert(ps);
    	if (ps->_top == ps->_capacity){
    		if (ps->_capacity == 0){
    			ps->_capacity = 10;
    		}
    		else{
    			int newcapacity = 2 * ps->_capacity;
    			ps->_capacity = newcapacity;
    		}
    		/realloc:用来追加数组空间!!!!
    		ps->_a = (STDataType*)realloc(ps->_a,sizeof(STDataType)*ps->_capacity);
    	}
    	ps->_a[ps->_top++] = x;
    }
    
    void StackPop(Stack* ps){
    	assert(ps);
    	/要保证栈里有元素
    	if (ps->_top > 0){
    		ps->_top--;
    	}
    	else{
    		return;
    	} }
    
    /取栈顶元素(千万不要忘了,数组的下标从0开始!!)
    STDataType StackTop(Stack* ps){
    	assert(ps);
    	return ps->_a[ps->_top-1];
    }
    
    int StackEmpty(Stack* ps){
    	assert(ps);
    	if (ps->_top == 0){
    		return 1;
    	}
    	else{
    		return 0;
    	}
    }
    
    int StackSize(Stack* ps){
    	assert(ps);
    	return ps->_top;
    }
    
    void StackPrint(Stack* ps){
    	assert(ps);
    	//非空
    	while (StackEmpty(ps) != 1){
    		printf("%d ", StackTop(ps));
    		StackPop(ps);
    	}
    	printf("\n");
    }
    
    展开全文
  • 顾名思义,栈也就是一个后进先出的一种数据结构。生活中就有很多后进先出的现象,如:一摞盒子,放在最下面的肯定死最先放进去的,但如果要去出来的话却是最后取出来的。 归纳先进后出的现象,可获得栈的非...

    栈(stack)又名堆栈,它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素;从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。

    ------------摘自百度百科。


    顾名思义,栈也就是一个后进先出的一种数据结构。生活中就有很多后进先出的现象,如:一摞盒子,放在最下面的肯定死最先放进去的,但如果要去出来的话却是最后取出来的。


    归纳先进后出的现象,可获得栈的非正式定义如下。

    栈是一个满足如下条件的数据结构。

    (1)数据项一个叠一个呈线性排列;

    (2)所有的插入与删除操作在一段进行;

    (3)最后插入的记录是第一个被删除的记录;

    (4)栈的基本操作有三个:

    ①入栈,压入一个元素或记录到栈顶;

    ②出栈,将栈顶元素或记录移除;

    ③读栈,取出栈顶元素或记录。


    下面给出栈的类定义:

    //Stack in C++
    #include<iostream>
    using namespace std;
    typedef int stackEntry;
    const int maxstack = 100;						//栈的最大尺寸
    class stack 
    {
    public:
    
    	void stack::push(const stackEntry &item)			//如果栈未满,将元素item压入栈顶,否则报错(入栈操作)
    	{
    		if (count >= maxstack)
    			cout << "栈上溢,无法压入元素";
    		else
    			data[count++] = item;
    	}
    
    	void stack::pop()						//如果栈未空,将栈顶元素删除,否则报错(出栈操作)
    	{
    		if (count == 0)
    			cout << "栈下溢,无法弹出元素";
    		else
    			--count;
    	}
    
    	void stack::top(stackEntry &item) const				//如果栈未空,将栈顶元素取出放在item里,否则报错(取出栈顶元素)
    	{
    		if (count == 0)
    			cout << "栈下溢,无法读取元素";
    		else
    			item = data[count - 1];
    	}
    
    	bool stack::empty() const					//判断栈是否为空
    	{
    		if (count > 0)
    			return false;
    		return true;
    	}
    
    	stack::stack()							//构建函数,初始化一个空栈
    	{
    		count = 0;
    	}
    private:
    	int count;							//栈中元素个数的记录
    	stackEntry data[maxstack];					//以连续分配的数组来存放栈元素
    };
    
    


    展开全文
  • 与日常生活中的排队相类似,队列是一种遵循先进先出原则数据结构。本文主要介绍了队列的定义、利用数组实现队列、利用链表实现队列等内容。

    1. 队列(Queue)

    与栈类似,队列也是最基本的数据结构之一。顾名思义,队列中数据的存储与排队相类似,遵循“先进先出”(First-In-First-Out, FIFO)的原则(都是文明人,插队肯定是不允许的,手动狗头)。

    队列的流程

    2. 队列的抽象数据类型(队列ADT)

    方法功能描述
    enqueue(x)若队列未满,则将元素x加到队列末尾,否则报错
    dequeue()若队列非空,则将队列首元素移除,并将其返回,否则报错
    getSize()返回当前队列中元素的数目
    isEmpty()用于检测队列是否为空
    front()若队列非空,则返回队列首元素(但并不移除),否则报错

    3. 队列接口

    /**
    * 队列接口
    */
    public interface Queue {
    	void enqueue(Object obj);
    	Object dequeue() throws ExceptionQueueEmpty;
    	int getSize();
    	boolean isEmpty();
    	Object front() throws ExceptionQueueEmpty;
    }
    

    4. 利用数组实现队列

    4.1 队列的实现

    借助一个定长数组Q来存放对象,即可简单地实现队列。一种自然的办法就是仿照栈的实现,以 Q[0]作为队首,其它对象顺序往后存放。然而如此一来, 每次首元素出队之后,都需要将后续的所有元素向前顺移一个单元⎯⎯若队长为 n,这项工作需要O(n)时间,因此效率很低。

    为了避免数组的整体移动,可以引入两个变量 front 和 rear,分别指向队列的头和尾,使数组构成一个循环结构。

    public class ExceptionQueueEmpty extends RuntimeException {
    	
    	public ExceptionQueueEmpty(String error) {
    		super(error);
    	}
    	
    }
    
    public class ExceptionQueueFull extends RuntimeException {
    
    	public ExceptionQueueFull(String error) {
    		super(error);
    	}
    	
    }
    
    /**
     * 定长数组实现队列
    */
    public class ArrayQueue implements Queue {
    	private static final int CAPACITY = 1024;
    	private int capacity;
    	private Object[] Q;
    	
    	private int front;
    	private int rear;
    	
    	public ArrayQueue() {
    		this(CAPACITY);
    	}
    	
    	public ArrayQueue(int capacity) {
    		this.capacity = capacity;
    		Q = new Object[this.capacity];
    		front = 0;
    		rear = 0;
    	}
    
    	@Override
    	public void enqueue(Object obj) throws ExceptionQueueFull {
    		// 数组只剩下一个空闲单元时就判定队列已满(如数组满则front与rear相等),(front == rear) is true用于判定队列空
    		if ((capacity - 1) == getSize()) {
    			// 对于容量有限的队列需要考虑队列溢出的情况
    			throw new ExceptionQueueFull("意外:队列溢出");
    		}
    		Q[rear] = obj;
    		// 利用取余数实现数组的循环
    		rear = (rear + 1) % capacity;
    	}
    
    	@Override
    	public Object dequeue() throws ExceptionQueueEmpty {
    		if (isEmpty()) {
    			throw new ExceptionQueueEmpty("意外:队列空");
    		}
    		Object returnElement = Q[front];
    		Q[front] = null;
    		front = (front + 1) % capacity;
    		return returnElement;
    	}
    
    	@Override
    	public int getSize() {
    		return ((capacity + rear - front) % capacity);
    	}
    
    	@Override
    	public boolean isEmpty() {
    		return (front == rear);
    	}
    
    	@Override
    	public Object front() throws ExceptionQueueEmpty {
    		if (isEmpty()) {
    			throw new ExceptionQueueEmpty("意外:队列空");
    		}
    		return Q[front];
    	}
    
    }
    

    4.2 利用数组实现队列的优势与缺点

    1. 优势:
      1) 实现简单
      2) 各方法的时间复杂度均为O(1)
    2. 缺点:
      1) 若数组容量为N,则空间复杂度为O(N),在队列中的元素较少时会造成空间的浪费
      2) 入队操作会有溢出的风险

    5. 利用单链表实现队列

    由于队列只在队首才有出队(需删除元素)操作,因此只需要让单链表的头节点为队首,末节点为队尾,即可高效的实现队列这一数据结构(单链表删除末节点的时间复杂度是O(n))。

    5.1 队列的实现

    /**
     * 单链表节点类
    */
    public class Node {
    	private Object element; // 数据对象
    	private Node next; // 指向后继节点
    	
    	public Node() {
    		this(null, null);
    	}
    	
    	public Node(Object element, Node next) {
    		this.element = element;
    		this.next = next;
    	}
    	
    	public Object getElement() {
    		return element;
    	}
    	
    	public Object setElement(Object element) {
    		Object oldElememt = element;
    		this.element = element;
    		return oldElememt;
    	}
    	
    	public Node getNext() {
    		return next;
    	}
    	
    	public void setNext(Node newNext) {
    		next = newNext;
    	}
    }
    
    /**
     * 利用单链表实现队列
    */
    public class LinkedListQueue implements Queue {
    	private Node head;
    	private Node tail;
    	private int size; // 队列中元素的数目
    	
    	public LinkedListQueue() {
    		head = null;
    		tail = null;
    		size = 0;
    	}
    
    	@Override
    	public void enqueue(Object obj) {
    		Node tailNode = new Node(obj, null);
    		// 若此前队列为空,则直接插入
    		if (0 == size) {
    			head = tailNode;
    			tail = tailNode;
    		} else {
    			tail.setNext(tailNode);
    			tail = tailNode;
    		}
    		size++;
    	}
    
    	@Override
    	public Object dequeue() throws ExceptionQueueEmpty {
    		if (isEmpty()) {
    			throw new ExceptionQueueEmpty("意外:队列空");
    		}
    		Object returnElement = head.getElement();
    		head = head.getNext();
    		size--;
    		// 如果出队后,队列已空,需将末节点置空
    		if (isEmpty()) {
    			tail = null;
    		}
    		return returnElement;
    	}
    
    	@Override
    	public int getSize() {
    		return size;
    	}
    
    	@Override
    	public boolean isEmpty() {
    		return (size == 0);
    	}
    
    	@Override
    	public Object front() throws ExceptionQueueEmpty {
    		if (isEmpty()) {
    			throw new ExceptionQueueEmpty("意外:队列空");
    		}
    		return head.getElement();
    	}
    
    }
    

    5.2 利用单链表实现队列的优势与缺点

    1. 优势:
      1) 队列中实际有n个元素,空间复杂度即为O(n),空间利用效率较高
      2) 入队操作不会有溢出的风险
    2. 缺点:
      1) 较数组实现来说,再实现的复杂度上略有增加
      2) 需要有一个变量由于记录队列中元素的数目

    6.队列的应用

    队列的应用十分广泛,无论是商店、剧院、机场还是银行、医院,凡是按照“先到的客户优先接受服务”原则的场合,都可以利用队列这一数据结构来编排相应的服务。

    7. 双端队列

    双端队列是队列的一种变型,顾名思义,就是前端与后端都支持插入和删除操作的队列,它可以利用链表来实现。但由于双端队列两端都有删除操作,如果使用单链表来实现的话,总会有一端的删除操作的时间复杂度为O(n)。

    造成此现象的原因是,只有找到末节点的直接前驱节点(末节点的前一个节点)之后,才能对末节点实施删除操作。对于单链表,一节点并不能直接访问它的前一个节点,所以想要找到末节点的直接前驱节点必须进行一次遍历,即时间复杂度为O(n)。

    解决此问题的一个有效的方法是选用双向链表来实现。双向链表的节点都可以直接访问到它的前驱节点和后驱节点,故对于两端点的删除操作,时间复杂度也仅为O(1)。

    利用双向链表实现双端队列与单链表实现队列类似,此处不再赘述。

    展开全文
  • 1、栈是一种先进后出的顺序表,和顺序表的区别是:顺序表可以操作任意元素,但是栈只能对栈顶元素进行操作,即后进先出原则。 2、栈的操作就只有入栈和出栈两个。 3、实现入栈和出栈 栈的栈顶用top标识,入栈时...
  • 栈是一种遵循先进后出原则数据结构,在实际开发中有着广泛的应用(例如Java虚拟机中的操作数栈)。本文主要介绍了栈的定义、利用数组实现栈、利用链表实现栈等内容。
  • 1.“后进先出,先进后出”的数据结构。2.从操作特性来看,是一种“操作受限”的线性表,只可以在一端插入和删除数据。&#13;  &#13; 二、为什么需要栈?&#13;  &#13; 1.任何数据结构都是对特定应用...
  • 栈--后进先出的线性表

    千次阅读 2020-06-11 20:49:23
    具体而言,栈的数据结点必须后进先出。 宏观上来看,与数组或链表相比,栈的操作更为受限,那为什么我们要用这种受限的栈呢?其实,单纯从功能上讲,数组或者链表可以替代栈。然而问题是,数组或者链表的操作过于...
  • 展开全部1、栈32313133353236313431303231363533e58685e5aeb931333365643662中的“先进后出,后进先出”意思是:栈的概念是弹压,就像子弹壳装弹,一粒一粒压进去,但是打出来的时候是从上面打出来的,最先压进去的最后弹...
  • 栈是一种常用的数据结构,在生活中经常遇到这样的例子,如铁路调度站。本节将详细介绍堆栈的实现过程。算法点拨(顺序栈)栈是一种重要的数据结构。从数据结构的角度看,栈也是线性表,其特殊性在于栈的基本操作是...
  • 栈的修改是按后进先出原则进行的,栈又称为后进先出的线性表。 链栈是指采用链式存储结构实现的栈。通常链栈用单链表来表示,链栈的结点结构与单链表的结构相同,在此用StackNode 表示。链栈有着初始化、入栈、...
  • ④乘客上下电梯时先出后进。进电梯时乘客是按发出乘坐请求的顺序依次进入,每次只能进入一人且每个人花费的时间都为25t; ⑤电梯在关门期间(电梯离开之前)所在层提出请求的乘客同样允许进入。 (5)按时序显示...
  • 后进先出 C. 栈空则进 D. 栈满则出 8、设单链表中结点结构为(data, next) ,若想摘除结点*p的直接后继,则应执行下列哪一个操作( ) A.p-> next =p-> next -> next; B.p=p-> next; p-> next =p-> next -> next;...
  • 数据结构】栈

    多人点赞 热门讨论 2021-10-30 13:25:55
    栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则 图片即可解释,凡是具有LIFO特征的问题都可以运用栈的数据结构和思维来求解。 压栈:栈的插入操作叫做进栈/压栈/入栈,进入的数据在栈顶 出栈:栈的...
  • 这种排序原则被称作 LIFO(last-in first-out),即后进先出。它提供了一种基于在集合中的时间来排序的方式。最近添加的元素靠近顶端,旧元素则靠近底端。 栈的重要操作 栈中最重要的两个操作是出栈和入栈,我们在...
  • 如何选择数据结构

    2021-04-17 17:09:39
    数据结构类型 1.数组(Array): 数组是存储在连续内存位置的项目的集合。这个想法是将相同类型的多个项目存储在一起。通过简单地将偏移量添加到基本值(即数组的第一个元素的存储位置)(通常由数组的名称表示),这...
  • 数据结构:栈与队列

    2019-08-22 17:30:47
    栈的原则后进先出,即插入与删除元素均在栈顶进行。 (获取栈顶元素:s.top()) 队列的原则是先进先出,即插入数据在队尾进行,删除数据在队头进行。 (获取队头元素:q.front()) 用两个栈实现一个队列 ...
  • 后进先出”的栈

    2014-08-22 22:37:46
    栈的修改遵循后进先出原则,因此栈又称为后进先出的线性表,简称LIFO结构。 栈一般采用数组作为其存储结构,这样做可以避免使用指针,简化程序,当然数组需要预先声明静态数据区的大小,但这不是问题,因为即便是...
  • 数据结构知识整理

    万次阅读 多人点赞 2018-07-30 18:50:47
    1.数据结构:是一门研究非数值计算的程序设计问题中计算机的操作对象以及他们之间的关系和操作等的学科。 2.数据结构涵盖的内容: 3.基本概念和术语: 数据:对客观事物的符号表示,在计算机科学中是指所有能...
  • 王道考研数据结构笔记

    万次阅读 多人点赞 2021-04-15 22:43:48
    ##2022王道考研数据结构笔记 第二章 线性表(更新中) 我也看得太慢了吧sos 2.1 线性表的定义和基本操作 要点: 线性表的基本操作——创销、增删、改查 传入参数时,何时要用引用 & 2.2 线性表的顺序表示 ...
  • 专升本计算机综合-数据结构

    千次阅读 2021-04-09 23:09:05
    数据结构数据结构是数据的组织形式,可以用来表征特定的对象数据。在计算机程序设计中,操作的对象是各式各样的数据,这些数据往往拥有不同的数据结构,例如数组、结构体、指针和链表等。 数据结构+算法+程序...
  • c语言数据结构

    千次阅读 2020-07-25 14:42:12
    一、数据结构构造概述 1.1、什么是数据结构 数据结构是计算机存储,管理数据的方式。数据必须依据某种逻辑联系组织在一起存储在计算机内,数据结构研究的就是这种数据的存储结构和数据的逻辑结构。 二、线性表 ...
  • 专升本数据结构复习

    千次阅读 多人点赞 2021-03-03 13:48:51
    数据结构知识点总汇 主要参考书目: 程海英老师的《数据结构(C语言版)》教材 严蔚敏,李冬梅,吴伟民.《数据结构(C语言版)》 说明:这是本人专升本上岸一年后写的,本篇包含知识点和例题总结。因为是当时自己...
  • JS中数据结构之栈

    2020-10-17 13:47:14
    栈是一种遵从后进先出(LIFO)原则的有序集合。新添加的或待删除的元素都保存在栈末尾,称作栈顶,另一端称作栈底。在栈里,新元素都靠近栈顶,旧元素就接近栈底。
  • 数据结构(计算机存储、组织数据方式) 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率。...
  • 数据结构

    万次阅读 2018-02-07 00:47:38
    1. 什么是数据结构算法+数据结构=程序设计 数据结构是由数据和结构两方面组成,下面举一个例子可以让大家很快地理解数据结构:比如我们实验楼的课程管理系统,每一门课程由课程号、课程名、类别、作者等组成,每门...
  • 面试题:常见的数据结构的优缺点?(数据结构+算法) 解答:https://blog.csdn.net/Yuyh131/article/details/83629606 数据结构:简单地说,数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定...
  • 数据结构名词解释以及简答

    万次阅读 多人点赞 2020-05-20 23:28:52
    数据结构:是相互之间存在一种或多种特定关系的数据元素的集合,是计算机存储和数据组织的方式,它分为三个方面,即数据的逻辑结构,数据的物理结构,数据的操作。 数据项:是数据不可分割的最小单位,用它可以...
  • 什么是数据结构

    千次阅读 2019-06-19 20:25:39
    什么是数据结构数据结构是什么? 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率。数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,534
精华内容 4,613
关键字:

后进先出原则数据结构

数据结构 订阅