链表选择排序

「已注销」 2016-09-01 08:48:02
include<stdio.h>
#include<stdlib.h>
#include<string.h>
//#include<conio.h>
//清屏
typedef struct tamers
{
char tname[20];
int tno;
char tsex[2];
char tmuseum[10];
int tage;
char tshowtime[20];
char tshowname[20];
int ano;
struct tamers *next;
}TMR;
TMR*shuru();
int main()
{

TMR*head;
head = shuru();
return 0;
}
TMR*shuru()
{
TMR*head,*p,*q;
char tname[20];
p = (TMR *)malloc(sizeof(TMR));
head = p;
q = p;
q ->next = NULL;
printf("请输入驯养员信息 输入名字为'none'时结束：\n");
printf("名字：");
scanf("%s",&tname);
while(strcmp(tname,"none")!=0)
{
p = (TMR*)malloc(sizeof(TMR));
strcpy(p->tname,tname);
printf("编号：");
scanf("%s",&p->tno);
printf("性别：");
scanf("%s",&p->tsex);
printf("年龄：");
scanf("%d",&p->tage);
printf("场馆：");
scanf("%s",&p->tmuseum);
printf("表演时间：");
scanf("%s",&p->tshowtime);
printf("节目名称：");
scanf("%s",&p->tshowname);
printf("宠物编号：");
scanf("%d",&p->ano);
q->next=p;
q=q->next;
printf("请输入驯养员信息 输入名字为'none'时结束：\n");
printf("名字：");
scanf("%s",&tname);

}
q->next=NULL;
return head;
}



//******************
struct tamers *SelectSort(struct tamers *head)
{
TMR *pfirst; /* 排列后有序链的表头指针 */
TMR *ptail; /* 排列后有序链的表尾指针 */
TMR *pminBefore; /* 保留键值更小的节点的前驱节点的指针 */
TMR *pmin; /* 存储最小节点 */
TMR *pb; /* 当前比较的节点 */

pfirst = NULL;
while (head != NULL) /*在链表中找键值最小的节点。*/
{
/* 注意：这里for语句就是体现选择排序思想的地方 */
for (pb = head, pmin = head; pb->next != NULL; pb = pb->next) /*循环遍历链表中的节点，找出此时最小的节点。*/
{
if (pb->next->tno < pmin->tno) /*找到一个比当前min小的节点。*/
{
pminBefore = pb; /*保存找到节点的前驱节点：显然p->next的前驱节点是p。*/
pmin = pb->next; /*保存键值更小的节点。*/
}
}

/*上面for语句结束后，就要做两件事；一是把它放入有序链表中；二是根据相应的条件判断，安排它离开原来的链表。*/

/*第一件事*/
if (pfirst == NULL) /* 如果有序链表目前还是一个空链表 */
{
pfirst = pmin; /* 第一次找到键值最小的节点。 */
ptail = pmin; /* 注意：尾指针让它指向最后的一个节点。 */
}
else /* 有序链表中已经有节点 */
{
ptail->next = pmin; /* 把刚找到的最小节点放到最后，即让尾指针的next指向它。*/
ptail = pmin; /* 尾指针也要指向它。 */
}

/*第二件事*/
if (pmin == head) /* 如果找到的最小节点就是第一个节点 */
{
head = head->next; /* 显然让head指向原head->next,即第二个节点，就OK */
}
else /*如果不是第一个节点*/
{
pminBefore->next = pmin->next; /*前次最小节点的next指向当前pmin的next,这样就让pmin离开了原链表。*/
}
}

if (pfirst != NULL) /*循环结束得到有序链表first */
{
ptail->next = NULL; /*单向链表的最后一个节点的next应该指向NULL */
}
head = pfirst;
return head;
}








我想问一下，这个选择排序法我是在本站博客上学的，可是并不知道如何查看排序后的内容。
...全文
391 6 打赏 收藏 转发到动态 举报
写回复
用AI写文章
6 条回复
切换为时间正序
请发表友善的回复…
发表回复
赵4老师 2016-09-01
  • 打赏
  • 举报
 回复
