精华内容
下载资源
问答
  • 2022-01-18 16:58:47

    code

    //案例:定义一个结构体,其中有年龄属性,将结构体中的元素按年龄升序排列
    //三名同学在数学竞赛中取得优异成绩,现打印他们的信息
    #include<iostream>
    #include<string>
    using namespace std;
    
    struct hero
    {
    	string name;
    	int age;
    };
    
    //使用冒泡排序算法
    void bubbleSort(struct hero h[],int n)
    {
    	
    	for (int i = 0; i < n-1; i++)
    	{
    		for (int j = 0; j < n - i - 1; j++)
    		{
    			if (h[j].age>h[j+1].age)
    			{
    				int temp = h[j + 1].age;
    				h[j + 1].age = h[j].age;
    				h[j].age = temp;
    			}
    		}
    	}
    }
    
    //打印信息
    void print_(struct hero h[])
    {
    	for (int i = 0; i < 3; i++)
    	{
    		cout << h[i].name << h[i].age << endl;	
    	}	
    }
    
    int main() 
    {
    	struct hero h[3] =
    	{
    		{"小红",14},
    		{"小明",19},
    		{"小亮",18}
    	};
    	int n = sizeof(h) / sizeof(h[0]);
    	bubbleSort(h,n);
    	print_(h);
    	return 0;
    }

    更多相关内容
  • #include ...//对结构体进行冒泡排序的函数 void bubbleSort(struct hero heroArray[], int len) { for (int i = 0; i < len-1; i++) { for (int j = 0; j < len - i - 1; j++) { if (heroArra

    #include
    #include
    using namespace std;

    struct hero {

    string name;
    int age;
    string sex;
    

    };
    //对结构体进行冒泡排序的函数
    void bubbleSort(struct hero heroArray[], int len)
    {

    for (int i = 0; i < len-1; i++)
    {
    
    	for (int j = 0; j < len - i - 1; j++)
    	{
    		if (heroArray[j].age > heroArray[j+1].age)
    		{
    			struct hero temp;
    			temp = heroArray[j];
    			heroArray[j] = heroArray[j + 1];
    			heroArray[j + 1] = temp;
    
    
    		}
    
    	}
    
    
    }
    

    }
    //输出函数
    void printInfo(struct hero heroArray[], int len)
    {

    for (int i = 0; i < len; i++)
    {
    
    	cout << "姓名" << heroArray[i].name << "年龄" << heroArray[i].age
    		<< "性别" << heroArray[i].sex << endl;
    }
    

    }

    int main()
    {

    /// 创建数组 存放数组
    struct hero heroArray[5] = {
    
    	{"刘备",23,"男"},
    {"张飞",22,"男"},
    {"关羽",19,"男"},
    {"张飞",20,"男"},
    {"貂蝉",21,"男"},
    };
    

    //计算数组长度
    int len = sizeof(heroArray) / sizeof(heroArray[0]);
    // 对年龄运用冒泡排序进行升序排列
    bubbleSort(heroArray, len);
    //输入排序后的结果
    printInfo(heroArray, len);

    return 0;
    

    }

    展开全文
  • java之冒泡排序8

    千次阅读 2019-09-24 20:42:13
    我们在实现这8个数排序主要思路是:先用一个数组存取8个数字,然后使用冒泡排序从小到大进行排序。 二.冒泡排序 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素做同样的工作,从开始第一...

    一.实现思路

          我们在实现这8个数排序主要思路是:先用一个数组存取8个数字,然后使用冒泡排序从小到大进行排序。

    二.冒泡排序

    比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
    针对所有的元素重复以上的步骤,除了最后一个。持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较

    三.代码实现

    我们定义变量i表示数组,变量j表示数组的下一位。
    也就是说:a[i]a[j]分别代表了数组的上一位和下一位,利用双重循环的特点【先内层执行完毕,再执行外层循环】进行数组的比较。

    public class max{
    	public static void main(String []args){
    	//定义一个一维数组,并初始化值
    	int a[]={78,23,56,34,12,45,67,89};
    	int i,j,temp;
        /*进行冒泡排序*/
    	for(i=0;i<a.length;i++){
    		for(j=0;j<a.length;j++)
    			{
    				if(a[i]<a[j])
    				{
    					temp=a[i];
    					a[i]=a[j];
    					a[j]=temp;
    				}
    			}
    		}
    		/*输出这个数组*/
    		for(i=0;i<a.length;i++)
    			System.out.print(""+a[i]);
    	}
    }
    
    import java.util.Scanner;
    public class BubbleSort {
    
    	public static void main(String[] args) {
    		// TODO 自动生成的方法存根
    		int l = 0;
    		Scanner scanner=new Scanner(System.in);//系统的标准输入
    		
    		int []numbers=new int[8];
    		System.out.println("please enter eight numbers:");
    		for(int i=0;i<numbers.length;i++)
    			numbers[i]=scanner.nextInt();//通过nextInt进行输入操作
    		
    		
    		for(int i=numbers.length-1;i>0;i--) {
    			for(int j=0;j<i;j++) {
    				if(numbers[j]>numbers[j+1]) {
    					int temp=numbers[j];
    					numbers[j]=numbers[j+1];
    					numbers[j+1]=temp;
    				}
    			
    			}
    			
    		}
    		
    		
    		
    		
    		
    		/*
    		for(int i=0;i<numbers.length;i++) {
    			for(int j=0;j<numbers.length;j++) {//涉及到排序功能的时候,j的变化一定是关联着变量i的
    				if(numbers[i]<numbers[j]) {//排序比较的数字通常是根据内循环变量来变化的
    					l++;
    					int temp=numbers[i];//冒泡排序就是把小的变量往前排!
    					numbers[i]=numbers[j];
    					numbers[j]=temp;
    				}
    				if(l==0)
    					break;
    				l=0;
    			}
    			
    		}*/
    		
    		System.out.println("冒泡排序的结果是:");
    		for(int i=0;i<numbers.length;i++)
    			System.out.print(numbers[i]+"");
    		
    	}
    
    }
    
    展开全文
  • C语言结构体排序问题

    2021-05-22 06:13:33
    2011-11-23求解C语言中建立一个对链表按照学==========================功能:选择排序(由小到大)返回:指向链表表头的指针==========================*//*选择排序的基本思想就是反复从还未排好序的那些节点中,...

    e20d40910a72572dc23bea6deb048e82.png

    2011-11-23

    求解C语言中建立一个对链表按照学

    ==========================功能:选择排序(由小到大)返回:指向链表表头的指针==========================*//*选择排序的基本思想就是反复从还未排好序的那些节点中,选出键值(就是用它排序的字段,我们取学号num为键值)最小的节点,依次重新组合成一个链表。 我认为写链表这类程序,关键是理解:head存储的是第一个节点的地址,head->next存储的是第二个节点的地址;任意一个节点p的地址,只能通过它前一个节点的next来求得。单向链表的选择排序图示:---->[1]---->[3]---->[2]。 。。---...全部

    ========================== 功能:选择排序(由小到大) 返回:指向链表表头的指针==========================*//* 选择排序的基本思想就是反复从还未排好序的那些节点中, 选出键值(就是用它排序的字段,我们取学号num为键值)最小的节点, 依次重新组合成一个链表。

    我认为写链表这类程序,关键是理解: head存储的是第一个节点的地址,head->next存储的是第二个节点的地址; 任意一个节点p的地址,只能通过它前一个节点的next来求得。单向链表的选择排序图示:---->[1]---->[3]---->[2]。

    。。---->[n]---->[NULL](原链表)head 1->next 3->next 2->next n->next---->[NULL](空链表)firsttail---->[1]---->[2]---->[3]。

    。。---->[n]---->[NULL](排序后链表)first 1->next 2->next 3->next tail->next图10:有N个节点的链表选择排序1、先在原链表中找最小的,找到一个后就把它放到另一个空的链表中;2、空链表中安放第一个进来的节点,产生一个有序链表,并且让它在原链表中分离出来(此时要注意原链表中出来的是第一个节点还是中间其它节点);3、继续在原链表中找下一个最小的,找到后把它放入有序链表的尾指针的next,然后它变成其尾指针;*/struct student *SelectSort(struct student *head){ struct student *first; /*排列后有序链的表头指针*/ struct student *tail; /*排列后有序链的表尾指针*/ struct student *p_min; /*保留键值更小的节点的前驱节点的指针*/ struct student *min; /*存储最小节点*/ struct student *p; /*当前比较的节点*/ first = NULL; while (head != NULL) /*在链表中找键值最小的节点。

    */ { /*注意:这里for语句就是体现选择排序思想的地方*/ for (p=head,min=head; p->next!=NULL; p=p->next) /*循环遍历链表中的节点,找出此时最小的节点。

    */ { if (p->next->num num) /*找到一个比当前min小的节点。*/ { p_min = p; /*保存找到节点的前驱节点:显然p->next的前驱节点是p。

    */ min = p->next; /*保存键值更小的节点。*/ } } /*上面for语句结束后,就要做两件事;一是把它放入有序链表中;二是根据相应的条件判断,安排它离开原来的链表。

    */ /*第一件事*/ if (first == NULL) /*如果有序链表目前还是一个空链表*/ { first = min; /*第一次找到键值最小的节点。*/ tail = min; /*注意:尾指针让它指向最后的一个节点。

    */ } else /*有序链表中已经有节点*/ { tail->next = min; /*把刚找到的最小节点放到最后,即让尾指针的next指向它。*/ tail = min; /*尾指针也要指向它。

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

    */ } } if (first != NULL) /*循环结束得到有序链表first*/ { tail->next = NULL; /*单向链表的最后一个节点的next应该指向NULL*/ } head = first; return head;}/*========================== 功能:直接插入排序(由小到大) 返回:指向链表表头的指针==========================*//* 直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值 (就是用它排序的字段,我们取学号num为键值)排好序的,对于节点n在 这个序列中找插入位置,使得n插入后新序列仍然有序。

    按照这种思想,依次 对链表从头到尾执行一遍,就可以使无序链表变为有序链表。 单向链表的直接插入排序图示:---->[1]---->[3]---->[2]。。。---->[n]---->[NULL](原链表)head 1->next 3->next 2->next n->next---->[1]---->[NULL](从原链表中取第1个节点作为只有一个节点的有序链表)head图11---->[3]---->[2]。

    。。---->[n]---->[NULL](原链表剩下用于直接插入排序的节点)first 3->next 2->next n->next图12---->[1]---->[2]---->[3]。

    。。---->[n]---->[NULL](排序后链表)head 1->next 2->next 3->next n->next图13:有N个节点的链表直接插入排序1、先在原链表中以第一个节点为一个有序链表,其余节点为待定节点。

    2、从图12链表中取节点,到图11链表中定位插入。3、上面图示虽说画了两条链表,其实只有一条链表。在排序中,实质只增加了一个用于指向剩下需要排序节点的头指针first罢了。 这一点请读者务必搞清楚,要不然就可能认为它和上面的选择排序法一样了。

    */struct student *InsertSort(struct student *head){ struct student *first; /*为原链表剩下用于直接插入排序的节点头指针*/ struct student *t; /*临时指针变量:插入节点*/ struct student *p; /*临时指针变量*/ struct student *q; /*临时指针变量*/ first = head->next; /*原链表剩下用于直接插入排序的节点链表:可根据图12来理解。

    */ head->next = NULL; /*只含有一个节点的链表的有序链表:可根据图11来理解。*/ while (first != NULL) /*遍历剩下无序的链表*/ { /*注意:这里for语句就是体现直接插入排序思想的地方*/ for (t=first, q=head; ((q!=NULL) && (q->num num)); p=q, q=q->next); /*无序节点在有序链表中找插入的位置*/ /*退出for循环,就是找到了插入的位置*/ /*注意:按道理来说,这句话可以放到下面注释了的那个位置也应该对的,但是就是不能。

    原因:你若理解了上面的第3条,就知道了。*/ first = first->next; /*无序链表中的节点离开,以便它插入到有序链表中。*/ if (q == head) /*插在第一个节点之前*/ { head = t; } else /*p是q的前驱*/ { p->next = t; } t->next = q; /*完成插入动作*/ /*first = first->next;*/ } return head;}/*========================== 功能:冒泡排序(由小到大) 返回:指向链表表头的指针==========================*//* 直接插入排序的基本思想就是对当前还未排好序的范围内的全部节点, 自上而下对相邻的两个节点依次进行比较和调整,让键值(就是用它排 序的字段,我们取学号num为键值)较大的节点往下沉,键值较小的往 上冒。

    即:每当两相邻的节点比较后发现它们的排序与排序要求相反时, 就将它们互换。单向链表的冒泡排序图示:---->[1]---->[3]---->[2]。。。---->[n]---->[NULL](原链表)head 1->next 3->next 2->next n->next ---->[1]---->[2]---->[3]。

    。。---->[n]---->[NULL](排序后链表)head 1->next 2->next 3->next n->next图14:有N个节点的链表冒泡排序任意两个相邻节点p、q位置互换图示:假设p1->next指向p,那么显然p1->next->next就指向q,p1->next->next->next就指向q的后继节点,我们用p2保存p1->next->next指针。

    即:p2=p1->next->next,则有:[ ]---->[p]---------->[q]---->[ ](排序前) p1->next p1->next->next p2->next图15[ ]---->[q]---------->[p]---->[ ](排序后)图161、排序后q节点指向p节点,在调整指向之前,我们要保存原p的指向节点地址,即:p2=p1->next->next;2、顺着这一步一步往下推,排序后图16中p1->next->next要指的是p2->next,所以p1->next->next=p2->next;3、在图15中p2->next原是q发出来的指向,排序后图16中q的指向要变为指向p的,而原来p1->next是指向p的,所以p2->next=p1->next;4、在图15中p1->next原是指向p的,排序后图16中p1->next要指向q,原来p1->next->next(即p2)是指向q的,所以p1->next=p2;5、至此,我们完成了相邻两节点的顺序交换。

    6、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置,这样我们不必每次都从头到尾的扫描,只需要扫描到记录点为止。 因为后面的都已经是排好序的了。*/struct student *BubbleSort(struct student *head){ struct student *endpt; /*控制循环比较*/ struct student *p; /*临时指针变量*/ struct student *p1; struct student *p2; p1 = (struct student *)malloc(LEN); p1->next = head; /*注意理解:我们增加一个节点,放在第一个节点的前面,主要是为了便于比较。

    因为第一个节点没有前驱,我们不能交换地址。*/ head = p1; /*让head指向p1节点,排序完成后,我们再把p1节点释放掉*/ for (endpt=NULL; endpt!=head; endpt=p) /*结合第6点理解*/ { for (p=p1=head; p1->next->next!=endpt; p1=p1->next) { if (p1->next->num > p1->next->next->num) /*如果前面的节点键值比后面节点的键值大,则交换*/ { p2 = p1->next->next; /*结合第1点理解*/ p1->next->next = p2->next; /*结合第2点理解*/ p2->next = p1->next; /*结合第3点理解*/ p1->next = p2; /*结合第4点理解*/ p = p1->next->next; /*结合第6点理解*/ } } } p1 = head; /*把p1的信息去掉*/ head = head->next; /*让head指向排序后的第一个节点*/ free(p1); /*释放p1*/ p1 = NULL; /*p1置为NULL,保证不产生“野指针”,即地址不确定的指针变量*/ return head;}/*========================== 功能:插入有序链表的某个节点的后面(从小到大) 返回:指向链表表头的指针==========================*//*有序链表插入节点示意图:---->[NULL](空有序链表)head图18:空有序链表(空有序链表好解决,直接让head指向它就是了。

    )以下讨论不为空的有序链表。---->[1]---->[2]---->[3]。。。---->[n]---->[NULL](有序链表)head 1->next 2->next 3->next n->next图18:有N个节点的有序链表插入node节点的位置有两种情况:一是第一个节点前,二是其它节点前或后。

    ---->[node]---->[1]---->[2]---->[3]。。。---->[n]---->[NULL]head node->next 1->next 2->next 3->next n->next图19:node节点插在第一个节点前---->[1]---->[2]---->[3]。

    。。---->[node]。。。---->[n]---->[NULL]head 1->next 2->next 3->next node->next n->next图20:node节点插在其它节点后*/struct student *SortInsert(struct student *head, struct student *node){ struct student *p; /*p保存当前需要检查的节点的地址*/ struct student *t; /*临时指针变量*/ if (head == NULL) /*处理空的有序链表*/ { head = node; node->next = NULL; n += 1; /*插入完毕,节点总数加1*/ return head; } p = head; /*有序链表不为空*/ while (p->num num && p != NULL) /*p指向的节点的学号比插入节点的学号小,并且它不等于NULL*/ { t = p; /*保存当前节点的前驱,以便后面判断后处理*/ p = p->next; /*后移一个节点*/ } if (p == head) /*刚好插入第一个节点之前*/ { node->next = p; head = node; } else /*插入其它节点之后*/ { t->next = node; /*把node节点加进去*/ node->next = p; } n += 1; /*插入完毕,节点总数加1*/ return head;}/*测试代码如下:*//*测试SelectSort():请编译时去掉注释块*/ /* head = SelectSort(head); Print(head); */ /*测试InsertSort():请编译时去掉注释块*/ /* head = InsertSort(head); Print(head); */ /*测试BubbleSort():请编译时去掉注释块*/ /* head = BubbleSort(head); Print(head); */ /*测试SortInsert():上面创建链表,输入节点时请注意学号num从小到大的顺序。

    请编译时去掉注释块*/ /* stu = (struct student *)malloc(LEN); printf("/nPlease input insert node -- num,score: "); scanf("%ld,%f",&stu->num,&stu->score); head = SortInsert(head,stu); free(stu); stu = NULL; Print(head); */转载: 。

    收起

    展开全文
  • 指向链表表头的指针==========================*//*选择排序的基本思想就是反复从还未排好序的那些节点中,选出键值(就是用它排序的字段,我们取学号num为键值)最小的节点,依次重新组合成一个链表。我认为写链表这...
  • 用类冒泡排序法对链表进行排序; 再合并两链表,并按照学号升序排列。 #include #include #include #include #define LEN sizeof(STUDENT) #define STU STUDENT typedef struct//结构体定义 {  long snum;  ...
  • i++)//这里所接收的都是char*类型的指针,所以每次交换只能交换一个字节,如果想要完整的交换原本的两个元素,则需要接收原本元素所占字节大小 { char temp=*bub1; *bub1=*bub2; *bub2=temp; bub1++; bub2++; ...
  • #include void bubble_sort(int arr[], int sz) { //确定冒泡排序的趟数 int i = 0; for (i = 0; i ; i++) { //每冒泡排序 int j = 0; for (j = 0; j ; j++) { if (arr[j]>arr[j + 1]) { int tem = arr[j]; arr...
  • 排序——冒泡排序(Bubble sort)

    千次阅读 2020-02-03 12:40:57
    定义 冒泡排序种较简单的排序算法。...这算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。 ...
  • 输入多行,先输入要排序的人的个数,然后输入排序方法0(降序)或者1(升序)再分别输入他们的名字和成绩,以一个空格隔开 输出描述: 按照指定方式输出名字和成绩,名字和成绩之间以一个空格隔开 示例1 输入 3...
  • //用冒泡排序法排序(从大到小) for(i=0;i;i++) {//遍历sum_stu-1轮 for(j=0;j;j++) {//每过轮,遍历的元素数目-1 if((p[j]->sum)<(p[j+1]->sum)) { temp=p[j+1];//交换两结构体在...
  • 6.*英雄结构体+冒泡法——对英雄结构体里属性-年龄升序排列,最后打印输出 ————————————————————————————————————— *1.结构体概念 作用:允许用户储存不同类型的数据 语法:...
  • 之前遇到排序只想着最原始的方法,诸如冒泡,选择,快速排序等等,刚刚跟大牛学会了结构体的方法来排序,这样的话以后再也不用怕成绩统计、名次排序之类的题目了。首先头文件(基于大牛的方法,本人之后做题喜欢引入...
  • include<...1.第种定义结构体的方法 struct student { char name[10]; char idnumber[10]; int score; }; typedef struct studet; 2.第二种定义结构体的方法 typedef struct student { ch...
  • 函数头文件:#include&...①对数组进行排序:sort(begin,end) / sort(begin,end,compare) #include<iostream> #include<algorithm> using namespace std; bool compare(int a, int b) { return a &g...
  • * 冒泡排序5名学员成绩(降序) * @param args */ public static void main(String[] args) { Scanner input =new Scanner(System.in); System.out.println("请输入5名同学的成绩:"); // 首先定义数组...
  • 1.c++自带的头文件`<algorithm>`模板库,使用sort函数进行排序。自定义了cmp函数并在结构体中重载了“<”运算符。 2.while(scanf("%d",&n) != EOF) 、while(gets(字符串变量)) 循环条件。
  • 用C语言编写通用冒泡排序函数

    千次阅读 2019-02-20 17:40:34
    用C语言模拟实现qsort函数 一、首先用冒泡排序法一个数组进行排序: 注:此处为升序排列
  • C语言-排序算法冒泡排序1.原理2.代码实现(降序排序)二、选择排序1.原理2.代码实现(降序排序)注意事项 冒泡排序 1.原理 冒泡排序先会从头到尾比较相邻元素的⼤⼩,如果不满⾜升序降序的条件,则对其进⾏...
  • 直接插入排序,希尔排序,简单选择排序,冒泡排序,快速排序,堆排序,归并排序主要通过某种策略移动,选择或交换关键字来实现,关键字选择上,为了简便起见,都是整形数据。关键字间的比较,也都是直观的大小比较。...
  • 1. 冒泡法 #include int main() {  int a[10];  int i=0, t, j;    printf("please write 10 stu_grade:");  for(i=0; i  scanf("%d",&a[i]);  printf("\n");    for(j=0; j
  • 本文通过ST语言实现经典的冒泡排序算法,来了解和熟悉codesys系统中常用的几功能,如变量的定义,数组的应用,条件与循环结构的应用、可视化界面按钮,数值显示、数值输入的配置方法等。
  • C++冒泡排序案例

    2021-08-30 11:31:03
    100)通过冒泡排序算法,将数组中英雄年龄进行升序排列并且最终打印出结果 #include <iostream> using namespace std; #include<string> //创建英雄结构体 struct hero { string name; int age; ...
  • 冒泡法排序

    2021-09-17 16:41:31
    这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。 具体方法 1.比较相邻的元素。如果第一个比第二...
  • 定义一个数组a[11],用(1)学生成绩处理应用以下不同的方法,对学生的成绩进行处理。根据不同的方法的难度和采用方法的种类评定成绩。选方法1、2、3,至少要完成两种算法的程序编写。方法4、...
  • 方式 二维数组 #include &...输入10字符串,进行排序,输出 * 利用字符型二维数组 */ #define N 10 // 选择排序 void sort(char p[][20]) { int i = 0, k, j = 0; char temp[20];
  • 冒泡排序,插入排序,快速排序,归并排序和C++标准库模板sort函数
  • 一个一个降(参数问题) void SearchCommonData(pLinkNode firstpHead, pLinkNode secondpHead); //查找倒数第k个节点,只需遍历一次 pLinkNode SearchKFromTail(pLinkNode pHead, int k); //冒泡排序 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 646
精华内容 258
关键字:

设计一个英雄的结构体,利用冒泡排序法按照英雄年龄进行升序排列