单链表排序问题(冒泡/快排【前后指针法】)

#include<iostream>
#include<assert.h>
using namespace std;
typedef struct Node
{
    int data;
    struct Node* next;
    Node(int x)
        :data(x)
        ,next(NULL)
    {}
}Node;


----------//核心代码


//1.冒泡排序
void BubbleSortList(Node* PHead)
{
    //为空或者只有一个结点,直接返回
     if (PHead==NULL||PHead->next==NULL)
     {
         return;
     }
     //不为空,大于一个结点
     Node* cur=NULL;
     Node* next=NULL;
     Node* Tail=NULL;
     while(Tail!=PHead)
     {
         Node* cur=PHead;
         Node* next=PHead->next;
         int  mark=0;//标志
         while(next!=Tail)
         {
             if (cur->data>next->data)
             {
                 std::swap(cur->data,next->data);
                 mark=1;
              }
             cur=next;
             next=cur->next;
         }
         if (mark=0)
         {
             break;
         }
         Tail=cur;
     }

}


----------


----------//核心代码


//快排--前后指针法(因为不能从后往前遍历链表)
void QuickSort(Node* PHead,Node*  Tail)//将链表区间的最后一个结点的next作为结束标志
{
    if (PHead==NULL||PHead->next==Tail||PHead==Tail)
    {
        return ;
    }
    Node* cur=PHead->next;//前指针
    Node* prev=PHead;//后指针
    int key=prev->data;//将链表区间的第一个数作为基准值
    while(cur!=Tail)//一趟排序的结束条件---就是前指针已经走到区间末尾的下一个位置
    {   
        if (cur->data<key)//cur遇到了比key小的数,则将prev先后走一步,交换值
        {
            prev=prev->next;
            if (prev!=cur)
            {
                std::swap(cur->data,prev->data);
            }
        }
        cur=cur->next;//cur继续向后走
    }
    //循环出来以后将基准值和prev当前的结点值作交换
    std::swap(PHead->data,prev->data);
    QuickSort(PHead,prev);
    QuickSort(prev->next,Tail);
}


----------


void Printf(Node* PHead)
{
    assert(PHead);
    Node* cur=PHead;
    while (cur)
    {
        cout<<cur->data<<" ";
        cur=cur->next;
    }
}
int main()
{
        Node* node1 = new Node(4);
        Node* node2 = new Node(9);
        Node* node3 = new Node(3);
        Node* node4 = new Node(5);
        node1->next = node2;
        node2->next = node3;
        node3->next = node4;

        BubbleSortList(node1);
        cout<<"冒泡";
        Printf(node1);
        cout<<endl;
        QuickSort(node1,NULL);
        cout<<"快排";
        Printf(node1);
    return 0;
}
冒泡排序是一种简单的排序,可以用于对单链表进行排序。其基本思想是通过相邻元素的比较和交换,将较大的元素逐渐“冒泡”到链表的末尾。 下面是使用冒泡排序单链表进行排序的C语言代码实现: ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构体 struct ListNode { int val; struct ListNode *next; }; // 冒泡排序函数 void bubbleSort(struct ListNode *head) { if (head == NULL || head->next == 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) { // 交换节点的值 int temp = ptr1->val; ptr1->val = ptr1->next->val; ptr1->next->val = temp; swapped = 1; } ptr1 = ptr1->next; } lptr = ptr1; } while (swapped); } // 创建链表节点 struct ListNode* createNode(int val) { struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode)); newNode->val = val; newNode->next = NULL; return newNode; } // 打印链表 void printList(struct ListNode *head) { struct ListNode *temp = head; while (temp != NULL) { printf("%d ", temp->val); temp = temp->next; } printf("\n"); } int main() { // 创建链表 struct ListNode *head = createNode(5); head->next = createNode(3); head->next->next = createNode(8); head->next->next->next = createNode(1); head->next->next->next->next = createNode(6); printf("排序前的链表:"); printList(head); // 对链表进行冒泡排序 bubbleSort(head); printf("排序后的链表:"); printList(head); return 0; } ``` 以上代码中,我们首先定义了链表节点的结构体`struct ListNode`,然后实现了冒泡排序函数`bubbleSort`。在`bubbleSort`函数中,我们使用了两个指针`ptr1`和`lptr`,其中`ptr1`用于遍历链表,`lptr`用于记录已经排好序的部分的末尾节点。通过比较相邻节点的值,如果前一个节点的值大于后一个节点的值,则交换它们的值。通过多次遍历和交换,最终将较大的元素逐渐“冒泡”到链表的末尾。 在`main`函数中,我们创建了一个示例链表,并调用`bubbleSort`函数对链表进行排序。最后,打印排序前和排序后的链表。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值