数据结构--排序--简单排序

 1 /*插入排序--是基本排序里面性能比较好的(比较适合基本有序的排序)
 2  *排序的思想:一个序列,前边是有序的,后边是无序的,拿出一个元素进行插入到已经有序
 3  *           的部分(这里就涉及移动的操作)--先找到位置,再移动
 4  *特点:一趟排序下来每个元素的位置可能不是固定的
 5  *时间复杂度:O(N2)
 6  *排序的稳定性:稳定的
 7  *使用场景:数据基本有序的情况下
 8  * */
 9 public class TestInsertSort {
10
11     public static void main(String[] args) {
12         int[] list1 = {10,8,9,7};
13         insertSort(list1);
14         for(int i = 0; i < list1.length; i++){
15             System.out.print(list1[i] + " ");
16         }
17
18     }
19
20     public static void insertSort(int[] list){
21         for(int i = 1; i <list.length; i++){
22             //记录现在被比较的值
23             int temp = list[i];
24             int j = i;
25             //和前面有序的部分比较找到位置插入【满足>0和比前面的元素小】
26             while(j > 0 && list[j-1] > temp){
27                 list[j] = list[j-1];//向右边移动
28                 j--;
29             }
30             list[j] = temp;
31         }
32     }
33
34 }
 1 /*冒泡排序--属于简单排序
 2  *思想:就是每两个相邻的元素比较-交换直到排完一趟排序,确定出最大的一个元素
 3  *具体实现:需要嵌套循环
 4  *外循环:控制排序趟数--n-1
 5  *内循环:控制每趟的比较次数n-1/n-2....
 6  *冒泡排序的时间复杂度:O(N2)--比较+交换
 7  *排序的稳定性:指的是存在相同的值的元素排序后相对位置不变
 8  *本质就是较换的条件是:大于而不是大于等于
 9  * */
10 public class TestBubbleSort {
11
12     public static void main(String[] args) {
13         int[] list = {10, 8,7,9,2,3,1,0};
14         int[] list1 = bubbleSort(list);
15         for(int i = 0; i < list1.length; i++){
16             System.out.print(list1[i] + " ");
17         }
18     }
19
20     public static int[] bubbleSort(int[] list){
21         //外部循环控制排序的趟数
22         for(int i = 1; i < list.length; i++){
23             //内部比较每趟比较的次数
24             for(int j = 0; j <list.length - i; j++ ){
25                 if(list[j] > list[j+1]){//保证排序的稳定性
26                     int temp = list[j];
27                     list[j] = list[j+1];
28                     list[j+1] = temp;
29
30                 }
31             }
32         }
33         return list;
34     }
35
36
37
38 }
 1 /*选择排序--对冒泡排序的一定的改进,减少了较好的次数
 2  *基本思路:将第一个元素与后面的所有元素比较,找到最小的元素与第一个交换
 3  *          完成一次排序,后面依次找出第二小等等
 4  *具体实现:嵌套循环(外控制排序趟数,内控制交换次数)
 5  *选择排序的时间复杂度:O(N2)
 6  *排序的稳定性:稳定
 7  *使用场景:数据量比较小的情况下
 8  * */
 9 public class TestSelectSort {
10
11     public static void main(String[] args) {
12         int[] list1 = {10,8,0,7,9,7,6,5,4};
13         selectSort(list1);
14         for(int i = 0; i < list1.length; i++){
15             System.out.print(list1[i] + " ");
16         }
17     }
18
19     //以及有序的不在参与比较【减少较好次数】
20     public static void selectSort(int[] list){
21         for(int i = 0; i < list.length -1; i++){
22             for(int j = i + 1; j < list.length; j++){
23                 if(list[i] > list[j]){
24                     int temp = list[i];
25                     list[i] =list[j];
26                     list[j] = temp;
27                 }
28             }
29         }
30     }
31
32 }
时间: 2024-11-08 06:10:48

数据结构--排序--简单排序的相关文章

数据结构之简单排序的三种玩法

本文主要介绍,一个简单排序算法都可以有哪几种玩法(以选择排序为例,代码请在cpp文件下运行) 选择排序...总结为三个步骤就是: 1.在一段区间内找最大/最小元素. 2.将最大/最小元素与区间中的第一个值进行交换 3.缩小查找区间 如果你还没有理解?不用担心,请参考:选择排序_百度百科:http://baike.baidu.com/item/选择排序 玩法1:初窥门径 如果理解了选择排序的算法,想要把它实现成一段代码,对于代码能力比较强的小伙伴来说,并不是一件复杂的事情,因此我们达到的第一重境界

(九)数据结构之简单排序算法实现:冒泡排序、插入排序和选择排序

