`

几个排序算法(java版)

    博客分类:
  • Sort
阅读更多
//改进的冒泡算法
public class 改进的冒泡算法 {
public static void main(String args[]){
	int a[]={2,6,4,3,28,9,43,21,89,23};
	bubblesort(a);
	for(int i=0;i<a.length;i++){
		System.out.print(a[i]+" ");
	}
}
public static void bubblesort(int arr[]){
	boolean b =false;
	int temp;
	for(int i = 1;i<arr.length;i++){       //下标从第二个数开始,所以是1
		b=false;
		for(int j=arr.length-1;j>=i;j--){
			if(arr[j]<arr[j-1]){                //满足条件时,交换
				temp = arr[j];
				arr[j]=arr[j-1];
				arr[j-1]=temp;
				b = true;                     
			}
		}
		if(!b){
			break;
		}
	}
	
}
}

//快速排序算法1
public class 快速排序算法 {
public static void main(String args[]){
	int a[]={23,6,7,88,76,65,44,338,59};
	quicksort(a,0,a.length-1);
	for(int i=0;i<a.length;i++){
		System.out.print(a[i]+" ");
	}
}

public static  void quicksort(int arr[],int low,int high){
	int i,j,k;                          //三剑客的约定
	if(low<high){                  //先决条件
		i = low;
		j = high;
		k= arr[i];                   //找到适合位置
		while(i<j){              
			while(i<j&&arr[j]>k){
				j--;
			}
			if(i<j){
				arr[i]=arr[j];
				i++;
			}
			while(i<j&&arr[i]<k){
				i++;
			}
			if(i<j){
				arr[j]=arr[i];
				j--;
			}
		}
		arr[i]=k;                          //装到适合的位置
		quicksort(arr,low,i-1);      //递归
		quicksort(arr,i+1,high);   //递归
	}
}
}

//快速排序算法2
public class 快速排序2 {
public static void main(String ag[]){
	int a[]={23,6,7,88,76,65,44,338,59};
	quicksort2(a,0,a.length-1);
	for(int i=0;i<a.length;i++){
		System.out.print(a[i]+" ");
	}
}


public static void quicksort2(int arr[],int low,int high){
	 if(low<high){                                       //条件
		 int i=partion(arr,low,high);               //合适位置的获得 
			quicksort2(arr,low,i-1);
			quicksort2(arr,i+1,high);
	 }
}
public static int partion(int arr[],int low,int high){          //目的是找到一个合适的位置和置一个数!
	int temp = arr[low];                                                   //得到要置的数
	if(low<high){
		int k=arr[low];
		int mid=(low+high)/2;
		
		while(low<high&&k<arr[high]){
			high--;
		}
		if(low<high){
			arr[low]=arr[high];
			low++;
		}
		while(low<high&&k>arr[low]){
			low++;
		}
		if(low<high){
			arr[high]=arr[low];
			high--;
		}
	}
	arr[low]=temp;                                           //置数
	return low;
}
}

//归并排序
public class 归并排序算法 {

	public static void main(String[] args) {
		int a[]={23,6,7,88,76,65,44,338,59};
		mergesort(a,0,a.length-1);
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
   
	public static void mergesort(int arr[],int start,int end){     //主函数
		if(start<end){
			int mid = (start+end)/2;                 //关键一步
			mergesort(arr,start,mid);                //递归
			mergesort(arr,mid+1,end);             //递归
			merge(arr,start,mid,mid+1,end);     //调用下面的函数
		}
	}
	public static void merge(int arr[],int start1,int end1,int start2,int end2){        //被调用的函数
		int i , j, k=0;                                         //临时变量的使用
		i = start1;
		j=start2;
		int temp[] = new int[end2-start1+1];    //临时数组的大小规格
		while(i<=end1&&j<=end2){
		     if(arr[i]>arr[j]){
		    	 temp[k++]=arr[j++];
		     }else {
		    	 temp[k++]=arr[i++];
		     }
		}
		//把剩下的元素依次放入临时数组中
		while(i<=end1){
			temp[k++]=arr[i++];
		}
		while(j<=end2){
			temp [k++]=arr[j++];
		}
		//归还到原来的数组中去
		k = start1;
		for(int element :temp){
			arr[k++]=element;
		}
	}
}


分享到:
评论

相关推荐

    常用排序算法java演示

    首先,让我们逐一了解几种常见的排序算法: 1. **冒泡排序(Bubble Sort)**:这是一种简单的交换排序,通过重复遍历数组,比较相邻元素并根据需要交换它们,直到没有任何一对数字需要交换。Java中实现冒泡排序的...

    各种排序算法比较(java实现)

    本文将详细探讨标题所提及的几种排序算法:合并排序、插入排序、希尔排序、快速排序、冒泡排序以及桶排序,并结合Java语言的实现进行解析。 1. **合并排序(Merge Sort)**: 合并排序是一种基于分治策略的排序算法...

    java编写的几种排序算法

    本文将深入探讨在Java中实现的几种常见排序算法:冒泡排序、快速排序以及堆排序。 1. **冒泡排序(Bubble Sort)** 冒泡排序是最简单的排序算法之一,通过重复遍历数组,比较相邻元素并交换位置,直到没有任何一对...

    JAVA排序汇总 java应用中一些比较经典的排序算法

    本文将对几种经典的排序算法进行简要介绍和分析。 1. **插入排序**: 插入排序分为直接插入排序和折半插入排序。直接插入排序是将每个元素逐个插入已排序部分,而折半插入排序则是利用二分查找减少比较次数。希尔...

    Java常用8大排序算法

    除了以上介绍的四种排序算法外,Java中还有以下几种常用的排序算法: 1. **冒泡排序**:每次比较两个相邻的元素,如果它们的顺序错误就把它们交换过来。遍历所有元素之后,最大的元素就会被放到最后的位置上。然后...

    数据结构java版 排序算法

    本篇文章将深入探讨几种常见的排序算法,并通过Java代码示例进行解析。 ### 1. 插入排序 - **直接插入排序**:在已排序部分后依次插入新元素,不断调整已排序部分,直至整个数组有序。 - **折半插入排序**:改进了...

    内部排序算法java实现

    这里我们将深入探讨Java实现的几种内部排序算法,包括希尔排序、快速排序、堆排序、归并排序、冒泡排序、插入排序和选择排序。 首先,希尔排序是一种基于插入排序的算法,通过将原始数组分解成多个子序列来提高效率...

    常用的排序算法(java实现),附带一个PPT动画演示、详解了其中三种

    除了插入排序和希尔排序,压缩包中还可能包含了其他几种常见的排序算法的Java实现,如冒泡排序、快速排序、选择排序、归并排序和堆排序等。每种排序算法都有其特定的适用场景和性能特点。例如,冒泡排序虽然简单,但...

    JAVA版BM25排序模型

    在这个JAVA版的实现中,我们主要关注以下几个知识点: 1. **TF-IDF**: TF-IDF是一种统计方法,用于评估一个词在文档中的重要性。TF(Term Frequency)是词在文档中出现的次数,IDF(Inverse Document Frequency)是...

    Java所有排序算法大全

    本文将深入探讨Java中常见的几种排序算法,包括它们的工作原理、优缺点以及如何在实际编程中应用。 首先,我们来看`BubbleSortAlgorithm.java`,它实现的是冒泡排序。冒泡排序是一种简单的交换排序,通过重复遍历...

    JAVA排序算法集合

    以上介绍了Java排序算法中常见的几种方法及其变体。每种算法都有其特点和适用场景,例如当数据量较小时可以选择直接插入排序或直接选择排序;当数据量较大时,归并排序和快速排序则更为合适。理解这些算法的工作原理...

    Java各种排序算法代码

    下面我们将详细探讨Java中常见的几种排序算法。 1. 冒泡排序(Bubble Sort) 冒泡排序是一种简单的交换排序,通过不断比较相邻元素并交换位置,将最大或最小的元素逐渐“冒泡”到数组的一端。虽然效率较低,但其...

    IT面试笔试-各种排序算法Java实现

    本文将详细介绍几种经典的排序算法,并提供Java语言的实现代码,包括冒泡排序、插入排序、选择排序和快速排序。这些算法不仅在面试中常被考察,而且在实际开发中也有广泛应用。 1. **冒泡排序(Bubble Sort)**: ...

    常见排序算法的实现与性能比较JAVA版

    常见排序算法的实现与性能比较JAVA 问题描述:实现合并排序,插入排序,希尔排序,快速... 3) N=1000,10000,100000时,每个排序用不同的样本多试验几次(最低5次)得出平均时间,比较不同排序算法所用的平均时间。

    各种排序算法 JAVA代码实现

    根据提供的文件信息,我们可以归纳总结出以下几个主要的排序算法及其JAVA代码实现: ### 1. 插入排序(Insert Sort) 插入排序是一种简单的排序方法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序...

    三种线性排序算法Java实现

    桶排序是一种分布式排序算法,将待排序的数据分到几个有序的桶里,每个桶再分别排序。桶内排序完成后,再按照顺序依次取出所有桶中的元素。这种算法适用于数据分布均匀且数据范围与桶的数量成正比的情况。`...

    java实现数据结构常见排序算法及详解

    ### Java 实现数据结构常见排序算法及详解 #### 排序算法概述 排序算法是计算机科学中的基础概念之一,主要用于将一系列数据按照特定规则进行排列。根据数据处理方式的不同,排序算法大致分为两大类:比较排序与非...

    几种常用的排序法 java程序

    本资源包含了一些常见的排序算法的Java实现,包括快速排序、堆排序和归并排序。下面将对这些排序算法进行详细介绍,并探讨它们的原理、优缺点以及适用场景。 1. 快速排序(Quick Sort) 快速排序是一种分治策略的...

    各类排序算法java的实现

    根据提供的文件信息,我们可以深入探讨几种不同的排序算法在Java中的实现。这些算法包括插入排序(Insert Sort)、冒泡排序(Bubble Sort)、选择排序(Selection Sort)以及希尔排序(Shell Sort)。接下来,我们将...

Global site tag (gtag.js) - Google Analytics