package other;
import java.util.Random;
public class Main {
public static void main(String[] args) {
int b = -100000;
System.out.println("b的源码是:"+Integer.toBinaryString(b));
Random r = new Random();
Main m = new Main();
int[] a = new int[100];
for (int i = 0; i < a.length; i++) {
a[i] = r.nextInt(100) + 1; // 生成[1,100]的整数
}
long time1 = System.currentTimeMillis();
m.bubbleSort(a); //冒泡排序
long time2 = System.currentTimeMillis();
System.out.println("冒泡排序"+(time2 - time1) + "ms");
System.out.println("冒泡排序后:数组a中元素:");
for (int i = 0; i < a.length; i++)
System.out.println(a[i]);
}
//矩阵乘法
public void Multiply(int[][] A, int[][] B) { // 矩阵A和B进行相乘
int[][] C;
if (A[0].length != B.length) {
System.out.println("不能进行矩阵相乘运算");
}
C = new int[A.length][B[0].length];
for (int i = 0; i < A.length; i++) {
for (int j = 0; j < B[0].length; j++)
for (int k = 0; k < A[0].length; k++) {
C[i][j] = A[i][k] * B[k][j] + C[i][j];
}
}
}
//-----------------------快速排序begin---------------------------------//
public void quickSort(int[] array, int p, int r) {// 快速排序,使数组array从p到r变成有序的
// 分治策略
if (p < r) {
int q = partion(array, p, r); // 分割成两部分,其中一部分的所有元素小于另一部分中的所有元素,q是中间位置
// 分别对于两部分进行快速排序
quickSort(array, p, q - 1);
quickSort(array, q + 1, r); // 递归调用
}
}
private int partion(int[] array, int p, int r) { // 就是对array进行原地排序,
int x = array[r];
int i = p - 1;
int temp;
for (int j = p; j <= r - 1; j++) { // j指向当前的待排序元素
if (array[j] < x || array[j] == x) {
i++;// i指向小于x的部分的最后一个数
temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
temp = array[i + 1];
array[r] = temp;
array[i + 1] = x; // 将中轴换到两个部分的中间位置
return i + 1; // 中轴的位置,中轴左侧都是小于等于中轴值,中轴右侧部分都大于中轴值
}
//-----------------------快速排序end---------------------------------//
//-----------------------选择排序begin---------------------------------//
public void selectionSort(int[] array) { // 选择排序
int j;
int temp = 0;
int min = 0;
for (int i = 0; i < array.length - 1; i++) { //注意这个边界是array.length-1,因为如果前面n-1个有序了,最后一个肯定是最大的
min = i;
for (j = i+1 ; j <= array.length - 1; j++) {
if (array[min] > array[j])
min = j;
}
temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
//-----------------------选择排序end---------------------------------//
//-----------------------归并排序begin---------------------------------//
public void mergeSort(int[] a, int p, int r) { // 归并排序,从数组a的p位置到r位置排序
int q;
if (p < r) {
q = (p + r) / 2;
mergeSort(a, p, q);
mergeSort(a, q + 1, r);
merge(a, p, q, r);// 将已经有序的a[p...q]和a[q+1...r]归并成一个有序的a[p...r]
}
}
private void merge(int[] a, int p, int q, int r) { //归并两个有序序列a[p...q]和a[q+1...r]成为有序的a[p...r]
int n1 = q - p + 1;
int n2 = r - q;
int[] L = new int[n1]; //辅助数组
int[] R = new int[n2];//辅助数组
for (int i = 0; i < n1; i++) {
L[i] = a[i + p];
}
for (int i = 0; i < n2; i++) {
R[i] = a[i + q + 1];
}
int i = 0, j = 0;// 分别指向L和R两个数组中元素的指针
int k = p; // 指向结果数组元素的指针
while (i < n1 && j < n2) {
if (L[i] <= R[j]) { //两个有序数组的元素进行比较,谁小就加入到结果数组中,并将指针往前移一步
a[k] = L[i];
i++;
k++;
} else {
a[k] = R[j];
j++;
k++;
}
}
if (i < n1) {//while条件不满足了,肯定是 j=n2了,R先插入完,
while (i < n1) {
a[k] = L[i];
k++;
i++;
}
}
if (j < n2) { //while条件不满足了,肯定是 i=n2了,L先插入完
while (j < n2) {
a[k] = R[j];
k++;
j++;
}
}
}
//-----------------------归并排序end---------------------------------//
//-----------------------插入排序begin---------------------------------//
public void insertSort(int[] a){
int i,j,key;
for(i=1;i<a.length;i++){
j=i-1; //有序列的最后一个元素下标
key = a[i];//当前待插入的元素
//将当前元素插入到已经排好序的a[0...i-1]中
while(key<a[j]&&j>0){
a[j+1]=a[j]; //将元素往后移
j--;
}
a[j+1] = key; //插入当前元素
}
}
//-----------------------插入排序end---------------------------------//
//-----------------------冒泡排序begin---------------------------------//
public void bubbleSort(int[] a){
int temp;
for(int i=0;i<a.length;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j]>a[j+1]){ //逆序时,交互相邻两个元素
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
//-----------------------冒泡排序end---------------------------------//
}
分享到:
相关推荐
本文将深入探讨Java编程语言中实现的七种主要排序算法:直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序以及归并排序。每种算法都有其独特性,适用于不同的场景和数据特性。 1. **直接插入排序**:...
java实现10种排序算法:选择排序、冒泡排序、插入排序、快速排序、归并排序、堆排序、希尔排序、桶排_sorting-algorithms
本篇文章将详细讲解标题中提到的六种常见排序算法的Java实现。 1. **冒泡排序**:冒泡排序是最基础的排序算法之一,它通过不断交换相邻的逆序元素来逐渐将较大的元素“浮”到数组的前端。在Java中,冒泡排序的基本...
排序算法java版,速度排行:冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序.mht
这里我们将深入探讨标题和描述中提到的六种排序算法:快速排序、归并排序、插入排序、冒泡排序、选择排序以及堆排序。 1. **快速排序**:由C.A.R. Hoare在1960年提出,是一种高效的分治算法。快速排序的基本思想是...
八种排序算法原理及Java实现是排序算法中的一种,包括冒泡排序、快速排序、直接插入排序、希尔排序、选择排序、归并排序和基数排序等。 冒泡排序是八种排序算法中的一种,属于交换排序。冒泡排序的基本思想是重复...
本篇文章将深入探讨五种常见的排序算法,并以Java编程语言为实现背景。这些算法包括冒泡排序、插入排序、选择排序、归并排序以及快速排序。 **冒泡排序**是一种基础的排序方法,它通过重复遍历数组,比较相邻元素并...
除了冒泡排序之外,还有其他各种高效的排序算法,如快速排序、归并排序、堆排序、插入排序、选择排序等。每种算法都有各自的优势和局限性,适合不同的使用场景。 快速排序是一个高效的排序算法,采用分治法来把一个...
冒泡排序是一种基础且经典的排序算法,主要应用于教学和理解排序的基本原理。...以上就是关于Java实现冒泡排序算法的相关知识点,通过学习和实践,不仅可以掌握冒泡排序,也能为学习更复杂的排序算法打下坚实的基础。
在提供的"冒泡归并和快排"压缩包文件中,你将找到这些排序算法的Java实现,可以直接运行并观察它们的排序效果。这些源代码可以帮助你理解每种排序算法的工作原理,并在实践中应用它们。对于学习和提升Java编程技能,...
以下是关于Java实现的七种排序算法的详细说明: 1. **冒泡排序(Bubble Sort)**: 冒泡排序是一种简单的排序算法,通过不断交换相邻两个元素的位置来逐步将较大的元素推向数组的后部。它的主要思想是重复遍历数组...
在计算机科学中,排序算法是数据...更高效的排序算法如快速排序、归并排序和堆排序等,在性能和复杂度上都有显著提升,更适合于实际应用。然而,了解和掌握基础的排序算法,对于理解和优化更复杂的算法具有重要意义。
Java代码-排序-直接插入排序、希尔排序、直接选择排序、冒泡排序、堆排序、快速排序、归并排序中部分排序以及算法-贪心法,大家可以将源码下载下来进行学习,附带着注释和解释,有不理解的可以找博主一起探讨,共同...
这里我们将深入探讨快速排序、归并排序、希尔排序、冒泡排序、选择排序以及插入排序这六种经典的排序算法,并通过Java语言来实现它们。 1. **快速排序**:由C.A.R. Hoare在1960年提出,是基于分治策略的一种高效...
Java排序算法实现主要涉及到两种经典的算法:冒泡排序和选择排序。这两种算法都是基于比较的排序方法,适用于小规模或教学目的的数据排序。 **冒泡排序(Bubble Sort)** 是一种简单直观的排序算法,其核心思想是...
排序是程序设汁中常见的任务,在数据结构课程中介绍了很多种排序方法,有插入排序、交换排序、选择排序、归并排序、...本设计中,我分别采用基数排序、冒泡排序、归并排序算法对随机产生的三百名同学的成绩进行排序。
本文将详述Java语言实现的六种经典排序算法:冒泡排序、选择排序、插入排序、归并排序、希尔排序以及快速排序。这些排序算法各有特点,适用于不同的场景。 1. 冒泡排序(Bubble Sort) 冒泡排序是一种简单的排序...
交换排序是指通过交换记录的位置来实现排序的算法,常见的交换排序算法有冒泡排序和快速排序。冒泡排序的时间复杂度为 O(n^2),而快速排序的时间复杂度为 O(nlogn)。快速排序是一种高效的排序算法,但它是不稳定的...
本文将深入探讨四种常见的排序算法:快速排序、归并排序、冒泡排序和选择排序。这些算法不仅在理论上有其重要性,而且在实际编程项目中也经常被用到。 ### 快速排序 快速排序是由英国计算机科学家C.A.R. Hoare提出...
这个名为"Java各种排序算法代码.zip"的压缩包包含了一系列实现不同排序算法的Java源代码。排序算法是计算机科学中的基本概念,用于对一组数据进行排列。下面将详细讨论这些算法及其在Java中的实现。 1. 冒泡排序...