数据结构和算法基础（1）——数组、队列、链表和栈

最新推荐文章于 2023-05-30 12:03:20 发布
最新推荐文章于 2023-05-30 12:03:20 发布
阅读量646 收藏 2
点赞数 2
分类专栏： 数据结构和算法 文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51114283/article/details/121330233
版权

一. 分类

数据结构包括线性结构和非线性结构。
线性结构

  1. 线性结构作为最常用的数据结构，其特点是数据元素直接存在一对一的线性关系。
  2. 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。
  3. 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。
  4. 链式存储的线性表称为链表，链表中存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
  5. 线性结构包括：数组，队列，链表和栈。

非线性结构
非线性结构包括：二维数组，多维数组，广义表，数结构，图结构。

二、稀疏数组（Sparse Array）

经典的棋盘存取问题

请添加图片描述
一个棋盘，通过横坐标和纵坐标可以唯一的确定棋盘上的点，通过给棋子不同的值，可以将棋子分为不同的阵营。所以当需要存取时，我们可以通过二维数组来保存这个棋盘。

int[][] checkerboard = new int[15][15];
checkerboard[4][5] = 1;
checkerboard[4][6] = 1;
checkerboard[5][6] = 2;
checkerboard[7][5] = 2;
checkerboard[7][7] = 1;

可以发现，二维数组虽然解决了这个需求，但是造成了较多的空间浪费，所以使用稀疏数组来存储。

稀疏数组

当一个数组中大部分元素是0，或者是一个相同的值，或者分布不是很紧密时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式为：

  • 稀疏数组第0行，记录原数组一共有几行几列以及不同值的数量。
  • 其余每一行存储每个点位的信息。

将上面的二维数组转为稀疏数组存储为如下所示。

int[][] checkerboard = new int[6][3];
checkerboard[0][0] = 15;
checkerboard[0][1] = 15;
checkerboard[0][2] = 5;

checkerboard[1][0] = 4;
checkerboard[1][1] = 5;
checkerboard[1][2] = 1;

checkerboard[2][0] = 4;
checkerboard[2][1] = 6;
checkerboard[2][2] = 1;

checkerboard[3][0] = 5;
checkerboard[3][1] = 6;
checkerboard[3][2] = 2;

checkerboard[4][0] = 7;
checkerboard[4][1] = 5;
checkerboard[4][2] = 2;

checkerboard[5][0] = 7;
checkerboard[5][1] = 7;
checkerboard[5][2] = 1;

三、队列

  队列是一种特殊的线性表，特殊在它只允许表的前端（front，队头）进行删除操作，在表的后端（rear，队尾）进行插入操作。最早进入队列的元素最先从队列删除，故又称队列为先进先出（FIFO）线性表。

顺序队列

  顺序队列结构采用一片连续的存储空间，并设置两个指针管理。头指针front指向队头元素，尾指针rear，指向下一个入队元素的位置。
  操作规则为：只有队尾能插入元素，每插入一个元素rear增1；只有队头能删除一个元素，front增1。当front = rear时，队列中没有任何一个元素，为空队列。当rear大于数组长度时，队列无法再插入新元素。
  溢出现象：当队列为空时，做出队运算产生下溢现象。当队列满时，做进队操作，产生真上溢现象。当队列没满，但是头指针只增不减，超出上限时，产生假上溢现象。
顺序队列存在的问题:
顺序队列被删掉的元素位置无法在被使用，头指针值增不减无法复用空间，造成空间浪费。

循环队列

无论插入或删除，一旦rear或front指针增1时超过了所分配的队列空间，就让它指向起始位置。
在循环队列中，当队列为空时，front=rear。当队列满时，front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储时，队列就已经满了。

  1. 循环队列的判空条件为front=rear
  2. 判满条件为front = (rear + 1) % MaxSize
    当尾指针指向头指针前一个地址时，队列就满了。所有rear + 1就是头指针的下标，%MaxSize还是头指针的下标。
  3. 队列有效数据长度为(rear-front + MaxSize) % MaxSize

