java插入排序,java排序实现

发布时间：2022-12-01

本文目录一览：

  1. Java编程：简化的插入排序？
  2. 请给出java几种排序方法
  3. [java 数组插入排序改错 急](#java 数组插入排序改错 急)
  4. [Java 直接插入排序法](#Java 直接插入排序法)

Java编程：简化的插入排序？

代码：（如果输入必须是有序数组，不然方法内要先排序） 结果：

请给出java几种排序方法

java常见的排序分为：

  1. 插入类排序 主要就是对于一个已经有序的序列中，插入一个新的记录。它包括：直接插入排序，折半插入排序和希尔排序。
  2. 交换类排序 这类排序的核心就是每次比较都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序，但是每一趟排序都会让一个记录排序到它的最终位置上。它包括：起泡排序，快速排序。
  3. 选择类排序 每一趟排序都从一系列数据中选择一个最大或最小的记录，将它放置到第一个或最后一个为位置交换，只有在选择后才交换，比起交换类排序，减少了交换记录的时间。属于它的排序：简单选择排序，堆排序。
  4. 归并类排序 将两个或两个以上的有序序列合并成一个新的序列。
  5. 基数排序 主要基于多个关键字排序的。 下面针对上面所述的算法，讲解一些常用的java代码写的算法。

二、插入类排序之直接插入排序

直接插入排序，一般对于已经有序的队列排序效果好。 基本思想：每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。 算法思路，从后往前先找到要插入的位置，如果小于则就交换，将元素向后移动，将要插入数据插入该位置即可。时间复杂度为O(n²)，空间复杂度为O(1)。

package sort.algorithm;
public class DirectInsertSort {
    public static void main(String[] args) {
        int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
        int temp, j;
        for (int i = 1; i < data.length; i++) {
            temp = data[i];
            j = i - 1;
            // 每次比较都是对于已经有序的
            while (j >= 0 && data[j] > temp) {
                data[j + 1] = data[j];
                j--;
            }
            data[j + 1] = temp;
        }
        // 输出排序好的数据
        for (int k = 0; k < data.length; k++) {
            System.out.print(data[k] + " ");
        }
    }
}

三、插入类排序之折半插入排序（二分法排序）

条件：在一个已经有序的队列中，插入一个新的元素。 折半插入排序记录的比较次数与初始序列无关。 思想：折半插入就是首先将队列中取最小位置low和最大位置high，然后算出中间位置mid。 将中间位置mid与待插入的数据data进行比较， 如果mid大于data，则就表示插入的数据在mid的左边，high=mid-1； 如果mid小于data，则就表示插入的数据在mid的右边，low=mid+1。 最后整体进行右移操作。 时间复杂度O(n²)，空间复杂度O(1)。

package sort.algorithm;
// 折半插入排序
public class HalfInsertSort {
    public static void main(String[] args) {
        int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
        // 存放临时要插入的元素数据
        int temp;
        int low, mid, high;
        for (int i = 1; i < data.length; i++) {
            temp = data[i];
            // 在待插入排序的序号之前进行折半插入
            low = 0;
            high = i - 1;
            while (low <= high) {
                mid = (low + high) / 2;
                if (temp < data[mid])
                    high = mid - 1;
                else
                    // low=high的时候也就是找到了要插入的位置，
                    // 此时进入循环中，将low加1，则就是要插入的位置了
                    low = mid + 1;
            }
            // 找到了要插入的位置，从该位置一直到插入数据的位置之间数据向后移动
            for (int j = i; j >= low + 1; j--)
                data[j] = data[j - 1];
            // low已经代表了要插入的位置了
            data[low] = temp;
        }
        for (int k = 0; k < data.length; k++) {
            System.out.print(data[k] + " ");
        }
    }
}

四、插入类排序之希尔排序

希尔排序，也叫缩小增量排序，目的就是尽可能的减少交换次数，每一个组内最后都是有序的。 将待排序按照某一种规则分为几个子序列，不断缩小规则，最后用一个直接插入排序合成。 空间复杂度为O(1)，时间复杂度为O(nlog₂n)。 算法先将要排序的一组数按某个增量d（n/2，n为要排序数的个数）分成若干组，每组中记录的下标相差d。对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

package sort.algorithm;
public class ShellSort {
    public static void main(String[] args) {
        int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };
        double d1 = a.length;
        int temp = 0;
        while (true) {
            // 利用这个在将组内倍数减小
            // 这里依次为5,3,2,1
            d1 = Math.ceil(d1 / 2);
            // d为增量每个分组之间索引的增量
            int d = (int) d1;
            // 每个分组内部排序
            for (int x = 0; x < d; x++) {
                // 组内利用直接插入排序
                for (int i = x + d; i < a.length; i += d) {
                    int j = i - d;
                    temp = a[i];
                    for (; j >= 0 && temp < a[j]; j -= d) {
                        a[j + d] = a[j];
                    }
                    a[j + d] = temp;
                }
            }
            if (d == 1)
                break;
        }
        for (int i = 0; i < a.length; i++)
            System.out.print(a[i] + " ");
    }
}

五、交换类排序之冒泡排序

交换类排序核心就是每次比较都要进行交换。 冒泡排序：是一种交换排序。 每一趟比较相邻的元素，若大小不同则就会发生交换，每一趟排序都能将一个元素放到它最终的位置！每一趟就进行比较。 时间复杂度O(n²)，空间复杂度O(1)。

package sort.algorithm;
// 冒泡排序：是一种交换排序
public class BubbleSort {
    // 按照递增顺序排序
    public static void main(String[] args) {
        int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };
        int temp = 0;
        // 排序的比较趟数，每一趟都会将剩余最大数放在最后面
        for (int i = 0; i < data.length - 1; i++) {
            // 每一趟从开始进行比较，将该元素与其余的元素进行比较
            for (int j = 0; j < data.length - 1; j++) {
                if (data[j] > data[j + 1]) {
                    temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < data.length; i++)
            System.out.print(data[i] + " ");
    }
}

java 数组插入排序改错 急

修改Score类声明，实现java.lang.Comparable接口；

public class Score implements java.lang.Comparable {

在方法getStuInfomation() 后追加两个方法(compareTo为Comparable接口要求实现此方法，toString为重写基类的打印输出方法)：

public int compareTo(Object otherScore) {
    return this.stuScore - ((Score) otherScore).stuScore;
}
public String toString() {
    return "[学号:" + stuNumber + "分数:" + stuScore + "姓名:" + stuName + "]";
}

重新编译Score.java，再运行Test，输出结果为：

----------
[学号:3分数:323姓名:Lily]
[学号:5分数:332姓名:Mike]
[学号:2分数:445姓名:Fangfang]
[学号:1分数:472姓名:Liming]
[学号:4分数:540姓名:Green]
--2008/04/05
哎......

package method2;
import java.util.ArrayList;
import java.util.Collections;
public class Test {
    public static void main(String args[]) {
        ArrayList list = new ArrayList();
        list.add(new Score(1, "Liming", 472));
        list.add(new Score(2, "Fangfang", 445));
        list.add(new Score(3, "Lily", 323));
        list.add(new Score(4, "Green", 540));
        list.add(new Score(5, "Mike", 332));
        Collections.sort(list, new StuScoreComparator());
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).toString());
        }
        Collections.binarySearch(list, new Score(1, "Liming", 472));
    }
}
class StuScoreComparator extends Score implements java.util.Comparator {
    public int compare(Object o1, Object o2) {
        Score score1 = (Score) o1;
        Score score2 = (Score) o2;
        return score1.getStuScore() - score2.getStuScore();
    }
}

