数据结构经典题目及c语言代码

数据结构经典题目及c语言代码
一、线性表
1. 顺序表
顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现：
```c
#define MaxSize 50
typedef struct {
int data[MaxSize]; // 存储元素的数组
int length; // 顺序表的当前长度
} SeqList;
// 初始化顺序表
void initList(SeqList *L) {
L->length = 0;
}
// 插入元素到指定位置
void insert(SeqList *L, int pos, int elem) {
if (pos < 1 || pos > L->length + 1) {
printf("插入位置无效\n");
return;
}
if (L->length == MaxSize) {
printf("顺序表已满，无法插入\n"); return;
}
for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];
}
L->data[pos - 1] = elem;
L->length++;
}
// 删除指定位置的元素
void delete(SeqList *L, int pos) {
if (pos < 1 || pos > L->length) {
printf("删除位置无效\n");
return;
}
for (int i = pos - 1; i < L->length - 1; i++) {
L->data[i] = L->data[i + 1];
}
L->length--;
}
// 获取指定位置的元素值
int getElement(SeqList *L, int pos) {
if (pos < 1 || pos > L->length) {
printf("位置无效\n");
return -1;
}
return L->data[pos - 1];
}
```
2. 链表
链表是一种利用非连续存储空间存储元素的线性表。

以下是一个链表的经典题目及C语言代码实现：
```c
typedef struct Node {
int data; // 数据域
struct Node *next; // 指针域，指向下一个节点} Node;
typedef struct {
Node *head; // 头节点指针
} LinkedList;
// 初始化链表
void initList(LinkedList *L) {
L->head = NULL;
}
// 在链表末尾插入节点
void insert(LinkedList *L, int elem) {
Node *newNode = (Node*)malloc(sizeof(Node)); newNode->data = elem;
newNode->next = NULL;
if (L->head == NULL) {
L->head = newNode;
} else {
Node *current = L->head;
while (current->next != NULL) { current = current->next;
}
current->next = newNode;
}
}
// 删除指定位置的节点
void delete(LinkedList *L, int pos) { if (L->head == NULL) {
printf("链表为空，无法删除\n"); return;
}
if (pos == 1) {
Node *temp = L->head;
L->head = L->head->next;
free(temp);
} else {
Node *prev = L->head;
Node *current = L->head->next;
int count = 2;
while (current != NULL) {
if (count == pos) {
prev->next = current->next; free(current);
return;
}
prev = current;
current = current->next;
count++;
}
printf("位置无效\n");
return;
}
}
// 获取指定位置的节点值
int getElement(LinkedList *L, int pos) { Node *current = L->head;
int count = 1;
while (current != NULL) {
if (count == pos) {
return current->data;
}
current = current->next;
count++;
}
printf("位置无效\n");
return -1;
}
```
二、栈与队列
1. 栈
栈是一种先进后出的数据结构。

以下是一个栈的经典题目及C语言代码实现：
```c
#define MaxSize 50
typedef struct {
int data[MaxSize]; // 存储元素的数组
int top; // 栈顶指针
} Stack;
// 初始化栈
void initStack(Stack *S) {
S->top = -1;
}
// 判断栈是否为空
int isEmpty(Stack *S) {
return (S->top == -1);
}
// 判断栈是否已满
int isFull(Stack *S) {
return (S->top == MaxSize - 1); }
// 元素入栈
void push(Stack *S, int elem) {
if (isFull(S)) {
printf("栈已满，无法入栈\n");
}
S->top++;
S->data[S->top] = elem;
}
// 元素出栈
int pop(Stack *S) {
if (isEmpty(S)) {
printf("栈为空，无法出栈\n"); return -1;
}
int elem = S->data[S->top];
S->top--;
return elem;
}
// 获取栈顶元素值
int getTop(Stack *S) {
if (isEmpty(S)) {
printf("栈为空\n");
}
return S->data[S->top];
}
```
2. 队列
队列是一种先进先出的数据结构。

以下是一个队列的经典题目及C 语言代码实现：
```c
#define MaxSize 50
typedef struct {
int data[MaxSize]; // 存储元素的数组
int front; // 队头指针
int rear; // 队尾指针
} Queue;
// 初始化队列
void initQueue(Queue *Q) {
Q->front = 0;
Q->rear = 0;
}
// 判断队列是否为空
int isEmpty(Queue *Q) {
return (Q->front == Q->rear);
}
// 判断队列是否已满
int isFull(Queue *Q) {
return (Q->rear == MaxSize);
}
// 元素入队列
void enqueue(Queue *Q, int elem) { if (isFull(Q)) {
printf("队列已满，无法入队\n"); return;
}
Q->data[Q->rear] = elem;
Q->rear++;
}
// 元素出队列
int dequeue(Queue *Q) {
if (isEmpty(Q)) {
printf("队列为空，无法出队\n"); return -1;
}
int elem = Q->data[Q->front];
Q->front++;
return elem;
}
// 获取队头元素值
int getFront(Queue *Q) {
if (isEmpty(Q)) {
printf("队列为空\n");
return -1;
}
return Q->data[Q->front];
}
```
以上是数据结构中线性表、栈和队列的经典题目及相应的C语言代码实现。

这些题目和代码能够帮助我们更好地理解和掌握数据结构的基本概念和操作方法。

希望对你有所帮助！。