Cấu trúc dữ liệu trong c và python có giống nhau không?

Cấu trúc dữ liệu là khóa học cơ bản cho bất kỳ sinh viên khoa học máy tính nào. Khóa học này thảo luận về mọi chủ đề từ những điều rất cơ bản và đạt đến độ sâu tối đa có thể

Ghi chú. Một người không có kiến ​​thức cũng có thể hiểu khóa học và một chuyên gia về cấu trúc dữ liệu và thuật toán cũng có thể tìm ra các kỹ thuật mới và có thể đào sâu

--------------------------------------------------

Ngăn xếp là một cấu trúc dữ liệu tuyến tính tuân theo nguyên tắc Nhập sau xuất trước [LIFO]. Điều này có nghĩa là phần tử cuối cùng được chèn vào bên trong ngăn xếp sẽ bị xóa trước

Bạn có thể coi cấu trúc dữ liệu ngăn xếp như một đống đĩa chồng lên nhau

Ở đây, bạn có thể

• Đặt một cái đĩa mới lên trên
• Tháo tấm trên cùng

Và, nếu bạn muốn tấm ở dưới cùng, trước tiên bạn phải loại bỏ tất cả các tấm trên cùng. Đây chính xác là cách cấu trúc dữ liệu ngăn xếp hoạt động

LIFO nguyên tắc ngăn xếp

Trong thuật ngữ lập trình, việc đặt một mục lên trên ngăn xếp được gọi là đẩy và loại bỏ một mục được gọi là bật

Trong hình trên, mục 3 được giữ cuối cùng nhưng lại bị xóa trước. Đây chính xác là cách hoạt động của Nguyên tắc LIFO [Last In First Out]

Chúng ta có thể triển khai ngăn xếp trong bất kỳ ngôn ngữ lập trình nào như C, C++, Java, Python hoặc C#, nhưng đặc điểm kỹ thuật gần như giống nhau

Thao tác cơ bản của Stack

Có một số thao tác cơ bản cho phép chúng ta thực hiện các thao tác khác nhau trên ngăn xếp

• Đẩy. Thêm một phần tử vào đầu ngăn xếp
• Nhạc pop. Xóa một phần tử khỏi đỉnh ngăn xếp
• Không có sản phẩm nào. Kiểm tra xem ngăn xếp có trống không
• là đầy đủ. Kiểm tra xem ngăn xếp có đầy không
• nhìn trộm. Lấy giá trị của phần tử trên cùng mà không xóa nó

Hoạt động của cấu trúc dữ liệu ngăn xếp

Các thao tác hoạt động như sau

1. Một con trỏ có tên TOP được sử dụng để theo dõi phần tử trên cùng trong ngăn xếp
2. Khi khởi tạo ngăn xếp, chúng tôi đặt giá trị của nó thành -1 để có thể kiểm tra xem ngăn xếp có trống không bằng cách so sánh TOP == -1
3. Khi đẩy một phần tử, chúng tôi tăng giá trị của TOP và đặt phần tử mới vào vị trí được chỉ định bởi TOP
4. Khi bật một phần tử, chúng tôi trả về phần tử được trỏ bởi TOP và giảm giá trị của nó
5. Trước khi đẩy, chúng tôi kiểm tra xem ngăn xếp đã đầy chưa
6. Trước khi bật, chúng tôi kiểm tra xem ngăn xếp đã trống chưa

Triển khai ngăn xếp trong Python, Java, C và C++

Cách triển khai ngăn xếp phổ biến nhất là sử dụng mảng, nhưng nó cũng có thể được triển khai bằng cách sử dụng danh sách

# Stack implementation in python


# Creating a stack
def create_stack[]:
    stack = []
    return stack


# Creating an empty stack
def check_empty[stack]:
    return len[stack] == 0


# Adding items into the stack
def push[stack, item]:
    stack.append[item]
    print["pushed item: " + item]


# Removing an element from the stack
def pop[stack]:
    if [check_empty[stack]]:
        return "stack is empty"

    return stack.pop[]


stack = create_stack[]
push[stack, str[1]]
push[stack, str[2]]
push[stack, str[3]]
push[stack, str[4]]
print["popped item: " + pop[stack]]
print["stack after popping an element: " + str[stack]]

// Stack implementation in Java

class Stack {
  private int arr[];
  private int top;
  private int capacity;

  // Creating a stack
  Stack[int size] {
    arr = new int[size];
    capacity = size;
    top = -1;
  }

  // Add elements into stack
  public void push[int x] {
    if [isFull[]] {
      System.out.println["OverFlow\nProgram Terminated\n"];
      System.exit[1];
    }

    System.out.println["Inserting " + x];
    arr[++top] = x;
  }

  // Remove element from stack
  public int pop[] {
    if [isEmpty[]] {
      System.out.println["STACK EMPTY"];
      System.exit[1];
    }
    return arr[top--];
  }

  // Utility function to return the size of the stack
  public int size[] {
    return top + 1;
  }

  // Check if the stack is empty
  public Boolean isEmpty[] {
    return top == -1;
  }

  // Check if the stack is full
  public Boolean isFull[] {
    return top == capacity - 1;
  }

  public void printStack[] {
    for [int i = 0; i top = -1;
}

// Check if the stack is full
int isfull[st *s] {
  if [s->top == MAX - 1]
    return 1;
  else
    return 0;
}

// Check if the stack is empty
int isempty[st *s] {
  if [s->top == -1]
    return 1;
  else
    return 0;
}

// Add elements into stack
void push[st *s, int newitem] {
  if [isfull[s]] {
    printf["STACK FULL"];
  } else {
    s->top++;
    s->items[s->top] = newitem;
  }
  count++;
}

// Remove element from stack
void pop[st *s] {
  if [isempty[s]] {
    printf["\n STACK EMPTY \n"];
  } else {
    printf["Item popped= %d", s->items[s->top]];
    s->top--;
  }
  count--;
  printf["\n"];
}

// Print elements of stack
void printStack[st *s] {
  printf["Stack: "];
  for [int i = 0; i < count; i++] {
    printf["%d ", s->items[i]];
  }
  printf["\n"];
}

// Driver code
int main[] {
  int ch;
  st *s = [st *]malloc[sizeof[st]];

  createEmptyStack[s];

  push[s, 1];
  push[s, 2];
  push[s, 3];
  push[s, 4];

  printStack[s];

  pop[s];

  printf["\nAfter popping out\n"];
  printStack[s];
}

// Stack implementation in C++

#include 
#include 

using namespace std;

#define MAX 10
int size = 0;

// Creating a stack
struct stack {
  int items[MAX];
  int top;
};
typedef struct stack st;

void createEmptyStack[st *s] {
  s->top = -1;
}

// Check if the stack is full
int isfull[st *s] {
  if [s->top == MAX - 1]
    return 1;
  else
    return 0;
}

// Check if the stack is empty
int isempty[st *s] {
  if [s->top == -1]
    return 1;
  else
    return 0;
}

// Add elements into stack
void push[st *s, int newitem] {
  if [isfull[s]] {
    cout top++;
    s->items[s->top] = newitem;
  }
  size++;
}

// Remove element from stack
void pop[st *s] {
  if [isempty[s]] {
    cout top--;
  }
  size--;
  cout