链表排序(1.交换结点的值 2.交换结点)

truct MyList
{
    int nA;
    MyList* pTnext;
    MyList* pTpre;
};

//双向链表的生成

MyList* CreateList() 
{
    MyList* pHead = NULL;
    MyList* pPre = NULL;
    MyList* pNext = NULL;
    MyList* pCur = NULL;

    int nA = 0;
    printf("请输入您的数字");
    for (int i = 0;i < 5;i++) 
    {
        scanf_s("%d", &nA);
        pCur = new MyList;
        pCur->pTpre = pPre;
        pCur->pTnext = NULL;

        if (pCur != nullptr)
        {
            pCur->nA = nA;
        }
        if (pPre == NULL)
        {
            pHead = pCur;
        }
        else 
        {
            pPre->pTnext = pCur;
        }
        pPre = pCur;
    }
    return pHead;
}

//第一种交换结点的值

MyList* ListWord(MyList* pList) 
{
    MyList* pCur = pList;
    int nB = 0;
    while (pCur != NULL)
    {
        printf("%d\n", pCur->nA);
        nB = nB + 1;
        pCur = pCur->pTnext;
    }

    pCur = pList;//重新赋值不然下面执行有错

    for (int i=0;i<nB;i++)
    {
        for (int j=0;j<nB;j++)
        {
            if (pCur->pTnext != NULL)
            {
                if (pCur->nA > pCur->pTnext->nA)
                {
                    int temp = pCur->nA;
                    pCur->nA = pCur->pTnext->nA;
                    pCur->pTnext->nA = temp;
                }
                else 
                {
                }
                pCur = pCur->pTnext;
            }
        }
        pCur = pList;
    }
    return pList;
}
 

//第二种结点值的交换

MyList* ListTextTwo(MyList* pListtwo) 
{
    MyList* pCur = pListtwo;
    MyList* pTemp = pListtwo;
    int nB = 0;
    int nC = 0;

    pCur = pListtwo;
    if (pListtwo == NULL)
    {
        return pListtwo;
    }

    MyList* pCurBig = pListtwo;
    while (pCurBig != NULL)
    {
        //每次进来从头开始比较
        pCur = pListtwo;

        while (pCur != NULL && pCur->pTnext != NULL)
        {
            if (pCur->nA > pCur->pTnext->nA)
            {
                int temp = pCur->nA;
                pCur->nA = pCur->pTnext->nA;
                pCur->pTnext->nA = temp;
            }
            pCur = pCur->pTnext;
        }
        pCurBig = pCurBig->pTnext;
    }
    return pListtwo;
}

//交换结点

MyList* ListRandTwo(MyList* pListTwo)
{
    MyList* pCur = pListTwo;
    MyList* pHead = pListTwo;

    MyList* pA;
    MyList* pB;
    MyList* pC;
    MyList* pD;

    pA = NULL;
    pB = pCur;
    if (pB == nullptr)
    {
        return pListTwo;
    }

    pC = pB->pTnext;
    pD = NULL;
    int nB = 0;
    while (pCur)
    {
        printf("%d\n", pCur->nA);
        pCur = pCur->pTnext;
        nB = nB + 1;
    }
    for (int i=0;i<nB;i++)
    {
        pCur = pListTwo;
        while (pCur != NULL && pCur->pTnext != NULL)
        {
            pA = pCur->pTpre;
            pB = pCur;
            pC = pCur->pTnext;
            if (pC != nullptr)
            {
                pD = pC->pTnext;
            }
            else
            {
                break;
            }

            if (pA->nA > pC->nA)
            {
                //连接
                pC->pTnext = pB;
                pC->pTpre = pA;
                pB->pTnext = pD;
                pD->pTpre = pB;

                if (pA != nullptr)
                {
                    pA->pTnext = pC;
                }
                else 
               {
                    pListTwo = pC;
                }

                if (pD != NULL)
                {
                    pD->pTpre = pB;
                }
            }
            else 
            {
                pCur = pCur->pTnext;
            }
        }
    }
    return pListTwo;
}
 

int main()
{
    int nA = 123;
    int nB = 888;
    int nC = 234;
    int nD = 555;
    MyList* pList = CreateList();//测试过了pList值是有的


    ListTextTwo(pList);
    ListTextTwo(pList);
    ListWord(pList);

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
好的,我们可以举一个链表排序的实际例子,该链表包含多个节点,每个节点有一个整数。我们使用冒泡排序对该链表进行排序,具体步骤如下: 1. 定义两个指针,分别称为 "当前节点" 和 "前驱节点",并初始化为链表的头结点和 NULL。 2. 在一个 while 循环中,外层循环从头结点开始,内层循环从当前节点的下一个节点开始,依次比较相邻两个节点大小,并交换它们的位置,直到内层循环结束。 3. 每次内层循环结束后,当前节点指针指向下一个节点,前驱节点指针指向当前节点,直到当前节点指针指向 NULL,表示已经遍历完整个链表。 4. 最后得到的链表即为排序后的链表。 下面是具体的代码实现: ```c++ // 定义链表节点结构体 struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; // 冒泡排序 ListNode* bubbleSortList(ListNode* head) { if (head == NULL || head->next == NULL) { return head; } ListNode *cur = head, *pre = NULL; while (cur != NULL) { ListNode *p = head; ListNode *q = p->next; while (q != NULL) { if (p->val > q->val) { ListNode *temp = p; p = q; q = temp; if (pre != NULL) { pre->next = p; } else { head = p; } temp = p->next; p->next = q->next; q->next = temp; } pre = p; p = p->next; q = q->next; } cur = cur->next; } return head; } ``` 需要注意的是,在实现过程中需要注意边界条件,以及交换节点时需要注意保留前驱节点的指针。此外,该实现并不包含头结点,即头结点不参与排序
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值