顺序表删除结点代码生成
时间: 2023-05-11 12:06:48 浏览: 56
以下是顺序表删除结点的代码生成:
```c
#include <stdio.h>
#define MAXSIZE 100
typedef struct {
int data[MAXSIZE];
int length;
} SqList;
int deleteElem(SqList *L, int i) {
if (i < 1 || i > L->length) {
return 0;
}
int e = L->data[i - 1];
for (int j = i; j < L->length; j++) {
L->data[j - 1] = L->data[j];
}
L->length--;
return e;
}
int main() {
SqList L = {{1, 2, 3, 4, 5}, 5};
int e = deleteElem(&L, 3);
printf("Deleted element: %d\n", e);
printf("List: ");
for (int i = 0; i < L.length; i++) {
printf("%d ", L.data[i]);
}
printf("\n");
return 0;
}
```
希望这个代码能够帮到你!
相关问题
生成c语言数据结构线性表代码
以下是一个简单的C语言线性表的实现代码,包括顺序表和链表两种方式:
1. 顺序表实现
```c
#define MAXSIZE 100 // 定义线性表最大长度
typedef struct {
int data[MAXSIZE]; // 存储数据元素
int length; // 线性表当前长度
} SqList; // 顺序表类型定义
// 初始化线性表
void InitList(SqList *L) {
L->length = 0;
}
// 插入元素
bool ListInsert(SqList *L, int i, int e) {
if (i < 1 || i > L->length + 1 || L->length == MAXSIZE) {
return false; // 插入位置不合法或线性表已满
}
for (int j = L->length; j >= i; j--) {
L->data[j] = L->data[j - 1]; // 将插入位置后的元素后移
}
L->data[i - 1] = e; // 插入新元素
L->length++; // 线性表长度加1
return true;
}
// 删除元素
bool ListDelete(SqList *L, int i, int *e) {
if (i < 1 || i > L->length) {
return false; // 删除位置不合法
}
*e = L->data[i - 1]; // 将删除元素的值赋给e
for (int j = i; j < L->length; j++) {
L->data[j - 1] = L->data[j]; // 将删除位置后的元素前移
}
L->length--; // 线性表长度减1
return true;
}
// 查找元素
int LocateElem(SqList L, int e) {
for (int i = 0; i < L.length; i++) {
if (L.data[i] == e) {
return i + 1; // 返回元素在线性表中的位置
}
}
return 0; // 未找到元素
}
```
2. 链表实现
```c
typedef struct LNode {
int data; // 数据域
struct LNode *next; // 指针域
} LNode, *LinkList; // 链表类型定义
// 初始化链表
void InitList(LinkList *L) {
*L = (LinkList)malloc(sizeof(LNode)); // 创建头结点
(*L)->next = NULL; // 头结点指针域置空
}
// 插入元素
bool ListInsert(LinkList L, int i, int e) {
LNode *p = L, *s;
int j = 0;
while (p && j < i - 1) { // 寻找第i-1个结点
p = p->next;
j++;
}
if (!p || j > i - 1) {
return false; // 插入位置不合法
}
s = (LNode*)malloc(sizeof(LNode)); // 创建新结点
s->data = e; // 新结点赋值
s->next = p->next; // 新结点指向原第i个结点
p->next = s; // 原第i-1个结点指向新结点
return true;
}
// 删除元素
bool ListDelete(LinkList L, int i, int *e) {
LNode *p = L, *q;
int j = 0;
while (p->next && j < i - 1) { // 寻找第i-1个结点
p = p->next;
j++;
}
if (!p->next || j > i - 1) {
return false; // 删除位置不合法
}
q = p->next; // q指向第i个结点
*e = q->data; // 将删除元素的值赋给e
p->next = q->next; // 将第i-1个结点指向第i+1个结点
free(q); // 释放第i个结点的空间
return true;
}
// 查找元素
int LocateElem(LinkList L, int e) {
LNode *p = L->next;
int i = 1;
while (p) {
if (p->data == e) {
return i; // 返回元素在链表中的位置
}
p = p->next;
i++;
}
return 0; // 未找到元素
}
```
(1)参照例9-5中结点类Node的声明(9_5.h),给出其实现。在测试程序中从键盘输入10个整数,用这些整数值作为结点数据,生成一个链表,按顺序输出链表中结点的数值。然后从键盘输入一个待查找整数,在链表中查找该整数,若找到则删除该整数所在的结点(如果出现多次,全部删除),然后输出删除结点以后的链表。在程序结束之前清空链表。
Node的实现代码如下:
```cpp
#include<iostream>
using namespace std;
class Node {
public:
int data;
Node* next;
Node(int data): data(data), next(nullptr) {}
};
```
生成链表和输出链表的代码如下:
```cpp
int main() {
Node* head = nullptr;
Node* tail = nullptr;
int n;
for (int i = 0; i < 10; i++) {
cin >> n;
Node* node = new Node(n);
if (tail == nullptr) {
head = node;
tail = node;
} else {
tail->next = node;
tail = node;
}
}
Node* p = head;
while (p != nullptr) {
cout << p->data << " ";
p = p->next;
}
cout << endl;
// ...
return 0;
}
```
接下来是删除结点的代码。我们可以先遍历一遍链表,找到要删除的结点,然后再遍历一遍链表,将要删除的结点全部删除。删除结点时需要注意,如果要删除的结点是头结点,则需要特殊处理。
```cpp
int main() {
// ...
int x;
cin >> x;
Node* prev = nullptr;
Node* curr = head;
while (curr != nullptr) {
if (curr->data == x) {
if (prev == nullptr) {
head = curr->next;
delete curr;
curr = head;
} else {
prev->next = curr->next;
delete curr;
curr = prev->next;
}
} else {
prev = curr;
curr = curr->next;
}
}
p = head;
while (p != nullptr) {
cout << p->data << " ";
p = p->next;
}
cout << endl;
// ...
return 0;
}
```
最后是清空链表的代码。我们可以遍历链表,依次删除每个结点,直到链表为空。
```cpp
int main() {
// ...
Node* p = head;
while (p != nullptr) {
Node* q = p;
p = p->next;
delete q;
}
head = nullptr;
tail = nullptr;
// ...
return 0;
}
```
完整代码如下: