c语言while循环冒泡排序

以下是使用C语言实现的while循环冒泡排序的示例代码：

#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;
}

该代码使用了嵌套的while循环来实现冒泡排序算法。外层循环控制排序的轮数，内层循环用于比较相邻元素并进行交换。通过多次遍历数组，将较大的元素逐渐移动到数组的末尾，从而实现排序。

相关问题

c语言链表的冒泡排序算法

链表的冒泡排序算法与数组的冒泡排序算法类似，都是每次比较相邻两个元素的大小，根据需要交换它们的位置，重复这个过程直到没有交换发生为止。但是链表的冒泡排序需要注意一些细节问题。

具体实现方法如下：

1. 定义三个指针，p、q、tail，其中 p 和 q 分别指向相邻的两个节点，tail 指向链表的末尾。

2. 外层循环控制排序的轮数，内层循环遍历链表并进行比较交换。

3. 在内层循环中，如果 p 的值大于 q 的值，就交换它们的值。

4. 每一轮内层循环结束后，把 tail 指向当前最后一个已经排好序的节点。

5. 当没有发生交换时，说明链表已经排好序，排序结束。

完整代码实现如下：

void bubble_sort(struct node *head) {
    if (head == NULL) {
        return;
    }
    struct node *p, *q, *tail = NULL;
    int exchange = 1;
    while (exchange && head->next != tail) {
        exchange = 0;
        p = head;
        q = p->next;
        while (q != tail) {
            if (p->data > q->data) {
                int tmp = p->data;
                p->data = q->data;
                q->data = tmp;
                exchange = 1;
            }
            p = p->next;
            q = q->next;
        }
        tail = p;
    }
}

注意，这里的链表节点使用了结构体 node 来表示，其中 data 表示节点的值，next 指向下一个节点。

循环单链表的冒泡排序 c语言

以下是循环单链表的冒泡排序的C语言代码实现：

#include <stdio.h>
#include <stdlib.h>

// 定义循环单链表的结构体
typedef struct Node {
    int data;
    struct Node *next;
} Node, *LinkedList;

// 创建循环单链表
LinkedList createLinkedList(int n) {
    LinkedList head = (LinkedList) malloc(sizeof(Node)); // 创建头结点
    head->next = head; // 初始化头结点的next指针指向自身
    LinkedList p = head; // 创建指向头结点的指针p
    int i, data;
    for (i = 0; i < n; i++) {
        printf("请输入第%d个数据：", i + 1);
        scanf("%d", &data);
        LinkedList q = (LinkedList) malloc(sizeof(Node)); // 创建新节点
        q->data = data; // 新节点的数据为输入的数据
        q->next = p->next; // 新节点的next指针指向头结点的下一个节点
        p->next = q; // 头结点的next指针指向新节点
        p = q; // p指向新节点
    }
    return head;
}

// 输出循环单链表
void printLinkedList(LinkedList head) {
    LinkedList p = head->next;
    while (p != head) {
        printf("%d ", p->data);
        p = p->next;
    }
}

// 冒泡排序
void bubbleSort(LinkedList head) {
    LinkedList p = head->next;
    while (p->next != head) {
        LinkedList q = p->next;
        while (q != head) {
            if (p->data > q->data) {
                int temp = p->data;
                p->data = q->data;
                q->data = temp;
            }
            q = q->next;
        }
        p = p->next;
    }
}

int main() {
    int n;
    printf("请输入循环单链表的节点个数：");
    scanf("%d", &n);
    LinkedList head = createLinkedList(n); // 创建循环单链表
    printf("排序前：");
    printLinkedList(head); // 输出排序前的循环单链表
    bubbleSort(head); // 对循环单链表进行冒泡排序
    printf("\n排序后：");
    printLinkedList(head); // 输出排序后的循环单链表
    return 0;
}

注意，在循环单链表中，头结点的next指针指向的是第一个节点，所以在访问循环单链表时，需要从头结点的下一个节点开始访问。在冒泡排序中，需要两个指针p和q分别指向相邻的两个节点，如果p的数据比q的数据大，则交换它们的数据。循环单链表的冒泡排序的时间复杂度为O(n^2)。