#我的编程语言学习笔记#

根据提供的两个引用内容，我了解到这是关于计算机编程学习笔记的内容，其中包括C语言的基础内容以及指针和数组等内容。下面是对两个引用的总结：

引用中提供了一个递归函数，用于计算一个整数的阶乘。通过递归调用fac()函数本身，计算n的阶乘。其中，当n小于等于1时，返回1；当n大于1时，返回n和fac(n-1)的乘积。在主函数中，通过输入一个整数n，调用fac()函数计算n的阶乘，最后将结果输出。

引用中提供了一个程序，用于初始化一个3*4的二维数组，并输出所有的元素。首先，定义一个3行4列的数组，并将所有元素初始化为0。然后，通过两个循环分别给每个元素赋值。最后，再遍历整个数组，将每个元素依次输出。

以下是Java中使用数组实现栈和队列的示例代码：

1. 使用数组实现栈

public class Stack {
    private int[] data;
    private int top;

    public Stack(int size) {
        data = new int[size];
        top = -1;
    }

    public void push(int elem) {
        if (top == data.length - 1) {
            System.out.println("Stack is full!");
            return;
        }
        data[++top] = elem;
    }

    public int pop() {
        if (top == -1) {
            System.out.println("Stack is empty!");
            return -1;
        }
        return data[top--];
    }
}

2. 使用数组实现队列

public class Queue {
    private int[] data;
    private int front;
    private int rear;

    public Queue(int size) {
        data = new int[size];
        front = -1;
        rear = -1;
    }

    public void enqueue(int elem) {
        if (rear == data.length - 1) {
            System.out.println("Queue is full!");
            return;
        }
        data[++rear] = elem;
        if (front == -1) {
            front = 0;
        }
    }

    public int dequeue() {
        if (front == -1) {
            System.out.println("Queue is empty!");
            return -1;
        }
        int elem = data[front];
        if (front == rear) {
            front = -1;
            rear = -1;
        } else {
            front++;
        }
        return elem;
    }
}

使用链表实现栈和队列的方式比较简单，只需要在链表的基础上添加一些操作即可。下面是具体的实现方式：

1. 链表实现栈

栈的特点是先进后出，可以使用链表的头插法实现。具体步骤如下：

• 定义一个链表节点类，包含元素值和指向下一个节点的指针；
• 定义栈顶指针，初始化为 None；
• 入栈：新建一个节点，将其插入链表头部，更新栈顶指针；
• 出栈：判断栈顶指针是否为 None，如果是则返回 None，否则返回栈顶元素的值，并将栈顶指针向下移动一个节点。

代码如下所示：

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None

class Stack:
    def __init__(self):
        self.top = None

    def push(self, val):
        new_node = ListNode(val)
        new_node.next = self.top
        self.top = new_node

    def pop(self):
        if not self.top:
            return None
        val = self.top.val
        self.top = self.top.next
        return val

2. 链表实现队列

队列的特点是先进先出，可以使用链表的尾插法实现。具体步骤如下：

• 定义一个链表节点类，包含元素值和指向下一个节点的指针；
• 定义队列头部和尾部指针，初始化为 None；
• 入队：新建一个节点，将其插入链表尾部，更新队列尾部指针；
• 出队：判断队列头部指针是否为 None，如果是则返回 None，否则返回队列头部元素的值，并将队列头部指针向下移动一个节点。

代码如下所示：

class Queue:
    def __init__(self):
        self.head = None
        self.tail = None

    def enqueue(self, val):
        new_node = ListNode(val)
        if not self.head:
            self.head = new_node
        else:
            self.tail.next = new_node
        self.tail = new_node

    def dequeue(self):
        if not self.head:
            return None
        val = self.head.val
        self.head = self.head.next
        return val

链表和数组在不同的场景下有不同的适用性。一般来说，当需要快速访问数据但是数据量比较大时，使用数组比较合适；当需要频繁插入和删除数据时，使用链表比较合适。

具体来说，相对于数组，链表插入和删除数据的效率更高，因为只需要更改指针即可，时间复杂度为O(1)。而数组在插入和删除数据时，需要将插入或删除位置后面的数据往后或往前移动，时间复杂度为O(n)。所以，当需要频繁插入和删除数据时，使用链表比较合适。

相反，当需要快速访问数据时，数组比较合适。因为在数组中，数据存储是连续的，可以通过下标快速访问数据，时间复杂度为O(1)。而链表中，由于数据是通过指针连接在一起的，需要从头节点开始遍历，时间复杂度为O(n)。所以，当需要快速访问数据时，使用数组比较合适。

引用:链表和数组有什么区别，在什么时候应该使用链表/数组？。 链表和数组有什么区别，在什么时候应该使用链表/数组？ 1. 数组和链表的区别2. 链表和数组使用场景 。

数组和链表都是计算机中常用的数据结构。数组是一种连续存储的数据结构，其中每个元素都可以使用其索引进行访问。链表则是一种非连续存储的数据结构，其中每个元素包括一个值以及一个指向下一个元素的指针。通过定义节点并使用指针连接它们，可以在链表中存储大量的数据。

数组和链表之间的最大区别在于它们的内存管理方式，以及它们适用的不同场景。数组的内存分配是连续的，这使得在内存中寻找元素的时间变得更加快速。因此，当需要随机访问元素时，应该使用数组。数组还适用于具有固定大小的数据集合，因为数组的大小是在创建时确定的。

链表的内存分配是非连续的，这使得在内存中寻找元素的时间更长。但是链表可以通过增加、删除节点来动态地构建和修改数据集合。因此，当需要频繁的插入、删除元素时，应该使用链表。

数组和链表是两种常见的数据结构，它们有以下不同的特性：数组拥有连续内存空间和相同类型的数据，因此可以支持随机访问，时间复杂度为O(1)，而链表则不同，它是由一系列的节点组成，每个节点都包含了数据和指向下一个节点的指针，在链表中进行插入和删除操作比数组更加高效，时间复杂度为O(1)。但是，链表不支持随机访问，需要通过指针一个一个地查找节点，时间复杂度为O(n)。因此，当需要快速随机访问数据时，使用数组会更加合适；当需要频繁进行插入和删除操作时，使用链表会更加合适。