仅供参考：
//不带表头结点的单向链表
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <locale.h>
struct NODE {
    int          data;
    struct NODE *next;
} *head,*p,*q,*s,*p1,*p2,*q1,**ta;
int i,k,n,t,m,v,N=10;
int main() {
    setlocale(LC_ALL,"chs");
    srand(time(NULL));

    head=NULL;

    printf("创建%d个节点的单链表:",N);//创建N个节点的单链表
    p=head;
    for (i=0;i<N;i++) {
        q=(struct NODE *)malloc(sizeof(struct NODE));
        if (NULL==q) exit(1);
        q->data=rand()%100;//填写0..99的随机值
        q->next=NULL;
        if (NULL==p) {
            head=q;
            p=head;
        } else {
            p->next=q;
            p=q;
        }
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    k=3;
    v=5;
    printf("将值为%d的结点插入到单链表的第%d个结点前:",v,k);//将值为v的结点插入到单链表的第k个结点前
    n=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        n++;
        if (k==1) {
            q=(struct NODE *)malloc(sizeof(struct NODE));
            if (NULL==q) exit(1);
            q->data=v;
            q->next=head;
            head=q;
            break;
        } else {
            if (k-1==n) {
                q=(struct NODE *)malloc(sizeof(struct NODE));
                if (NULL==q) exit(1);
                q->data=v;
                q->next=p->next;
                p->next=q;
                break;
            }
        }
        p=p->next;
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    k=5;
    printf("删除第%d个节点:",k);//删除第k个节点
    n=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        n++;
        if (k==1) {
            q=head;
            head=head->next;
            free(q);
            break;
        } else {
            if (k-1==n) {
                q=p->next;
                if (q) {
                    p->next=q->next;
                    free(q);
                }
                break;
            }
        }
        p=p->next;
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    printf("从小到大排序:");//从小到大排序
    for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {
        for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {
            if (p->data > q->data) {

                //交换data
//              printf("swap %02d %02d\n",p->data,q->data);
//              t=p->data;p->data=q->data;q->data=t;

                //或者

                //交换next
//              printf("swap %02d %02d\n",p->data,q->data);
                if (p==head) {//p是头
                    if (p->next==q) {//pq挨着
                        head=q;
                        p->next=q->next;
                        q->next=p;
                        q=p;
                        p=head;
                    } else {//pq不挨着
                        head=q;
                        p2=p->next;
                        p->next=q->next;
                        q->next=p2;
                        q1->next=p;
                        q=p;
                        p=head;
                    }
                } else {//p不是头
                    if (p->next==q) {//pq挨着
                        p1->next=q;
                        p->next=q->next;
                        q->next=p;
                        q=p;
                        p=p1->next;
                    } else {//pq不挨着
                        p1->next=q;
                        p2=p->next;
                        p->next=q->next;
                        q->next=p2;
                        q1->next=p;
                        q=p;
                        p=p1->next;
                    }
                }

                //输出整个单链表
//              s=head;
//              while (1) {
//                  if (NULL==s) {
//                      printf("\n");
//                      break;
//                  }
//                  printf("%02d->",s->data);
//                  s=s->next;
//              }
//              getchar();
            }
        }
    }

    //输出整个单链表并计算链表长度n
    n=0;
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        n++;
        s=s->next;
    }

    printf("将整个链表逆序:");//将整个链表逆序
    if (n>=2) {
        p=head;
        q=p->next;
        p->next=NULL;
        while (1) {
            q1=q->next;
            q->next=p;
            p=q;
            q=q1;
            if (NULL==q) break;
        }
        head=p;
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    m=4;
    n=6;
    printf("将单链表中前%d个结点和后%d个结点进行互换:",m,n);//将单链表中前m个结点和后n个结点进行互换,m+n为链表总长
    k=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        k++;
        if (m==k) {
            q=p;
        }
        s=p;
        p=p->next;
    }
    q1=head;
    head=q->next;
    s->next=q1;
    q->next=NULL;

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    //释放所有节点
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        q=p->next;
        free(p);
        p=q;
    }

    return 0;
}
//创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16->
//将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16->
//删除第5个节点:08->74->05->07->03->99->31->56->88->16->
//从小到大排序:03->05->07->08->16->31->56->74->88->99->
//将整个链表逆序:99->88->74->56->31->16->08->07->05->03->
//将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56->
//
小灸舞 版主 2016-09-01
  • 打赏
  • 举报
 回复
char tsex[2];
你光开2个字节是不够的（中文一般是占2~3个字节，看你的编码了），而且还有'\0'
你改成char tsex[4];试试
「已注销」 2016-09-01
  • 打赏
  • 举报
 回复
可是为什么在显示输出时，性别那一项输出不对，比如我输入性别是男，场馆是海洋馆，结果输出的性别就是，男海洋馆，场馆输出还是海洋馆正常。
小灸舞 版主 2016-09-01
  • 打赏
  • 举报
 回复
引用 2楼我是你的主体 的回复:
void output(TMR*p)
{
TMR *head=p;
if(p==0)
printf("null\n");
else
while(p!=0)
{
printf("姓名：%s;\t编号：%d;\t性别：%s;\t年龄：%d;\t场馆：%s;\t表演时间：%s;\t节目名称：%s;\t宠物编号：%d;\n",
p->tname,p->tno,p->tsex,p->tage,p->tmuseum,p->tshowtime,p->tshowname,p->ano);

p=p->next;
}
p=head;
}
这样再声明一个函数可以吗？
我排序的是编号，可以输出所有的信息么？
如果你排序没错的话，这样输出是可以的
「已注销」 2016-09-01
  • 打赏
  • 举报
 回复