循环队列实现代码

class CircleArray{
	private int maxSize;  // 表示数组的最大容量
	private int front;  
	private int rear;
	private int[] arr;  // 用于存放数据

	public CircleArray(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[maxSize];
		front = 0;
		rear = 0;
	}

	public boolean isFull() {
		return (rear + 1)%maxSize == front;
	}

	public boolean isEmpty() {
		return rear == front;
	}

	public void addQueue(int n) {
		if (isFull()) {
			System.out.println("队列已满")
			return;
		}
		arr[rear] = n;
		rear = (rear + 1)%maxSize;
	}
	
	public int getQueue(int n) {
		if (isEmpty()) {
			System.out.println("队列为空")
			return;
		}
		int temp = arr[front];
		front = (front + 1)%maxSize;
		return temp ;
	}

	public void showQueue(){
		if (isEmpty()) {
			System.out.println("队列为空")
			return;
		}
		for (int i = front;i < front + size();i++) {
			System.out.printf("arr[%d] = %d\n",i%maxSize,arr[i%maxSize])
		}
	}

	public int headQueue(){
		if (isEmpty()) {
			System.out.println("队列为空")
			return;
		}
		return arr[front];
	}
}

四、链表

  1. 链表在内存中不是连续的，而是通过指针将一系列不连续的内存联系起来。
  2. 链表是由结点构成。每个结点包含data域和next域。
  3. 链表的插入删除元素相较数组较为简单，不需要移动元素，且较为容易实现长度扩充。但是寻找某个元素较为困难。
  4. 链表分为带头结点的链表和没有头结点的链表，根据实际需求来确定。

1. 单向链表

单向链表的结点被分成两部分，一部分是保存或显示关于节点的信息的信息域，第二部分存储下一个节点地址的指针域，而最后一个节点则指向一个空值。
单向链表中有一个head指针，称为表头结点，指向第一个节点。

2. 单向链表练习题

  1. 求单链表中有效结点的个数。
// head为头结点
public int length(Node head) {
	if (head.next == null) {
		return 0;
	}
	int length = 0;
	CurrentNode cur = head.next;
	while (cur != null) {
		length++;
		cur = cur.next;
	}
	return length;
}
  1. 查找单链表中的倒数第k个结点

/* 
	① 求出单链表的长度
	② 得出正数第temp结点
	③ 取出第temp结点
*/
public Node findNode(Node head,int num) {
	if (head.next == null) {
		return null;
	}
	int length = 0;
	CurrentNode cur = head.next;
	while (cur != null) {
		length++;
		cur = cur.next;
	}
	int temp = length - num;
	if (temp <= 0 || temp > length) {
		return  null;
	}
	cur = head.next;
	for (int i = 0; i < temp; i++) {
		cur = cur.next;
	}
	return cur;
}
  1. 单链表的反转
public void reverse(Node head) {
	if (head.next == null || head.next.next == null) {
		return ;
	}
	Node revNode = new Node();
	Node temp = null;
	CurrentNode cur = head.next;
	while (cur != null) {
		temp = cur.next;
		cur.next = revNode.next;
		revNode.next = cur ;
		cur = temp;
	}
	head.next = revNode.next;
}
  1. 从头到尾打印单链表
    方式一：先将单链表进行反转操作，然后再遍历即可。这样做的问题是会破坏原来单链表的结构，不建议。
    方式二： 压栈出栈
  2. 合并两个有序单链表，合并之后的链表依然有序。

3. 双向链表

每个数据节点都有两个指针，分别指向直接后继和直接前驱。所以双向链表任意一个节点开始，都可以很方便地访问前驱后继。

4. 环形链表

链表是单向链表，并且最后一个节点next指针指向了第一个节点，这种链表结构就是单向环形链表，用于解决约瑟夫问题。同理也有双向环形列表
一般我们创建的是没有头结点的单向环形链表，但是会有头指针。
头指针：

  • 头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针
  • 头指针具有标识作用，所以头指针冠以链表的名字（指针变量的名字）
  • 无论链表是否为空，头指针均不为空
  • 头指针是链表的必要元素