d59FG8075P7伊http://www.zcool.com.cn/collection/ZMTg2NTU2NjQ=.html 312V畏蝗淤ZP哦睬http://www.zcool.com.cn/collection/ZMTg2NTU4NDQ=.html f衷4i82419s搪褂压8http://www.zcool.com.cn/collection/ZMTg2NTU4Njg=.html 75抖0瞪4豪c练偃62诵付http://www.zcool.com.cn/collection/ZM

排序——简单排序

1 #include <stdio.h> 2 int main() 3 { 4 int i,j,n,min,r[100]; 5 printf("enter total numbers\t"); 6 scanf("%d",&n); 7 for(i=1;i<=n;i++) 8 { 9 printf("enter number %d\t",i); 10 scanf("%d",&r[i]); 11 }

Java数据结构和算法之数组与简单排序

一.数组于简单排序 数组 数组(array)是相同类型变量的集合,可以使用共同的名字引用它.数组可被定义为任何类型,可以是一维或多维.数组中的一个特别要素是通过下标来访问它.数组提供了一种将有联系的信息分组的便利方法. 一维数组 一维数组(one‐dimensional array )实质上是相同类型变量列表.要创建一个数组,你必须首先定义数组变量所需的类型.通用的一维数组的声明格式是: type var‐name[ ]; 获得一个数组需要2步: 第一步,你必须定义变量所需的类型. 第二步,你必

数据结构与算法分析之简单排序算法

在排序算法中,简单排序主要有三种,分别为冒泡排序.选择排序.插入排序,学习理解好这三种排序算法有助于进一步研究数据结构与算法分析.下面,简单地谈一谈冒泡排序.选择排序.插入排序的原理及区别. 冒泡排序原理: 1.比较相邻的元素.如果前一个比后一个大,它们就交换. 2.每对元素都要进行同样的动作,从后往前比较. 3.每趟都会确定一个位置的元素,因此n个元素,需要n-1趟才能确定各个元素的位置. 例如:对23,4,56,11四个数进行冒泡排序. 第一趟 4,23,11,56 第二趟 4,11,23,

Java数据结构和算法(三)——简单排序

单单有数据还不够,对于数据的展现,经常要按照一定的顺序进行排列,越高要求的排序越复杂,这篇只介绍三种大小的简单排序. 1)冒泡排序 模拟:有数组,1,4,2,5,7,3. (1)首先从1开始冒泡,1比4小,不冒,4大于2,冒上去,与2交换位置,4比5小,不冒,7比3大,冒,结果:1,2,4,5,3,7 (2)接下来从2开始,因为第一个元素冒过了,重复(1),结果:1,2,4,3,5,7 (3)从第三位4开始,结果1,2,3,4,5,7 (4)虽然看起来已经排好序,但是还是要继续冒,接下来就是从第

数据结构--排序(上)--简单排序(冒泡,插入)

简单排序(冒泡,插入) 介绍两大类算法,一类是排序,一类是查找 前提:X是排序的算法 void X_sort( ElementType A[],int N) . N是正整数,只讨论基于比较的排序(< = >有定义) 只讨论内部排序(所有数据都可以导入内部空间) 稳定性:任意两个相等的数据,排序前后的相对位置不发生改变. 没有一种排序是任何情况下都表现最好的. 冒泡排序 第一次冒泡最大的泡泡一定在最下面. void Bubble_sort(ElementType A[], int N){ for

数据结构-简单排序

在我们的业务中,有很多情况都需要根据某种需要针对要返回的数据进行排序,但是排序是一种非常耗时的操作,特别是当数据量大的时候,所有有时候我们也会说,数据的排序是很重要的,但是也是非常耗时间的.在这里简单介绍一下简单排序,这些排序算法执行速度较慢,但算法逻辑简单,在某些时候,比其他的复杂排序算法更加有效,同时也能帮助我们理解其他的复杂排序算法. 一.冒泡排序 冒泡算法的排序规则:重复比较相邻的两个元素,如果第一个比第二个大,就交换两个元素的位置,重复这个动作,就可以将最大值移动到后面.一趟(从第一个

简单排序方法

排序: 排序(Sort)是计算机程序设计中的一种重要操作,也是日常生活中经常遇到的问题.例如,字典中的单词是以字母的顺序排列,否则,使用起来非常困难.同样,存储在计算机中的数据的次序,对于处理这些数据的算法的速度和简便性而言,也具有非常深远的意义. 基本概念: 排序是把一个记录(在排序中把数据元素称为记录)集合或序列重新排列成按记录的某个数据项值递增(或递减)的序列. 下表是一个学生成绩表,其中某个学生记录包括学号.姓名及计算机文化基础.C 语言.数据结构等课程的成绩和总成绩等数据项.在排序时,