单链表实现排序算法（C语言）

已于 2022-03-31 11:23:45 修改
阅读量1.8k 收藏 21
点赞数 6
分类专栏： 数据结构与算法 文章标签： c语言 链表 数据结构 排序算法
于 2022-02-18 19:34:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43686863/article/details/123009923
版权

文章目录


在这里插入图片描述 

输入样例：
5
4 5 3 2 9
6
1 3 5 7 9 2
0

输出样例：
2 3 4 5 9
1 2 3 5 7 9

简单选择排序

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

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode, *LinkList;

void list_init(LinkList *L);

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_selection_sort(LinkList L);

void listSelectionSort(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList L = NULL;
        list_init(&L);

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        /*list_selection_sort(L);*/
        listSelectionSort(L);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

void list_init(LinkList *L) {
    *L = (LNode *) malloc(sizeof(LNode));

    (*L)->data = 0;
    (*L)->next = NULL;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;//avoid wild pointer
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

/**
 * 基于结点交换的选择排序
 * @param L
 */
void list_selection_sort(LinkList L) {
    LNode *p = L, *q, *tmp;
    LNode *min_prior_position;//min_prior_position->next->data == min_value

    while (p->next) {
        min_prior_position = p;
        q = p->next;
        /*find the minimum value*/
        while (q->next) {
            if (q->next->data < min_prior_position->next->data) {
                min_prior_position = q;
            }
            q = q->next;
        }
        /*swap*/
        if (min_prior_position != p) {
            if (p->next == min_prior_position) {//the values to be exchanged are adjacent
                p->next = min_prior_position->next;
                min_prior_position->next = min_prior_position->next->next;
                p->next->next = min_prior_position;
            } else {
                tmp = p->next->next;
                p->next->next = min_prior_position->next->next;
                min_prior_position->next->next = tmp;
                tmp = p->next;
                p->next = min_prior_position->next;
                min_prior_position->next = tmp;
            }
        }

        p = p->next;
    }
}

/**
 * 将单链表分割为两部分
 * 每次从后一个链表中选取一个最小元素结点插入到前一个链表尾部
 * @param L
 */
void listSelectionSort(LinkList L) {
    LNode *fakeHead = (LNode *) malloc(sizeof(LNode)), *tail = L, *minPos, *cursor, *tmp;

    fakeHead->next = L->next;
    L->next = NULL;
    while (fakeHead->next) {
        minPos = fakeHead;//minPos->next对应的结点为最小值结点
        for (cursor = fakeHead; cursor->next; cursor = cursor->next) {
            if (cursor->next->data < minPos->next->data) {
                minPos = cursor;
            }
        }
        /*将minPos->next对应的结点插入到前一个链表的尾部*/
        tail->next = minPos->next;
        minPos->next = minPos->next->next;
        tail = tail->next;
        tail->next = NULL;
    }
    free(fakeHead);
}

冒泡排序

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

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode, *LinkList;

void list_init(LinkList *L);

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

int list_count(LinkList L);

void list_bubble_sort(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList L = NULL;
        list_init(&L);

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        list_bubble_sort(L);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

void list_init(LinkList *L) {
    *L = (LNode *) malloc(sizeof(LNode));

    (*L)->data = 0;
    (*L)->next = NULL;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;//avoid wild pointer
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

int list_count(LinkList L) {
    LNode *p = L->next;
    int len = 0;

    while (p) {
        p = p->next;
        len++;
    }
    return len;
}

void list_bubble_sort(LinkList L) {
    LNode *cursor, *tmp;
    int len = list_count(L);

    for (int i = 0; i < len; i++) {
        cursor = L;
        for (int j = 0; j < len - i - 1; j++) {
            if (cursor->next->data > cursor->next->next->data) {
                /*swap node, not value*/
                tmp = cursor->next;
                cursor->next = tmp->next;
                tmp->next = tmp->next->next;
                cursor->next->next = tmp;
            }
            cursor = cursor->next;
        }
    }
}

直接插入排序

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

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode, *LinkList;

void list_init(LinkList *L);

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_insertion_sort(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList L = NULL;
        list_init(&L);

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        list_insertion_sort(L);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

void list_init(LinkList *L) {
    *L = (LNode *) malloc(sizeof(LNode));

    (*L)->data = 0;
    (*L)->next = NULL;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;//avoid wild pointer
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_insertion_sort(LinkList L) {
    if (!L->next) return;//empty

    LNode *left, *right = L->next->next, *tmp;

    L->next->next = NULL;
    while (right) {
        left = L;
        while (left->next && left->next->data < right->data) {
            left = left->next;
        }
        tmp = right->next;
        right->next = left->next;
        left->next = right;
        right = tmp;
    }
}
呦，又写BUG呢
关注
  • 6
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言实现单链表算法示例分享
09-04
"c语言实现单链表算法示例分享" 单链表是一种基础的数据结构，在计算机...* 算法实现：单链表可以用于实现算法，例如查找算法、排序算法等。 c语言实现单链表算法示例可以帮助开发者更好地理解单链表的实现和应用。
数据结构 单链表的生成算法 c语言实现
06-21
本篇将详细探讨单链表的生成算法及其C语言实现。 单链表是由一系列节点构成的，每个节点包含两部分：数据域，用于存储数据；指针域，指向下一个节点的地址。链表的头节点通常用来初始化链表，并通过其指针域指向...
数组、单链表冒泡排序——C语言实现
m0_47329175的博客
08-30 2225
数组冒泡排序 冒泡排序的原理 从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 举例 假如有一堆数据： 进行第一轮比较 第一次：80与31比较，80 > 31，交换 第二次:80与-4比较，80 > -4，交换 第三次:80与36比较，80 > 36，交换 第四次:80与-8比较，80 > -8，交换 此时，第一轮结束，最大值80已经到了最右边，一共进行了四次比较 第二轮比较 （下面就不添加图片了） 第一
数据结构之单链表的排序（C语言实现）
qq_42752472的博客
11-05 6086
数据结构之单链表的排序 一、 实现的步骤 1、生成一个单链表 2、对生成的链表排序 二、实现代码 #include
c语言单链表归并排序算法,归并排序链表实现
weixin_39681621的博客
05-21 148
该楼层疑似违规已被系统折叠隐藏此楼查看此楼void sort() {//其意义是if(empty() || size()==1 ) 但是这样做没有效率if (node->next == node || node->next->next == node)return;list carry;//缓冲链表list counter[64];//链表数组,也是缓冲数组的counter[i...
【数据结构与算法】单链表的排序算法(选择，冒泡，递归）
摸鱼小小虫的博客
11-27 6492
链表的选择排序思想与数组的排序类似，但是链表需要先找到里面最小或者最大的值，然后将这个值用改链语句进行操作。接下来我们进行排序，首先选取一个基准点，如何将比基准点大/小的值放左边，比基准点小/大的放右边。我们先看这个改链语句的操作（min是笔者打错了应该是max，但是图已经画好了就没有改）移动q这个指针找到最大的min，然后利用i保存q的前一个节点这样就能找到min_on.数组快速排序的思想和链表的一样，主要问题就是存在改链的操作。然后我们就可以将链表进行排序了，完整的代码如下。此时我们将2下沉到底部；
基于单链表的快速排序算法（C语言实现）
GeBrother的博客
01-19 2423
利用C语言实现单向链表的快速排序算法
一种单链表递增排序算法（C语言）
weixin_43638873的博客
04-10 848
LinkList BiggerSort(LinkList &L) { LNode* pre=L,*k=L,*minpre=L,*q; while(pre->next->next) { while(pre->next) { if(pre->next->data<minpre->next->data)minpre=pre; pre=pre->next; } q=minpre->next; minpre-&g
c语言单链表冒泡排序的步骤,单链表实现冒泡排序算法（C实现）
weixin_35662417的博客
05-20 1411
本实现主要采用交换指针的方法，其中附加有单链表及其相关的实现#include struct Node;typedef struct Node *PtrToNode;typedef PtrToNode List;typedef PtrToNode Position;typedef int ElementType;struct Node{ElementType Element;Position Nex...
冒泡排序算法的单链表实现
qi_ming_hao_nan的博客
03-10 3339
引言： 这几天都在忙着参加几个工作室（别问为什么是“几个”，问就是海投）的考核，报的都是后台组。后台的考核中必定是少不了单链表ADT和排序算法的。本专栏将专攻排序算法部分。注意，是排序算法的单链表实现，而不是数组排序喔！ 强烈建议有排序算法基础的人群食用。“基础”是指了解了这些排序算法如何在数组排序中编写。 那么，废话不多说，开始。 正文： 1）有关冒泡排序算法：这是个很形象的算法，因为用它排...
C语言版--单链表排序，冒泡排序，选择排序，插入排序，快速排序，应有尽有，保证看懂，没有bug!交换节点版本！
AABond的博客
08-13 6624
C语言版--单链表排序，冒泡排序，选择排序，插入排序，快速排序，应有尽有，保证看懂,没有bug! 交换节点版本！
单链表排序算法C语言版
03-27
单链表排序,是C语言版的，供初学者参考，有问题请留言。
C语言单链表实现方法详解
08-27
C语言单链表实现方法详解 单链表是一种基本的数据结构，在C语言中实现单链表可以提高程序的效率和灵活性。本文将详细介绍C语言单链表的实现方法，包括单链表的定义、创建、添加、删除、排序、打印等操作技巧，并...
常见数据结构与算法C语言实现
最新发布
05-04
# 常见数据结构与算法C语言实现 内容包含常见基本数据结构实现（C语言版）如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等 以及包含各个数据结构常见算法题的解答（C语言版...
入栈和出栈的基本操作
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-18 3859
入栈和出栈的基本操作，输入-1表示出栈，否则入栈，出栈若失败输出error并退出本轮循环。
数据结构编程练习（二叉树）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
02-16 2921
1.基于二叉链表的二叉树的遍历 2.基于二叉链表的二叉树高度的计算 3.基于二叉链表的二叉树结点个数的统计 4.基于二叉链表的二叉树左右孩子的交换 5.二叉排序树的判定 6.基于二叉链表的二叉树最大宽度的计算
剑指 Offer 58 - II. 左旋转字符串
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
04-14 2837
剑指 Offer 58 - II. 左旋转字符串
基于链表的两个非递减有序序列的合并
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-16 2319
将两个非递减有序序列合并为另一个非递增有序序列。
单链表排序c语言代码
10-12
以下是单链表排序的C语言代码： ```c #include <stdio.h> #include <stdlib.h> struct ListNode { int val; struct ListNode *next; }; struct ListNode* insertionSortList(struct ListNode* head) { if (head == NULL || head->next == NULL) { return head; } struct ListNode *dummy = (struct ListNode *)malloc(sizeof(struct ListNode)); dummy->next = head; struct ListNode *cur = head->next, *pre = head; while (cur != NULL) { if (cur->val >= pre->val) { pre = cur; cur = cur->next; } else { pre->next = cur->next; struct ListNode *p = dummy; while (p->next->val < cur->val) { p = p->next; } cur->next = p->next; p->next = cur; cur = pre->next; } } return dummy->next; } int main() { struct ListNode *head = (struct ListNode *)malloc(sizeof(struct ListNode)); head->val = 4; head->next = (struct ListNode *)malloc(sizeof(struct ListNode)); head->next->val = 2; head->next->next = (struct ListNode *)malloc(sizeof(struct ListNode)); head->next->next->val = 1; head->next->next->next = (struct ListNode *)malloc(sizeof(struct ListNode)); head->next->next->next->val = 3; head->next->next->next->next = NULL; struct ListNode *sortedList = insertionSortList(head); while (sortedList != NULL) { printf("%d ", sortedList->val); sortedList = sortedList->next; } printf("\n"); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值