头结点：

  • 头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义（但也可以用来存放链表的长度）
  • 有了头结点，对在第一元素结点前插入结点和删除第一结点起操作与其它结点的操作就统一了
  • 头结点不一定是链表的必要元素

头结点我们需要创建一个head结点，然后head.next指向第一个元素。头结点在链表当中。
头指针不需要创建一个单独的节点，直接指向第一个元素。头指针不在当前链表中。

5. 约瑟夫问题

Josephu问题：
设编号为1,2，3，…n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，他的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列位置，由此产生一个出队的编号序列。

public class Josephu {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.create(5);
        circleSingleLinkedList.show();
        circleSingleLinkedList.count(1,2,5);
    }
}

class CircleSingleLinkedList {
    // 头指针
    private JosephuNode first = null;

    // 根据链表长度创造环形链表
    public void create (int nums) {
        if (nums < 1) {
            System.out.println("nums的值不正确");
        }
        JosephuNode cur = null;
        for (int i = 1; i <= nums; i++) {
            // 创造新结点
            JosephuNode node = new JosephuNode(i);
            if (i == 1) {
                // 链表为空
                first = node;
                first.setNext(node);
                cur = first;
            } else {
                // 链表不为空
                cur.setNext(node);
                node.setNext(first);
                cur = node;
            }
        }
    }
    public void show () {
        if (first == null) {
            System.out.println("链表为空");
        }
        JosephuNode cur = first;
        while (true) {
            System.out.println("结点的编号为:" + cur.getNo());
            if (cur.getNext() == first) {
                break;
            }
            cur = cur.getNext();
        }
    }

    /**
     * 解决约瑟夫问题方法
     * @param startNo 开始叫号的编号
     * @param step  叫几个号
     * @param size 队列中有多少个元素
     */
    public void count(int startNo , int step, int size) {
        if (first == null || startNo < 1 || startNo > size) {
            System.out.println("输入参数有问题");
        }
        JosephuNode pre = null;
        JosephuNode cur = first;
        while (true) {
            if (cur.getNext() == first) {
                pre = cur;
                break;
            }
            cur = cur.getNext();
        }
        // pre永远是first元素的前一个元素，first元素指向被叫到的元素
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            pre = pre.getNext();
        }
        while (true) {
            if (pre == first) {
                break; // 当只有一个节点时，pre=first
            }
            for (int i = 0; i < step - 1; i++) {
                first = first.getNext();
                pre = pre.getNext();
            }
            System.out.println("出列的元素为：" + first.getNo());
            first = first.getNext();
            pre.setNext(first);
        }
        System.out.println("最后一个元素为：" + first.getNo());
    }

}

class JosephuNode {
    private int no;
    private JosephuNode next;

    public JosephuNode(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public JosephuNode getNext() {
        return next;
    }

    public void setNext(JosephuNode next) {
        this.next = next;
    }
}

五、栈

1.定义

栈的英文为stack，栈是一个先入后出（FILO,first in last out）的有序列表。
栈是限制线性表中元素的插入和删除只能在线性表的同一断进行的一种特殊线性表。允许插入和删除的一段，称为栈顶，另一端为固定的一段，称为栈底。
最先放入栈中的元素在栈底，最后放入的元素在栈顶。

2.数组模拟栈

public class ArrayStack {

    public static void main(String[] args) {
        ArrayStack arrayStack = new ArrayStack(6);
        boolean flag = true;
        Scanner scanner = new Scanner(System.in);
        while (flag) {
            String key = scanner.next();
            switch (key) {
                case "push" :
                    int value = scanner.nextInt();
                    arrayStack.push(value);
                    break;
                case "pop" :
                    try {
                        System.out.println(arrayStack.pop());
                    } catch (RuntimeException e) {
                        System.out.println("栈已空");
                    }
                    break;
                case "show" :
                    arrayStack.show();
                    break;
                case "exit" :
                    flag = false;
                    break;
                default:
                    System.out.println("命令输入错误");
                    break;
            }
        }
        System.out.println("退出成功");
    }

