精华内容
下载资源
问答
  • c语言链表排序

    2012-02-07 18:30:28
    c语言链表排序的方法,包括选择排序,直接插入排序,冒泡排序等
  • C语言 链表数据的排序

    千次阅读 2021-02-25 22:04:49
    下边介绍使用链表时可用的排序方法,冒泡排序和选择排序。 此链表排序仅对链表中的数据进行排序,如果想进行对整个结构体的排序,也就是利用数据顺序来调整节点中的信息,需要对节点进行交换,但与此方法不同,望...

    C语言使用链表时,有些时候会对链表中的数据进行排序。下边介绍使用链表时可用的排序方法,冒泡排序和选择排序。

    此链表排序仅对链表中的数据进行排序,如果想进行对整个结构体的排序,也就是利用数据顺序来调整节点中的信息,需要对节点进行交换,但与此方法不同,望读者周知。

    测试排序代码请先参考下边完整的测试代码。
    编程环境:Visual C++ 6.0.

    冒泡排序

    NODE* bubblesort(NODE* Head) 
    {
        NODE *pfirst=NULL,*psecond=NULL,*pend=NULL;
        pfirst=Head;
    	psecond=Head;
    	int temp;
        while(pfirst != pend)          //外循环
    	{							   //pfirst != pend 很有意思
            while(pfirst->next != pend)//内循环
    		{
                if(pfirst->date > pfirst->next->date)
    			{
                    temp=pfirst->date;  
                    pfirst->date=pfirst->next->date;
                    pfirst->next->date=temp;
                }
                   pfirst=pfirst->next;
            }
            pend=pfirst;//减少最后的已排好的循环
            pfirst=Head;
        }
        return Head;
    }
    

    选择排序

    /*链表的选择排序*/
    
    NODE* selectsort(NODE* head) 
    {
    	NODE *pfirst=NULL,*psecond=NULL,*pend=NULL;
        pfirst=head;
    	psecond=head;
    	int temp;
        while(pfirst != pend)          //外循环
    	{
            while(pfirst->next != pend)//内循环
    		{
                if(psecond->date > pfirst->next->date)
    			{
                    temp=psecond->date;  
                    psecond->date=pfirst->next->date;
                    pfirst->next->date=temp;
                }
                   pfirst=pfirst->next;
            }
    		psecond=psecond->next;
            pfirst=psecond;
        }
    	return head;
    } 
    
    

    测试代码

    /*
     *链表排序 Writen by YU
     */
    #include<stdio.h>
    #include<stdlib.h>
    
    /*结果输出查看*/
    void endscan()
    {
    	printf("\n点击回车继续...");
    	fflush(stdin);
    	getchar();
    }
    
    /*结构体*/
    struct node
    {
        int date;
        struct node *next;
    };
    
    typedef struct node NODE;  //把struct node 定义为 NODE
    int count = 0;
    
    /*创建链表并输入数据*/
    NODE* creat()
    {
        NODE *pHead=NULL,*pNew,*pEnd;
    
        printf("输入数据,当输入0时停止\n");
    
        pNew=(NODE*)malloc(sizeof(NODE));
        scanf("%d",&pNew->date);
        while(pNew->date != 0)
    	{
            count++;
            if(count == 1) //如果为头节点
    		{
                pNew->next = NULL;
                pEnd = pNew;
                pHead = pNew;
            }
    		else           //如果不是头结点
    		{
                pNew->next=NULL;
                pEnd->next=pNew;
                pEnd=pNew;
            }
                pNew=(NODE*)malloc(sizeof(NODE));
                scanf("%d",&pNew->date);
        }
            free(pNew);
        return pHead;
    }
    
    /*输出链表*/
    void print(NODE* Head)
    {
        NODE* p=Head;
        while(p!=NULL)
    	{
            printf("%d ",p->date);
            p=p->next;
        }
    }
    
    /*链表的冒泡排序*/
    NODE* bubblesort(NODE* Head) 
    {
        NODE *pfirst=NULL,*psecond=NULL,*pend=NULL;
        pfirst=Head;
    	psecond=Head;
    	int temp;
        while(pfirst != pend)          //外循环
    	{							   //pfirst != pend 很有意思
            while(pfirst->next != pend)//内循环
    		{
                if(pfirst->date > pfirst->next->date)
    			{
                    temp=pfirst->date;  
                    pfirst->date=pfirst->next->date;
                    pfirst->next->date=temp;
                }
                   pfirst=pfirst->next;
            }
            pend=pfirst;//减少最后的已排好的循环
            pfirst=Head;
        }
        return Head;
    }
    
    /*链表的选择排序*/
    
    NODE* selectsort(NODE* head) 
    {
    	NODE *pfirst=NULL,*psecond=NULL,*pend=NULL;
        pfirst=head;
    	psecond=head;
    	int temp;
        while(pfirst != pend)          //外循环
    	{
            while(pfirst->next != pend)//内循环
    		{
                if(psecond->date > pfirst->next->date)
    			{
                    temp=psecond->date;  
                    psecond->date=pfirst->next->date;
                    pfirst->next->date=temp;
                }
                   pfirst=pfirst->next;
            }
    		psecond=psecond->next;
            pfirst=psecond;
        }
    	return head;
    } 
    
    int main()
    {
        NODE* pHead=NULL;
        pHead=creat();
        printf("排序前:\n");
        print(pHead);
    //	pHead=bubblesort(pHead); //冒泡排序
    	pHead=selectsort(pHead); //选择排序
        printf("\n排序后:\n");
        print(pHead);
    	endscan();
        return 0;
    }
    
    展开全文
  • c语言实现链表排序,利用选择排序的思想,可以供大家学习。
  • //链表排序 从小到大排 选择排序 void sortList(Node* head) { printf("------进行排序------\r\n"); Node *p1,*p2,*p3,*temp; if((temp=(Node*)malloc(sizeof(Node)))==NULL) { printf("sort create error"); ...
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h> //用到了time函数
    
    #define arraySize 10
    
    
    typedef int elemType;
    
    typedef struct List
    {
        elemType elem;
        struct List *next;
    }Node;
    
    //产生随机数组
    void createRandomArray(int array[])
    {
        int i,number;
        srand((unsigned) time(NULL)); //用时间做种,每次产生随机数不一样
        for (i=0; i<arraySize; i++)
        {
            array[i] = rand() % 101; //产生0-100的随机数
        }
    }
    
    //创建单链表
    struct List *createList(int num,int arrayList[])
    {
        Node *head,*p1,*p2;
        if((head=(Node*)malloc(sizeof(Node)))==NULL)
        {
            printf("create error\r\n");
            exit(0);
        }
        head->elem=0;
        head->next=NULL;
        p1=head;
        int i;
        for(i=0;i<num;i++)
        {
            if((p2=(Node*)malloc(sizeof(Node)))==NULL)
            {
                printf("create error\r\n");
                exit(0);
            }
            p2->elem=arrayList[i];
            p2->next=NULL;
            p1->next=p2;
            p1=p2;
        }
        return head;
    }
    
    //遍历单链表
    void displayList(Node *head)
    {
        printf("遍历链表:");
        Node *p1;
        if(head==NULL)
        {
            printf("空链表\r\n");
            //exit(0);
        }
        else
        {
            for(p1=head->next;p1!=NULL;p1=p1->next)
            {
                printf("%d\t",p1->elem);
            }
            printf("\r\n");
        }
    }
    
    //判断链表是否为空
    bool isEmptyList(Node* head)
    {
        return head==NULL;//||head->next==NULL;
    }
    
    //链表排序  从小到大排 选择排序
    void sortList(Node* head)
    {
        printf("------进行排序------\r\n");
        Node *p1,*p2,*p3,*temp;
        if((temp=(Node*)malloc(sizeof(Node)))==NULL)
        {
            printf("sort create error");
        }
        p1=head;
        //int i=0,j=0;//调试
        for(p2=p1->next;p2->next!=NULL;p2=p2->next)
        {
    		for(p3=p2->next;p2!=NULL;p3=p3->next)
            {
                if(p2->elem>p3->elem)
                {
                    temp->elem=p3->elem;
                    p3->elem=p2->elem;
                    p2->elem=temp->elem;
                }
    //			i++;
    //            printf("i:%d\t",i);
    			if(p3->next==NULL)
    				break;
            }
    //		j++;
    //        printf("j:%d\t",j);
    	}
    }
    
    int main()
    {
        Node *head;
        elemType temp;
        int arrayList[arraySize];
        createRandomArray(arrayList);
        head=createList(arraySize,arrayList);
        printf("排序前\r\n");
        displayList(head);
        sortList(head);
        printf("排序后\r\n");
        displayList(head);
        return 0;
    }
    

    展开全文
  • C语言——链表排序

    2019-08-24 15:15:29
    交换节点:插入排序,冒泡排序,简单选择排序 交换数据:快速排序 初始化: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> //节点结构 struct node { int val;...

    单链表排序

     

    前言:

    最近总结了一下针对只有头结点的单链表进行排序的几个简单的方法。

    交换节点:插入排序,冒泡排序,简单选择排序
    交换数据:快速排序

    初始化:

    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    
    //节点结构
    struct node
    {
        int val;
        struct node * next;
    };
    typedef struct node node, * list;
    
    //打印函数
    void printList(list mylist);
    //排序函数
    //插入排序
    void insertSort(list mylist);
    //冒泡排序
    void bubbleSort(list mylist);
    //简单选择
    void selectSort(list mylist);
    //快速排序
    void quickSort(list mylist);
    
    int main(void)
    {
        int arr[] = {5, 1, 7, 4, 2, 9, 6, 3, 8};
        //程序都是针对有头结点的单向链表
        list mylist = (list)malloc(sizeof(node));
        mylist -> val = 0;
        mylist -> next = NULL;
        int len = sizeof(arr) / sizeof(arr[0]);
        int i = 0;
        node * cur = mylist;
        while(i < len)
        {
            node * newNode = (node *)malloc(sizeof(node));
            newNode -> val = arr[i];
            newNode -> next = NULL;
            cur -> next = newNode;
            cur = cur -> next;
            i ++;
        }
        //insertSort(mylist);
        //bubbleSort(mylist);
        //selectSort(mylist);
        quickSort(mylist);
        printList(mylist);
    
        return 0;
    }
    
    void printList(list mylist)
    {
        node * cur = mylist -> next;
        while(cur != NULL)
        {
            printf("%d ", cur -> val);
            cur = cur -> next;
        }
        printf("\n");
    }
    

    一、交换节点的单链表排序:

    交换节点的情况比较复杂,所以我只是写了比较简单的三个。

    1 、插入排序:

    //=============插入排序====================
    void insertSort(list mylist)
    {
        if((mylist -> next == NULL) || (mylist -> next -> next == NULL))
        {   
            return;
        }   
    
        node * head, * p1, * prep1, * p2, * prep2, * temp;
        head = mylist;
        prep1 = head -> next;
        p1 = prep1 -> next;
        //prep1和p1是否需要手动后移
        bool flag;
    
        while(p1 != NULL)
        {   
            flag = true;
            temp = p1; 
            //由于是单向链表,所以只能从头部开始检索
            for(prep2 = head, p2 = prep2 -> next; p2 != p1; prep2 = prep2 -> next, p2 = p2 -> next)
            {   
                //发现第一个较大值
                if(p2 -> val > p1 -> val) 
                {   
                    p1 = p1 -> next;
                    prep1 -> next = p1; 
                    prep2 -> next = temp;
                    temp -> next = p2; 
                    flag = false;
                    break;
                }   
            }   
            //手动后移prep1和p1
            if(flag)
            {   
                prep1 = prep1 -> next;
                p1 = p1 -> next;
            }   
        }   
    }
    //=============插入排序====================
    

    2、冒泡排序:

    //=============冒泡排序====================
    void bubbleSort(list mylist)
    {
        if((mylist -> next == NULL) || (mylist -> next -> next == NULL))
        {
            return;
        }
    
        node *head, * pre, * cur, *next, * end, * temp;
        head = mylist;
        end = NULL;
        //从链表头开始将较大值往后沉
        while(head -> next != end)
        {
            for(pre = head, cur = pre -> next, next = cur -> next; next != end; pre = pre -> next, cur = cur -> next, next = next -> next)
            {
                //相邻的节点比较
                if(cur -> val > next -> val)
                {
                    cur -> next = next -> next;
                    pre -> next = next;
                    next -> next = cur;
                    temp = next;
                    next = cur;
                    cur = temp;
                }
            }
            end = cur;
        }
    }
    //=============冒泡排序====================

    简单选择排序:

    //=============简单选择排序================
    void selectSort(list mylist)
    {
        if((mylist -> next == NULL) || (mylist -> next -> next == NULL))
        {
            return;
        }
    
        node * head, * prep1, * p1, * prep2, * p2, * premin, * min, * temp;
        head = mylist;
        for(prep1 = head, p1 = prep1 -> next; p1 -> next != NULL; prep1 = prep1 -> next, p1 = prep1 -> next)
        {
            //保存最小节点
            premin = prep1;
            min = p1;
            for(prep2 = p1, p2 = prep2 -> next; p2 != NULL; prep2 = prep2 -> next, p2 = prep2 -> next)
            {
                if(min -> val > p2 -> val)
                {
                    premin = prep2;
                    min = p2;
                }
            }
    
            if(p1 != min)
            {
                //一定要注意这个情况
                if(p1 -> next == min)
                {
                    temp = min -> next;
                    prep1 -> next = min;
                    min -> next = p1;
                    p1 -> next = temp;
                }else{
                    temp = min -> next;
                    prep1 -> next = min;
                    min -> next = p1 -> next;
                    premin -> next = p1;
                    p1 -> next = temp;
                }
            }
        }
    }
    //=============简单选择排序================
    

    一、交换数据的单链表排序:

    交换数据的排序方式就特别简单了,因为不用考虑前驱和后继,只需要标记待交换的两个节点即可。因此在这里就直接介绍一下快速排序。

    快速排序:

    //=============快速排序====================
    
    //交换节点
    void swap(node * a, node * b)
    {
        int temp = a -> val;
        a -> val = b -> val;
        b -> val = temp;
    }
    
    //求中间点
    node * partion(node * start, node * end)
    {
        if(start == end || start -> next == end)
        {   
            return start;
        }   
        //取第一个元素作为基准元素
        node * p = start, * q = start, * refer = start;
        //从start开始向后进行一次遍历(因为是单链表,无法按从左右向中间遍历的方法)
        while(p != end)
        {   
            if(q -> val < refer -> val) 
            {   
                p =  p -> next;
                swap(p, q); 
            }   
            q = q -> next;
        }   
        swap(p, refer);
        return p;
    }
    //递归
    void quick_sort(node * start, node * end)
    {
        if(start == end || start -> next == end)
        {   
            return;
        }   
        node * mid = partion(start, end);
        quick_sort(start, mid);
        quick_sort(mid -> next, end);
    }
    
    void quickSort(list mylist)
    {
        if((mylist -> next == NULL) || (mylist -> next -> next == NULL))
        {
            return;
        }
        node * start = mylist -> next;
        node * end = NULL;
        quick_sort(start, end);
    }
    //=============快速排序====================

    参考:

    1、链表的基本排序——C语言
    2、 单链表排序—-快排 & 归并排序

    展开全文
  • printf("请选择排序标准(输入选项前数字):"); scanf("%d",&n); if(n==1) { pfirst = NULL; while (head != NULL) /*在链表中找键值最小的节点。*/ { for (p = head, pmin = head; p->next != NULL; ...
  • 链表排序讲解: head指针指向链表的头结点,是找到整个链表的唯一依据,如果head指针丢失,整个链表就找不到了。 head存储的是第一个节点的...单向链表选择排序图示: ---->[1]---->[3]---->[2]...--...

     

    链表排序讲解:

    head指针指向链表的头结点,是找到整个链表的唯一依据,如果head指针丢失,整个链表就找不到了。

     head存储的是第一个节点的地址,head->next存储的是第二个节点的地址;  任意一个节点p的地址,只能通过它前一个节点的next来求得。

     

    单向链表的选择排序图示: ---->[1]---->[3]---->[2]...---->[n]---->[NULL](原链表)

                                            head   1->next  3->next  2->next   n->next

     选择排序(Selection sort)是一种简单直观的排序算法。

    首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。

    动画演示:http://www.nowamagic.net/librarys/veda/detail/1849

     

    选择排序

    定义的结构体

    struct student
    {  
    char ID[11]; //学生学号
    char name[20];  //学生姓名
     
    struct student *next;  //next 指针 指向 struct  student 类型的变量
    }stu;
    
     

     

    里面的变量均为数组

    那怎么实现结构体中定义(有)数组变量,链表遍历结构体,按照结构体里面变量来排序呢?

    其中对数组比较大小、比较两个字符串的大小来使用的函数是: strcmp()  也就是string compare字符串比较。

    对数组之间的赋值函数是 strcpy()  ==="string copy"

     

     

    升序:

    /***************
    
    函数功能:
    升序排列出勤学生
    返回:指向链表表头的指针
    
    /***************/
    
    
    struct student *sort_message_order(struct student* head) //升序  按照ID顺序
    
    {   
        struct student *Back,*pointer; //p指针指向新的节点 back指针指向链表的尾节点
        struct student  temp; // 定义结构体student别名,typedef也可以定义的结构体别名
        Back=head->next; 
        pointer=head->next; //跳过头结点 指向下一个节点 头结点中没有学生信息 
        while(Back!=NULL) //如果尾节点不为空 就一直遍历下去
        {
            while(pointer->next!=NULL) //如果指向新开辟的结点不为空就一直遍历下去
            {
                pointer=pointer->next; //指向下一个新开辟的结点
                if ( strcmp( Back->ID,pointer->ID)>0  )  //如果back->ID大于pointer->ID就返回大于0的值;后面大于前面的 往后放
                {
                    strcpy(temp.ID,Back->ID);
                    strcpy(temp.name,Back->name);  //把尾节点值赋值给临时temp结构体变量
                    
                    
                    strcpy( Back->ID,pointer->ID);
                    strcpy(Back->name,pointer->name); //把指向的新节点 跟尾节点交换 位置
                    
                    
                    strcpy(pointer->ID,temp.ID);
                    strcpy(pointer->name,temp.name);//将临时temp结构体变量赋值给指向的结构体变量
                    
                }
            }
            Back=Back->next; //指向下一个尾节点
            pointer=Back;  //指向尾节点
        }
        return head;  //返回头结点
        
    }

     

     

    降序:

    /***************
    
    函数功能:
    降序排列出勤学生
    返回:指向链表表头的指针
    
    /***************/
    
    struct student * sort_message_Desc(struct student* head)//Descending降序
    {
        struct student *Back,*pointer; //p总是指向新申请的结点  back总是指向链表的尾节点
        struct student  temp;
        Back=head->next;
        pointer=head->next;//跳过头结点,头结点中没有学生信息
        while(Back!=NULL)
        {
            while(pointer->next!=NULL)
            {
                pointer=pointer->next;
    
                if ( strcmp( Back->ID,pointer->ID)<0  ) // back->ID小于pointer->ID返回负数 把最小的 往后放  降序
                {
                    strcpy(temp.ID,Back->ID);
                    strcpy(temp.name,Back->name);     //把尾节点值赋值给临时temp结构体变量
                    
                    strcpy( Back->ID,pointer->ID);
                    strcpy(Back->name,pointer->name); //指向的新节点 跟尾节点交换 位置
                                
                    strcpy(pointer->ID,temp.ID);
                    strcpy(pointer->name,temp.name);  //将临时temp结构体变量赋值给指向的结构体变量
                }
            }
            Back=Back->next; //指向下一个尾节点
            pointer=Back;   //指向尾节点
        }
        return head;  //返回头结点
    }

     

     

    输出打印链表内容:

    void Print_List(struct student *head)
    {
        struct student* pointer;
        pointer=head->next; //跳过无数据的头结点
        while(pointer!=NULL)
            {  
                printf(" ",pointer->ID);
                printf(" ",pointer->name);
                 
                pointer=pointer->next;//指向下一个节点
            }     
    }

     

     

     

    转载于:https://www.cnblogs.com/zhaocundang/p/4779563.html

    展开全文
  • #include <stdio.h> #include <string.h> #include <stdlib.h> struct student{ char name[16]; int score; struct student *next; }; struct student *head=NULL, *p, *t...struct studen...
  • c语言关于使用链表排序(选择排序、冒泡排序)

    万次阅读 多人点赞 2018-01-26 10:04:25
    链表冒泡排序 比较两个相邻的元素大小,每一趟会把较大(或较小)的数放在往后移。链表冒泡排序思想:设置两个指针,一个是当前指针,一个是尾指针,当前的指针指向头节点,将尾指针赋为空,当当前的指针不等于尾...
  • C语言结构体链表的排序方法汇总 ========================== 功能:选择排序(由小到大) 返回:指向链表表头的指针 ========================== */ /* 选择排序的基本思想就是反复从还未排好序的那些节点中, ...
  • 因为在以前做过数组的选择排序,所以本来以为链表差不多,但是在实际操作的时候出现了很多问题。 1.首先是怎么交换位置,诚然,利用改变指针的指向可以交换节点,但是我觉得可以通过交换结构体的内容 代码,结构体...
  • 选择排序输出最大的值得位置 { int j , temp , p ; p = i ; for ( j = i + 1 ; j L . length ; j ++ ) { if ( L . elem [ p ] . key < L . elem [ j ] . key ) { p = j ; } } return ...
  • 课程设计:c语言链表

    2020-06-05 19:47:58
    目录 ...9)实现链表排序的功能函数。 9 10)实现链表文件读取的功能函数 10 11)实现链表文件存储的功能函数。 11 12)实现菜单选择的功能函数。 11 (四)系统演示及使用说明 12 1).菜单选项 12 2
  • 链表选择排序/********************************* 链表的排序 *******************************************/ /* ========================== 功能:选择排序(由小到大) 返回:指向链表表头的指针 ==========...
  • c语言选择排序

    2013-03-28 08:42:58
    链表选择排序,挺好用的希望对你的学习有帮助
  • 这里使用插入排序法,因为插入排序法涉及有序区域的后移,所以比较适合使用链表进行做。因为单链表没有prev的默认指针,所以不方便使用快速排序法。综合选择了插入排序 算法草稿 代码实现 int insertSortList...
  • 选择排序法的基本原理是:每一趟排序从当前未排好序的那些元素中选择一个值最小的 元素,将其与未排好序的那些元素的第一个元素交换位置。请根据该原理写出对一个带有头 结点的单链表按数据域值从小到大进行选择排序的...
  • 本代码实现了单链表的创建(头插法与尾插法)、单链表的遍历、插入节点、删除节点、 判断表空表满、求表长度、选择算法排序等功能
  • 采用C语言实现链表的创建、排序和输出,并提供了两种排序的方式可供选择!!亲测可以运行!
  • 1.3 选择排序算法 1.4 简单排序算法的复杂性 2 快速排序算法 2.1 算法基本思想及实现 2.2 算法的性能 2.3 随机快速排序算法 2.4 非递归快速排序算法 2.5 三数取中划分算法 2.6 三划分快速排序算法 3 合并排序算法 ...
  • C语言单链表实现选择排序

    千次阅读 2019-03-12 12:00:27
    链表实现选择排序有两种方法,一种是交换节点内的数据,比较简单。我这里使用的是第二种方法,交换节点。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #...
  • 选择排序 { struct Student *f=NULL,*t=NULL, *max, *maxbf=NULL, * p; while (h!= NULL) { for (p = h, max = h; p->next != NULL; p = p-> next) { if (p->next->score > max-> score) { ...
  • 选择排序C语言

    2019-12-23 17:58:49
    选择排序C语言)直接选择排序算法思想程序数组实现链表实现二元选择排序算法思想程序 直接选择排序 算法思想 见:3. 选择排序—简单选择排序(Simple Selection Sort) 程序 数组实现 void swap(int *s1, int *s2...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 300
精华内容 120
关键字:

c语言链表选择排序

c语言 订阅