C语言顺序表冒泡排序代码
时间: 2024-01-05 21:21:02 浏览: 24
以下是C语言顺序表冒泡排序的代码示例:
```c
#include <stdio.h>
void bubbleSort(int arr[], int n) {
int i, j;
for (i = 0; i < n-1; i++) {
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr)/sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: \n");
for (int i=0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
```
相关问题
用C语言写链表冒泡排序
以下是一个 C 语言实现链表冒泡排序的示例代码:
```
#include <stdio.h>
#include <stdlib.h>
// 定义链表节点结构体
struct Node
{
int data;
struct Node *next;
};
// 开始冒泡排序
void bubbleSort(struct Node *start)
{
int swapped, i;
struct Node *ptr1;
struct Node *lptr = NULL;
// 遍历链表节点直到链表的最后一个节点
do
{
swapped = 0;
ptr1 = start;
// 按顺序比较相邻的两个节点值
while (ptr1->next != lptr)
{
if (ptr1->data > ptr1->next->data)
{
int temp = ptr1->data;
ptr1->data = ptr1->next->data;
ptr1->next->data = temp;
swapped = 1;
}
ptr1 = ptr1->next;
}
lptr = ptr1;
}
while (swapped);
}
// 在链表的最后一个节点后面添加新节点
void push(struct Node **head_ref, int new_data)
{
struct Node *new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = NULL;
struct Node *last = *head_ref;
if (*head_ref == NULL)
{
*head_ref = new_node;
return;
}
while (last->next != NULL)
last = last->next;
last->next = new_node;
return;
}
// 打印链表中的所有元素
void printList(struct Node *node)
{
while (node != NULL)
{
printf("%d ", node->data);
node = node->next;
}
}
// 主函数
int main()
{
struct Node *start = NULL;
push(&start, 5);
push(&start, 20);
push(&start, 4);
push(&start, 3);
push(&start, 30);
printf("链表排序前的元素: \n");
printList(start);
bubbleSort(start);
printf("\n链表排序后的元素: \n");
printList(start);
return 0;
}
```
对于以上代码,我们先定义了一个链表节点结构体,包括一个数据成员和一个指向下一个节点的指针成员。然后编写了冒泡排序和其他帮助函数。在主函数中,我们通过调用 `push()` 函数向链表中添加元素,并在调用 `bubbleSort()` 函数时对链表进行排序。最后再使用 `printList()` 函数打印链表中的所有元素。
希望这个示例代码能够帮助你学习如何使用 C 语言进行链表冒泡排序。
C语言使用链表实现冒泡排序代码实现
### 回答1:
C语言使用链表实现冒泡排序的代码实现如下:
struct listNode {
int data;
struct listNode *next;
};
void BubbleSort(struct listNode* head) {
struct listNode *p, *q;
int temp;
if (head == NULL || head->next == NULL) return;
for (p = head; p->next != NULL; p = p->next) {
for (q = head; q->next != NULL; q = q->next) {
if (q->data > q->next->data) {
temp = q->data;
q->data = q->next->data;
q->next->data = temp;
}
}
}
}
### 回答2:
下面是用C语言实现冒泡排序算法的链表形式的代码:
```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));
if (newNode == NULL) {
printf("内存分配失败\n");
exit(1);
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
struct Node* insertNode(struct Node* head, int data) {
if (head == NULL) {
return createNode(data);
} else {
struct Node* newNode = createNode(data);
newNode->next = head;
return newNode;
}
}
struct Node* bubbleSort(struct Node* head) {
if (head == NULL || head->next == NULL) {
return head;
}
struct Node* current;
struct Node* next;
int swapped;
do {
swapped = 0;
current = head;
while (current->next != NULL) {
next = current->next;
if (current->data > next->data) {
int temp = current->data;
current->data = next->data;
next->data = temp;
swapped = 1;
}
current = next;
}
} while (swapped);
return head;
}
void printList(struct Node* head) {
struct Node* current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
}
int main() {
struct Node* head = NULL;
int n, data;
printf("请输入要排序的数字个数:");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
printf("请输入第%d个数字:", i+1);
scanf("%d", &data);
head = insertNode(head, data);
}
printf("排序前的链表:");
printList(head);
head = bubbleSort(head);
printf("排序后的链表:");
printList(head);
return 0;
}
```
以上代码创建了一个称为 Node 的结构体,表示链表中的节点。`createNode` 函数用于创建新的节点,`insertNode` 函数用于向链表插入节点。`bubbleSort` 函数用于实现冒泡排序算法并返回排好序的链表头节点。
在主函数中,首先获取要排序的数字个数,并逐个插入到链表中。然后调用 `bubbleSort` 对链表进行排序,最后打印排序前和排序后的链表。
请注意,这里的冒泡排序算法是从头节点开始两两比较相邻节点的值,如果顺序不对则交换。算法会一直遍历链表直到没有发生交换操作,即达到最佳排序顺序为止。
### 回答3:
冒泡排序是一种简单的排序算法,通过反复交换相邻元素的位置来实现排序。使用链表实现冒泡排序需要以下步骤:
1. 定义链表节点结构体,包含一个整型数据域和一个指向下一个节点的指针域。
2. 创建链表,并向其中插入待排序的元素。
3. 定义一个排序函数,用于对链表进行冒泡排序。函数内部使用两层循环,外层循环遍历链表的节点个数次,内层循环进行相邻节点的比较和交换操作。
在内层循环中,如果当前节点的数据大于下一个节点的数据,则交换它们的位置;否则,继续比较下一对节点。
通过这样的循环操作,每次内层循环结束后,链表最后的节点就是当前未排序部分的最大值。
外层循环重复执行该过程,每次只需要遍历到上一轮未排序部分的前一个节点。
4. 在排序函数中添加适当的边界判断和指针操作,确保链表正确排序。
5. 输出排序后的链表。
以下是一个使用链表实现冒泡排序的代码示例:
```c
#include <stdio.h>
#include <stdlib.h>
// 链表节点结构体
typedef struct Node {
int data; // 数据域
struct Node* next; // 指针域
} Node;
// 创建链表
Node* createList(int arr[], int size) {
Node* head = NULL;
Node* tail = NULL;
for (int i = 0; i < size; i++) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->data = arr[i];
newNode->next = NULL;
if (head == NULL) {
head = newNode;
tail = newNode;
} else {
tail->next = newNode;
tail = newNode;
}
}
return head;
}
// 冒泡排序
void bubbleSort(Node* head) {
if (head == NULL || head->next == NULL) {
return;
}
Node* p;
Node* q = NULL;
int swapped;
do {
swapped = 0;
p = head;
while (p->next != q) {
if (p->data > p->next->data) {
int temp = p->data;
p->data = p->next->data;
p->next->data = temp;
swapped = 1;
}
p = p->next;
}
q = p;
} while (swapped);
}
// 打印链表
void printList(Node* head) {
Node* p = head;
while (p != NULL) {
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int main() {
int arr[] = {4, 2, 6, 3, 1, 5};
int size = sizeof(arr) / sizeof(arr[0]);
Node* head = createList(arr, size);
bubbleSort(head);
printList(head);
return 0;
}
```
运行结果为:1 2 3 4 5 6,表示链表已经成功按照升序进行冒泡排序。