    private int maxSize;
    private int top;
    private int[] stack;

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        this.stack = new int[maxSize];
        this.top = -1;
    }

    public boolean isFull() {
        return top == maxSize - 1;
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public void push(int value) {
        if (isFull()) {
            System.out.println("栈已满");
            return;
        }
        stack[++top] = value;
    }

    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈已空");
        }
        return stack[top--];
    }

    public void show() {
        if (isEmpty()) {
            System.out.println("栈已空");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d] = %d",i,stack[i]);
        }
    }
}

3.单向链表模拟栈

单向链表一般是有头结点的，应为栈中有栈顶指针。所以我采用无头结点的单向链表，不过有头指针。

public class LinkedListStack {

    public static void main(String[] args) {
        LinkedListStack linkedListStack = new LinkedListStack(5);
        boolean flag = true;
        Scanner scanner = new Scanner(System.in);
        while (flag) {
            String key = scanner.next();
            switch (key) {
                case "push" :
                    int value = scanner.nextInt();
                    linkedListStack.push(value);
                    break;
                case "pop" :
                    try {
                        System.out.println(linkedListStack.pop());
                    } catch (RuntimeException e) {
                        System.out.println("栈已空");
                    }
                    break;
                case "show" :
                    linkedListStack.show();
                    break;
                case "exit" :
                    flag = false;
                    break;
                default:
                    System.out.println("命令输入错误");
                    break;
            }
        }
        System.out.println("退出成功");
    }

    private LinkedListStackNode first;
    private int size;
    private int maxSize;

    public LinkedListStack(int maxSize) {
        this.first = null;
        this.size = 0;
        this.maxSize = maxSize;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size == maxSize;
    }

    public void push(int num) {
        if (isFull()) {
            System.out.println("栈已满");
            return;
        }
        LinkedListStackNode newNode = new LinkedListStackNode(num);
        newNode.next = first;
        first = newNode;
        size++;
    }

    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈已空");
        }
        int data = first.getData();
        first = first.next;
        size--;
        return data;
    }

    public int size() {
        return size;
    }

    public void show() {
        if (isEmpty()) {
            System.out.println("栈已空");
            return;
        }
        LinkedListStackNode cur = first;
        while (true) {
            System.out.println(cur.getData());
            if (cur.getNext() == null) {
                break;
            }
            cur = cur.getNext();
        }
    }

    class LinkedListStackNode {
        private int data;
        private LinkedListStackNode next;

        public LinkedListStackNode(int data) {
            this.data = data;
        }

        public int getData() {
            return data;
        }

        public void setData(int data) {
            this.data = data;
        }

        public LinkedListStackNode getNext() {
            return next;
        }

        public void setNext(LinkedListStackNode next) {
            this.next = next;
        }
    }
}

4.前缀，中缀，后缀表达式（逆波兰表达式）

  1. 前缀表达式又称波兰式，前缀表达式的运算符位于操作符之前。
    例如：（3+4） * 5-6对应的表达式就是 - X + 3 4 5 6
  2. 中缀表达式是常见的运算表达式，如（3+4）*5-6
    中缀表达式对计算机来说却不好操作。因此在计算结果时，往往会将中缀转成其他表达式来操作（一般转成后缀表达式）
  3. 后缀表达式又称逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后。
    例如（3+4）*5-6对应的后缀表达式就是3 4 + 5 * 6 -

5. 中缀转后缀表达式

方法一：
将中缀表达式按照运算顺序加上（）。例如：a + b - (c -d) * e,就转为((a + b) - ((c -d)*e))。
如果是转为后缀表达式，就把运算法提到最近括号的右边。如果是前缀表达式，就把运算法提到最近括号的左边。例如((a + b) - ((c -d)*e))，就转为后缀：((ab)+((cd)-e)*)- ,ab+cd-e*-
方法二：