package method2;
/**
 *
 * @author Liuzhichao
 */
public class Score implements java.lang.Comparable {
    private int stuNumber;
    private String stuName;
    private int stuScore;
    Score() {
    }
    public Score(int stuNumber, String stuName, int stuScore) {
        if (stuNumber > 0) {
            this.stuNumber = stuNumber;
        } else {
            System.out.println("输入的学生学号不正确");
            System.exit(1);
        }
        if (stuScore > 0) {
            this.stuScore = stuScore;
        } else {
            System.out.println("输入的学生学号不正确");
            System.exit(1);
        }
        this.stuName = stuName;
    } // 设置学生信息
    public void setStuNumber(int stuNumber) {
        this.stuNumber = stuNumber;
    } // 设置学生学号
    public void setStuScore(int stuScore) {
        this.stuScore = stuScore;
    } // 设置学生分数
    public void setStuName(String stuName) {
        this.stuName = stuName;
    } // 设置学生名字
    public int getStuNumber() {
        return this.stuNumber;
    } // 设置学生学号
    public int getStuScore() {
        return this.stuScore;
    } // 设置学生分数
    public String getStuName() {
        return this.stuName;
    } // 获取学生名字
    public String getStuInfomation() {
        return "名字：" + this.stuName + " 学号:" + this.stuNumber + " 成绩:" + this.stuScore;
    } // 获取学生信息
    public int compareTo(Object otherScore) {
        return this.stuScore - ((Score) otherScore).stuScore;
    }
    public String toString() {
        return "[学号:" + stuNumber + "分数:" + stuScore + "姓名:" + stuName + "]";
    }
}

Java 直接插入排序法

比如数组[3, 2, 1, 5]这段处理就返回[1, 2, 3, 5]。它的处理是从第二位开始依次跟前边的比，比前边的小就往前移动。 也就是：

[3, 2, 1, 5]
[2, 3, 1, 5]
[1, 2, 3, 5]

(int j = i - 1; j >= 0 && temp < data[j]; j--)

回答于 2022-11-16

推荐文章