public class MyTest {
public static void main(String[] args) {
int[] a={24,69,80,57,13};
int t=0;
for (int i = 0; i < a.length-1; i++) { //外层循环用于定义排序次数
for(int j = 0;j < a.length-i-1; j++){ //j < a.length-i-1 定义每次排序比较的次数
if(a[j]>a[j+1]){
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
//打印结果
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
}
第一种:从0索引开始,逐个和后面的所有元素进行比较,小的往前放,第一轮排序完后,最小的元素出现在了最小索引处;第二轮排序,从1索引开始…
第二种:第一次设定起始位置的元素为最小(大)元素,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的首部。以此类推,直到全部待排序的数据元素的个数为零。
第一种
public class MyTest {
public static void main(String[] args) {
int[] a={24,69,80,57,13};
int t=0;
for (int i = 0; i < a.length-1; i++) { //外层循环定义排序次数 i为每次选择排序选择的元素的索引
for(int j = i+1;j < a.length; j++){ //每次从索引为i的元素后开始比较
if(a[i]>a[j]){
t=a[i];
a[i]=a[j];
a[j]=t;
}
}
}
//打印结果
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
}
public class MyTest {
public static void main(String[] args) {
int[] a = {46, 55, 13, 42, 17, 94, 5, 70, 10, 30, 56, 1, 0, 20, 1, 5, -1};
for (int i = 0; i < a.length-1; i++) {//确定每次开始的位置
int min=a[i];//假设每次起始的元素就是最小值
int flag=i;//标记最小值所在的位置
for(int j=i+1;j<a.length;j++){
if(a[j]<min){//从开始索引向后一个个和min比较,再把最小值存放到min,并更新flag标记
min=a[j];
flag=j;
}
}
if(min!=a[i]){//如果min和起始的索引的元素值不一致了,则交换min所在的索引元素和起始索引的元素
a[flag]=a[i];
a[i]=min;
}
}
//打印结果
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
}
}
直接插入排序,是一种最简单的排序方法。他的基本操作是将一个记录插入到一个长度为m 的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表。假设有一组无序元素{k1,k2…,kn},排序开始就认为k1是一个长度为1的有序序列,让k2按照大小顺序插入上述k1这个有序序列,使之成为一个表长为2的有序序列,然后让k3按照大小顺序插入上述表长为2的有序序列,使之成为一个表长为3的有序序列,以此类推,最后让kn插入表长为n-1的有序序列,得到一个表长为n的有序序列。
例如:
49,38,65,97,76,13,27 原始数据
[49],38,65,97,76,13,27 从1索引开始
[38,49], ,65,97,76,13,27
[38,49,65] 97,76,13,27
[38,49,65,97] 76,13,27
[38,49,65,76,97]13,27
[13,27,38,49,65,76,97],27
[13,27,27,38,49,65,76,97]
public class MyTest {
public static void main(String[] args) {
int[] a={24,69,80,57,13};
for (int i = 1; i < a.length; i++) {//外层循环定义轮次
for(int j=i;j>0;j--){//里层就是循环让当前元素和上一个有序列表中的每个元素比较,进行位置交换,使之仍保持有序
if(a[j]<a[j-1]){
int t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
}
//打印结果
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
}
举例:
解析:首先将第一个元素6作为基准数,起初i和j索引分别在数组的首和尾,从j开始从后向前找比基准数6小的值,找到后停下,于是j在值5处停下;接着,i开始从前向后找比基准数大的数,找到后停下,于是i在值为7处停下,然后交换5和7。再接着,j继续向前移,找到比基准数小的4,然后i继续向后移,找到比基准数大的9,将4和9交换。接着,j继续前移,找到比基准数小的3,i再开始后移,也到了3的位置,i和j重合了,于是,将3和基准数6交换(i和j重合,就将基准数和该处元素交换)。至此,基准数6就排到了自己正确的位置,然而6两边的数还是无序的,因此又拆分成两个数组,重复上述的操作,直到所有的数都归位为止。
public class MyTest {
public static void main(String[] args) {
int[] a = {46, 55, 13, 42, 17, 94, 5, 70, 10, 30, 56, 1, 0, 20, 1, 5, -1};
quickSort(a, 0, a.length - 1);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
}
private static void quickSort(int[] a, int startIndex, int endIndex) {
if (startIndex < endIndex) {
//获取归位后的基准数形成的左右分区的索引
int index = getIndex(a, startIndex, endIndex);
//对左右两个分区 再进行同样的步骤 ,即递归调用
quickSort(a, startIndex, index - 1);
quickSort(a, index + 1, endIndex);
}
}
private static int getIndex(int[] a, int startIndex, int endIndex) {
int index = startIndex;//定义基准数的索引
int i = startIndex;
int j = endIndex;
int t = 0;//临时变量
while (i < j) {
while (i < j && a[j] >= a[index]) {//从右往左比较,找到比基准数小的数
j--;
}
while (i < j && a[i] <= a[index]) {//从左往右比较,找到比基准数大的数
i++;
}
//交换两个数
t = a[i];
a[i] = a[j];
a[j] = t;
}
//此时i=j,交换基准数和a[i]
t = a[i];
a[i] = a[index];
a[index] = t;
return i;//返回此时基准数所在的索引
}
}
其他暂时没搞