浑水摸鱼仙君
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构和算法——线性结构（1）数组、栈、队列和单链表
zhupup
10-17 195
1. 数组   ● 面向对象： add 、insert 、get 、delete   ● 查找算法：线性查找 （依次对比查找，效率低）、二分查找（前提是有序数组） 二分查找思路： import java.util.Scanner; public class BinarySearch { public static void main(String[] args) { //...
算法——数据结构基础(数组、队列、栈、链表、散链表)
your_棒棒糖的博客
06-28 309
算法——数据结构基础数组：顺序存储链表：随机存储栈：队列：散列表（哈希表）：hash table1. 哈希函数2.散列表的读写操作:(1) 写操作：put(2) 读操作：get(3) 扩容：resize 文章结构概览 数组：顺序存储 读操作多，写操作少 1.读取(查找)元素：读取对应的下标 高效的查找元素的算法：二分查找 2.更新元素：对元素进行重新赋值 3.插入元素：尾部插入、中间插入、超范围插入 扩容问题，时间复杂度：O(n) 插入并移动元素，时间复杂度：O(n) 4.删除元素：1) 删除对应位置，
数学表达式求值
10-27
带有变量的中缀表达式是常见的数学表达式。如果规定变量由长度不超过 8 个小写字母组成；end为保留字，表示程序段结束；用？表示输出指定变量的值，则可以设计出比较复杂的表达式（即一个可顺序执行语句序列）。例如，如果有如下语句段：
数据结构与算法——线性表、顺序表、链表、栈、队列
usunshineboy的博客
01-13 437
一、线性表 前驱元素：若A元素在B元素的前面，则称A为B的前驱元素。 后继元素：若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种一对一的逻辑关系。 1.第一个数据元素没有前驱，这个数据元素被称为头结点； 2.最后一个数据元素没有后继，这个数据元素被称为尾结点； 3.除了第一个元素和最后一个元素外，其他数据元素有且仅有一个前驱和一个后继。 线性表的分类：线性表中数据元素存储的方式可以是顺序存储，也可以是链式存储，按照不同的存储方式可分为顺序表和链表。 1.1顺序表 1.1.1顺
Java数据结构与算法—及实现 线性表 顺序表、链表、栈、队列详解
caobing123321的博客
03-13 627
数据结构与算法是程序设计的两大基础，大型的IT企业面试时也会出数据结构和算法的题目，它可以说明你是否有良好的逻辑思维，如果你具备良好的逻辑思维，即使技术存在某些缺陷，面试公司也会认为你很有培养价值，至少在一段时间之后，技术可以很快得到提高。同时，它也是软考的重点，我们需要对这部分的内容进行一下总结。我们先看一下数据结构和算法的整体内容。1、线性表概念：数据元素的排列方式是线性的。分类：分类规则是根...
【数据结构】1. 数据结构基本概念（数组、顺序表、链表、栈、队列、二叉树、红黑树、堆、哈希表）
瞌睡的博客
01-16 1542
目录1. 数组2. 数组和线性表的区别3. 线性表4. 顺序表5. 链表6. 顺序表与链表的区别 1. 数组 数组：在一段 连续的内存空间 存储多个 类型相同 的数据 2. 数组和线性表的区别 （1）数组静态分配内存，链表动态分配内存 （2）数组在内存中连续，链表不连续 （3）数组元素在栈区，链表元素在堆区 （4）数组利用下标定位，时间复杂度为O(1)，链表定位元素时间复杂度O(n)； （5）数组插入或删除元素的时间复杂度O(n)，链表的时间复杂度O(1)。 3. 线性表 线性表：线性表是n个具有
JS常用的数据结构和算法,链表、栈、队列、排序和查找:octocat
最新发布
04-03
在这个主题下，我们将深入探讨四种基本的数据结构——链表、栈、队列以及基础的排序和查找算法。这些概念不仅在日常开发中广泛应用，也是面试中常被考察的知识点。 **链表** 链表是一种线性数据结构，与数组不同，...
数据结构、算法与应用——C++语言描述.rar
07-25
在数据结构部分，书中涵盖了数组、链表、栈、队列、树（包括二叉树、平衡树如AVL树和红黑树）、图等基本数据结构。数组是最基础的数据结构，提供了随机访问的能力；链表则允许动态添加和删除元素，适合处理变化的...
算法和数据结构——队列.pdf
08-07
队列是一种基础且重要的数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。在队列中，元素的插入（入队）发生在队尾，而删除（出队）则发生在队头。这个概念可以类比于现实生活中人们排队购物的情景...
表达式求值（2）选作.cpp
11-11
带有变量的中缀表达式是常见的数学表达式。如果规定变量由长度不超过 8 个小写字母组成；end为保留字，表示程序段结束；用？表示输出指定变量的值，则可以设计出比较复杂的表达式（即一个可顺序执行语句序列）。例如，如果有如下语句段： abc=10 def=8 c=abc+def abc=abc+5-c*2 ? c ? abc end 则输出为： c=18 abc=-21 注意：为了简化编程实现，运算符只有＋，－，＊，／ ，%和＾（指数运算），可以处理圆括号（），并假定输入的算术表达式正确。 要求：使用栈结构实现。 输入：表达式序列 输出：全部指定变量的值 表达式中的全部计算结果均为整数。如果在计算过程中出现除数为0的情况，则输出：Divide 0. 特殊情况说明： 在表达式中，如果操作数出现负数（例如-8），则要特别注意。例如： 10加-8表示为：10+-8。 10减-8表示为：10--8。
算术编码.cpp
07-19
此文档是有关算术编码与译码的源代码（仅供参考！！），编码方法是递归，相关说明链接
2010年计算机考研真题及答案
08-06
2010年计算机考研真题及答案2010年计算机考研真题及答案2010年计算机考研真题及答案
Java数据结构与算法02——队列
12-21
Java中的数据结构与算法是编程领域中至关重要的概念，它们为高效地处理和组织数据提供了...对于初学者来说，从简单的数组模拟开始，逐步深入到链表、环形队列以及更高级的队列实现，是学习数据结构与算法的有效路径。
算法和数据结构——左程云.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构和算法的基本概念和基本术语（数据，数据元素，数据项，数据对象）
技术改变命运
01-17 1329
数据结构（Data Structure）：是相互之间存在一种或多种特定关系的数据元系的集合，换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。 算法（Algorithm）：是为了解决某类问题而规定的一个有限长的操作序列。
常见的数据结构总结（8种）
热门推荐
m0_60416282的博客
07-05 2万+
1. 顺序表（数组 Array）2. 链表 3. 栈（Stack）4. 队列（Queue）5. 树（Tree）6. 堆（Heap）7. 图（graph）8. 散列表（Hash）
前缀表达式、中缀表达式、后缀表达式
逐梦苍穹的博客
05-30 4504
本文介绍三种表达式（前缀表达式、中缀表达式和后缀表达式）
排队(约瑟夫问题)用循环链表解决
GadyPu的专栏
10-19 753
描述 周末了，软件ACM的队员准备玩玩游戏，娱乐一下，CY想了一个好主意，所有队员站成一个圈，从1开始报数，凡是报出指定数字的人要出列，有人出列后，下个人重新从1开始报数。最后一位“幸存者”要给大家表演个节目。由于队员正在不断的壮大，C小加又想知道他是否需要准备表演，请你设计个程序，帮他确定他是否是“幸存者”。 输入第一行是n，有n次游戏，第二行是m，x，表示某次游戏有m个人，指定被请出列的数字
数据结构不挂科-3-栈和队列.pdf
07-17
本资料主要介绍了两个基本的数据结构——栈和队列，特别是它们在C语言中的实现。 栈是一种特殊的线性数据结构，被称为“后进先出”（LIFO，Last In First Out）或“先进后出”（FILO，First In Last Out）结构。它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值