void output(TMR*p)
{
TMR *head=p;
if(p==0)
printf("null\n");
else
while(p!=0)
{
printf("姓名：%s;\t编号：%d;\t性别：%s;\t年龄：%d;\t场馆：%s;\t表演时间：%s;\t节目名称：%s;\t宠物编号：%d;\n",
p->tname,p->tno,p->tsex,p->tage,p->tmuseum,p->tshowtime,p->tshowname,p->ano);

p=p->next;
}
p=head;
}
这样再声明一个函数可以吗？
我排序的是编号，可以输出所有的信息么？
paschen 2016-09-01
  • 打赏
  • 举报
 回复
方法一：排序后，将你要看的输出到控制台，可以使用printf 方法二：单步跟踪程序运行，每一步可以观察各变量的值
完整视频-coursera公开课 普林斯顿算法 ⅠⅡ部分
本资源为BT文件，下载速度快，如果P2P工具支持下载字幕可以进行下载 Coursera上的公开课，普林斯顿大学教授Robert Sedgewick主讲《Algorithms》算法 Java实现 课程网站http://algs4.cs.princeton.edu/home/ 视频一个两部分，算法（一）主要集中在基础的数据结构、排序、查找算法。 相关主题有：并查集算法，二分查找，栈，队列，背包，插入排序，选择排序，希尔排序，快速排序， 三切分快排，归并排序，堆排序，二分堆，二分查找树，红黑树，链表，线性哈希表，Graham扫描，kd树。 算法（二）主要讲解图论和字符串处理的相关算法。相关主题有：深度优先搜索，宽度优先搜索，拓扑排序，Kosaraju-Sharir算法，Kruskal算法，Prim算法，Dijkistra算法，Bellman-Ford算法, Ford-Fulkerson算法, LSD radix sort算法, MSD radix sort算法, 3-way radix 快排算法, 多路尝试法, 三元查找尝试法, Knuth-Morris-Pratt算法, Boyer-Moore算法, Rabin-Karp算法, 正则匹配, run-length编码, Huffman编码, LZW压缩, 还有Burrows-Wheeler变换。
万字长文，链表排序算法——冒泡排序、选择排序、插入排序、归并排序、快速排序、计数排序、桶排序、基数排序精讲及python实现
在数组排序中，常见的排序算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等。而对于链表排序而言，因为链表不支持随机访问，访问链表后面的节点只能依靠next指针从头部顺序遍历，所以相对于数组排序问题来说，链表排序问题会更加复杂一点。下面先来总结一下适合链表排序与不适合链表排序的算法：冒泡排序选择排序插入排序归并排序快速排序计数排序桶排序基数排序。希尔排序。堆排序。希尔排序为什么不适合链表排序？希尔排序：希尔排序中经常涉及到对序列中第。
C语言数据结构与算法编程、链表、树、栈、队列、排序算法
一个优秀的C语言开发大牛必定是擅长数据结构与算法的，所以数据结构是编程必学的内容之一！数据结构(Data Structure) ：是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关 系的数据元素的 集合。算法(Algorithm): 算法就是一系列高效的计算步骤，用来将输入数据转化成输出结果。数据结构用于解决数据存储问题，而算法用于处理和分析数据！黄老师通过对数据结构核心知识点： 顺序表、链表、栈、队列、树、二叉树、遍历、插入、删除、排序、查找算法 的细心讲解，结合生动的C语言实战代码演练、帮助学员快速掌握数据结构的核心内容、为STL、Boost标准库的学习、企业级算法开发打下坚实的基础！本课程适合有一定C语言基础编程的童鞋，对 C、C++数据结构与算法编程感兴趣的童鞋！
链表实现直接选择排序
链表实现直接选择排序 思路 先将头结点与后续节点断开，用位置指针指向后续第一个节点。 此时后续节点为未排序序列，每轮循环从未排序链表中找到最大节点，然后用头插法插入L指向的链表，直到未排序链表为空 则L指向的链表中是从小到大顺序排好的链表 代码 //单链表的数据结构定义 typedef struct LNode{ int data; struct LNode *next; //此处必须要加struct }LNode, *LinkList; void select_sort(LinkList &
数据结构--链表的排序详解
1、前言 前面两篇博客，我已经把线性表的两种基本的表示形式，做了一个基本的介绍和一些对比。但是，我突然发现在链表这里我缺少一个很重要的内容，那就是对我们的链表进行排序，其实，在连接两个链表的时候，就要求我们的那两个链表是有序的。2、链表排序—最简单、直接的方式（直接采用冒泡或者选择排序，而且不是交换结点，只交换数据域）//线性表的排序,采用冒泡排序,直接遍历链表 void Listsort(Nod
C语言

69,382

社区成员

243,073

社区内容

发帖
与我相关
我的任务
社区描述
C语言相关问题讨论
社区管理员
  • C语言
  • 花神庙码农
  • 架构师李肯
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章