数据结构 -- stack、queue

每天叫醒你的不是闹钟,而是梦想

● 数据结构 -- 栈(stack)

     栈是限制插入和删除只能在同一个位置上进行的表,该位置是表的末端,叫做栈顶(top)。栈结构是一种后进先出的(LIFO)的数据结构。对栈的基本操作只有进栈(push)和出栈(pop)两种,进栈相当于插入,出栈相当于删除最后的元素。

/**
* @Description: 数据结构 -- 栈
* @Author: Zero
* @Date: 2019/11/28
*/
public class MyStack {

   private LinkedList<String> linkedList;

   public MyStack () {
       linkedList = new LinkedList<>();
   }

   public void push (String value) {
       linkedList.add(value);
       System.out.println(value + "进栈");
   }

   public void pop () {
       int size = linkedList.size();
       if (size > 0) {
           System.out.println(linkedList.get(size - 1) + "出栈");
           linkedList.remove(size - 1);
       } else {
           System.out.println("该栈已经为空");
       }
   }

   public void getStack () {
       System.out.println("当前栈中数据");
       System.out.println("--------------");
       for (String s : linkedList) {
           System.out.println(s);
       }
       System.out.println("--------------");
   }


   public static void main(String[] args) {
       MyStack stack = new MyStack(); // 创建一个栈结构

       stack.push("A"); // 开始进栈啦
       stack.push("B");
       stack.push("C");
       stack.push("D");
       System.out.println("");

       stack.getStack(); // 获取当前栈中的数据
       System.out.println("");

       stack.pop(); //出栈
       stack.pop();
       System.out.println("");

       stack.getStack();

   }
}

● 数据结构 -- 队列(queue)

   队列,一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,一种操作受限制的线性表。进行插入操作的那一端则称为队尾,进行删除操作的端称为队头。

/**
* @Description: 数据结构 -- 队列
* @Author: Zero
* @Date: 2019/11/28
*/
public class MyQueue {

   private LinkedList<String> linkedList;

   public MyQueue () {
       linkedList = new LinkedList<>();
   }

   public void insert (String value) {
       linkedList.add(value);
       System.out.println(value + "进队列");
   }

   public void remove () {
       int size = linkedList.size();
       if (size > 0) {
           System.out.println(linkedList.get(0) + "出队列");
           linkedList.remove(0);
       } else {
           System.out.println("该队列为空");
       }

   }
   public void getQueue () {
       System.out.println(linkedList);
   }
   public static void main(String[] args) {
       MyQueue myQueue = new MyQueue();

       myQueue.insert("A");
       myQueue.insert("B");
       myQueue.insert("C");
       myQueue.insert("D");

       myQueue.getQueue();

       myQueue.remove();

       myQueue.getQueue();
   }
}

专注分享Java技术,跟我一起学习吧

长按识别二维码关注

### 数据结构的C语言实现示例 以下是几种常见的数据结构在C语言中的实现示例,包括链表、栈和队列。 #### 单链表的基本操作 单链表是一种动态数据结构,节点由数据部分和指针部分组成。以下是一个完整的单链表插入、删除和打印操作的代码示例[^3]: ```c #include <stdio.h> #include <stdlib.h> // 节点结构定义 struct Node { int data; struct Node* next; }; // 创建新节点 struct Node* createNode(int data) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = data; newNode->next = NULL; return newNode; } // 在链表末尾插入节点 void insertAtEnd(struct Node** head, int data) { struct Node* newNode = createNode(data); if (*head == NULL) { *head = newNode; return; } struct Node* temp = *head; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; } // 删除指定值的节点 void deleteNode(struct Node** head, int key) { struct Node* temp = *head; struct Node* prev = NULL; if (temp != NULL && temp->data == key) { *head = temp->next; free(temp); return; } while (temp != NULL && temp->data != key) { prev = temp; temp = temp->next; } if (temp == NULL) return; prev->next = temp->next; free(temp); } // 打印链表 void printList(struct Node* head) { struct Node* temp = head; while (temp != NULL) { printf("%d -> ", temp->data); temp = temp->next; } printf("NULL\n"); } int main() { struct Node* head = NULL; insertAtEnd(&head, 1); insertAtEnd(&head, 2); insertAtEnd(&head, 3); printList(head); // 输出: 1 -> 2 -> 3 -> NULL deleteNode(&head, 2); printList(head); // 输出: 1 -> 3 -> NULL return 0; } ``` #### 栈的顺序存储实现 栈是一种后进先出(LIFO)的数据结构,可以通过数组或指针实现。以下是一个基于指针的顺序栈实现[^2]: ```c #include <stdio.h> #include <stdlib.h> #define MAXSIZE 10 typedef int SElemType; typedef struct { SElemType *base; // 栈底指针 SElemType *top; // 栈顶指针 int stacksize; // 栈的最大容量 } SqStack; // 初始化栈 void InitStack(SqStack *S) { S->base = (SElemType *)malloc(MAXSIZE * sizeof(SElemType)); if (!S->base) exit(-1); S->top = S->base; S->stacksize = MAXSIZE; } // 入栈 void Push(SqStack *S, SElemType e) { if (S->top - S->base >= S->stacksize) { S->base = (SElemType *)realloc(S->base, (S->stacksize + 10) * sizeof(SElemType)); S->top = S->base + S->stacksize; S->stacksize += 10; } *(S->top)++ = e; } // 出栈 SElemType Pop(SqStack *S) { if (S->top == S->base) { printf("Stack is empty.\n"); exit(-1); } return *--S->top; } int main() { SqStack S; InitStack(&S); Push(&S, 1); Push(&S, 2); printf("Popped element: %d\n", Pop(&S)); // 输出: Popped element: 2 return 0; } ``` #### 队列的顺序存储实现 队列是一种先进先出(FIFO)的数据结构,可以使用数组实现。以下是一个简单的顺序队列实现: ```c #include <stdio.h> #include <stdlib.h> #define MAXSIZE 10 typedef int QElemType; typedef struct { QElemType *base; // 队列底指针 int front; // 队头指针 int rear; // 队尾指针 int queueSize; // 队列最大容量 } SqQueue; // 初始化队列 void InitQueue(SqQueue *Q) { Q->base = (QElemType *)malloc(MAXSIZE * sizeof(QElemType)); if (!Q->base) exit(-1); Q->front = Q->rear = 0; Q->queueSize = MAXSIZE; } // 入队 void EnQueue(SqQueue *Q, QElemType e) { if ((Q->rear + 1) % Q->queueSize == Q->front) { printf("Queue is full.\n"); return; } Q->base[Q->rear] = e; Q->rear = (Q->rear + 1) % Q->queueSize; } // 出队 QElemType DeQueue(SqQueue *Q) { if (Q->front == Q->rear) { printf("Queue is empty.\n"); exit(-1); } QElemType e = Q->base[Q->front]; Q->front = (Q->front + 1) % Q->queueSize; return e; } int main() { SqQueue Q; InitQueue(&Q); EnQueue(&Q, 1); EnQueue(&Q, 2); printf("Dequeued element: %d\n", DeQueue(&Q)); // 输出: Dequeued element: 1 return 0; } ```
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值