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语言中，顺序表是一种线性数据结构，它将元素按顺序存储在内存的连续区域，通过索引来访问每个元素。冒泡排序是一种简单的排序算法，尤其适用于小规模的数据集。它的基本思想是从数组的第一个元素开始，两两比较相邻元素，如果它们的顺序错误就把它们交换过来，这个过程就像气泡从底部向上浮一样。

以下是冒泡排序的C语言实现：

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

在这个函数中，外部循环控制排序的轮数，内部循环则是每轮的具体比较和交换操作。经过多次迭代，最大的元素会逐渐“冒泡”到数组的末尾。

c语言链表如何冒泡排序

链表是一种常见的数据结构，它可以通过指针实现动态存储数据。链表的冒泡排序和数组的冒泡排序有些不同，因为链表中的节点不是按照顺序排列的。下面是C语言中链表的冒泡排序算法：

1. 首先，定义一个链表节点结构体，包含一个数据成员和一个指向下一个节点的指针。

   struct ListNode {
       int val;
       struct ListNode *next;
   };

2. 定义链表的冒泡排序函数bubbleSortList，该函数接受一个链表头节点指针作为参数。

   void bubbleSortList(struct ListNode* head) {
       if (head == NULL) return;  // 如果链表为空，则直接返回
       int swapped;
       struct ListNode *ptr1;
       struct ListNode *lptr = NULL;
       do {
           swapped = 0;
           ptr1 = head;
           while (ptr1->next != lptr) {  // 遍历链表
               if (ptr1->val > ptr1->next->val) {  // 如果相邻两个节点的值大小关系需要调换
                   swap(ptr1, ptr1->next);  // 调换两个节点的值
                   swapped = 1;  // 标记本轮循环有交换发生
               }
               ptr1 = ptr1->next;  // 移动指针
           }
           lptr = ptr1;  // 记录已排序部分的尾指针
       } while (swapped);  // 如果本轮循环没有交换，则表示已经排好序，可以退出循环
   }

3. 定义一个交换函数swap，用于交换相邻两个节点的值。

   void swap(struct ListNode *a, struct ListNode *b) {
       int temp = a->val;
       a->val = b->val;
       b->val = temp;
   }

4. 然后在主函数中创建链表，并调用bubbleSortList函数进行排序。

   int main() {
       struct ListNode* head = createLinkedList();  // 创建链表
       bubbleSortList(head);  // 对链表进行冒泡排序
       printLinkedList(head);  // 输出排序后的链表
       return 0;
   }