关闭

对五种排序的实现【java】

标签: 冒泡排序堆排序快速排序java
48人阅读 评论(0) 收藏 举报
分类:

冒泡排序:

package sort;

//冒泡
public class BubbleSort {
	private int[] a;
	public BubbleSort(int[] a) {
		// TODO Auto-generated constructor stub
		this.a = a;
	}
	
	//把小的冒泡到前面,即从小到大
	public void sort() {
		for (int i = 0;i < a.length;i++) {
			for (int j = i+1;j < a.length;j++) {
				if (a[i]>a[j]) {
					int t = a[i];
					a[i] = a[j];
					a[j] = t;
				}
			}
		}
	}
	
	public static void main(String[] args) {
		int a[] = {5,6,4,3,8,6,4};
		BubbleSort sort = new BubbleSort(a);
		sort.sort();
		for (int i:sort.a)
		System.out.println(i);
	}
	
}
插入排序:

package sort;

public class InsertSort {
	
	private int[] a;
	
	public InsertSort(int[] a) {
		// TODO Auto-generated constructor stub
		this.a = a;
	}
	
	//从小到大
	public void sort() {
		for (int i = 0;i < a.length;i++) {
			for (int j = 0;j < i;j++) {
				if (a[i]<a[j]) {
					int t = a[i];
					for (int k = i-1;k >= j;k--) {
						a[k+1] = a[k];
					}
					a[j] = t;
				}
			}
		}
	}
	
	public static void main(String[] args) {
		int a[] = {5,6,4,3,8,6,4};
		InsertSort sort = new InsertSort(a);
		sort.sort();
		for (int i:sort.a)
		System.out.println(i);
	}
}

归并排序:

package sort;


//归并
public class MergeSort {
	private int a[];
	private int length;
	
	public MergeSort(int a[]) {
		// TODO Auto-generated constructor stub
		this.a = a;
		this.length = a.length;
	}
	
	public void sort() {
		MergeSort(0,length-1);
	}
	
	public void MergeSort(int m,int n) {
		int mid = (m + n) / 2;
		if (m < n) {
			MergeSort(m, mid);
			MergeSort(mid + 1, n);
			Merge(m,mid,n);
		}
	}
	
	public void Merge(int m, int mid, int n) {
		System.out.println("Merge("+m+","+mid+","+n+")");
		int p1 = m;
		int p2 = mid + 1;
		int temp[] = new int[n-m+1];
		int p = 0;
		if (m<n) {
			while(p <= n - m) {
				if (p1<=mid&&p2<=n) {
					if (a[p1]<a[p2]) {
						temp[p++] = a[p1++];
					}else {
						temp[p++] = a[p2++];
					}
				}
				else {
					if (p1>mid&&p2<=n) {
						temp[p++] = a[p2++];
					}
					if (p2>n&&p1<=mid) {
						temp[p++] = a[p1++];
					}
				}
			}
			for (int i=0;i<temp.length;i++) {
				a[m + i] = temp[i];
			}
		}
	}
	public static void main(String[] args) {
		int a[] = {5,6,4,3,8,6,4};
		MergeSort sort = new MergeSort(a);
		sort.sort();
		for (int i:sort.a)
		System.out.print(i+",");
	}
}


堆排序:

package sort;


public class HeapSort {
	private int a[];
	private int length;
	public HeapSort(int a[]) {
		// TODO Auto-generated constructor stub
		this.a = a;
		this.length = a.length;
	}
	
	public void MaxHeap(int i) {
		//int parent = (i+1)/2-1;
		int left = 2*(i+1)-1;
		int right = 2*(i+1);
		if (left < length&&a[left] > a[right]&&a[left] > a[i]) {
			int t = a[i];
			a[i] = a[left];
			a[left] = t;
			MaxHeap(left);
		}
		else if (right < length&&a[left] < a[right]&&a[right] > a[i]) {
			int t = a[i];
			a[i] = a[right];
			a[right] = t;
			MaxHeap(right);
		}
	}
	
	public void MakeMaxHeap() {
		for (int i = length/2; i >= 0; i--) {
			MaxHeap(i);
		}
	}
	
	public void toLastPos(int i) {
		int t = a[0];
		a[0] = a[i];
		a[i] = t;
		length--;
	}
	
	public void sort() {
		
		if (a == null || length <= 1) {  
            return;  
        }  
		
		MakeMaxHeap();
		for (int i:a)
		System.out.println("in:"+i);
		//最大的被轮流挤进数组后面,最后变成由大到小排序好的数组
		for(int i = length-1; i > 1; i--) {
			toLastPos(i);
			MaxHeap(0);
		}
		//当剩下两个节点时,这时如果把最大的数挤入数组中会导致还有一个节点没有被排序
		//跳出循环后,剩下的两个节点执行一次MaxHeap(0)即完成了两个节点的排序
		MaxHeap(0);
	}
	
	public static void main(String[] args) {
		int a[] = {-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
		HeapSort sort = new HeapSort(a);
		sort.sort();
		for (int i:sort.a)
		System.out.println(i);
	}
}


快速排序:

package sort;

public class QuickSort {
	private int[] a;
	private int length;
	public final static int Left = 0;
	public final static int Right = 1;
	public QuickSort(int a[]) {
		// TODO Auto-generated constructor stub
		this.a = a;
		this.length = a.length;
	}
	
	public void QuickSort(int a[], int m, int n) {
		if (n<=m) {
			return;
		}
		int standard = choose(a, m, n);
		int left = m;//左指针
		int right = n;//右指针
		int LeftOrRight = Left;//默认指针左移
		while(left < right) {
			//指针左移
			if(LeftOrRight==Left) {
				if (a[right] > standard) {
					right--;
				}
				else if (a[right] <= standard&&a[left] >= standard) {
					int t = a[right];
					a[right] = a[left];
					a[left] = t;
					LeftOrRight = Right;
					//这里是为了处理两边都等于基准值的情况,先移动一个指针后让下面的逻辑去处理,以免进入死循环
					if (a[left] == standard&&a[right] == standard) {
						right--;
					}
				}
				else if (a[right] <= standard&&a[left] <= standard) {
					LeftOrRight = Right;//左右都小于基准值时,改变指针移动方向
				}
			}
			//指针右移
			else {
				if (a[left] < standard) {
					left++;
				}
				else if (a[left] >= standard&&a[right] >= standard) {
					LeftOrRight = Left;//左右都大于基准值时,改变指针移动方向
					//这里是为了处理两边都等于基准值的情况,先移动一个指针后让下面的逻辑去处理,以免进入死循环
					if (a[left] == standard&&a[right] == standard) {
						left++;
					}
				}
				else if (a[left] >= standard&&a[right] <= standard) {
					int t = a[right];
					a[right] = a[left];
					a[left] = t;
					LeftOrRight = Left;
				}
			}
		}
		//这里我增加了一段代码,由于在基准值的选择中会出现重复值,处理时找到基准值的最左边界和最右边界
		//理解拙劣,只能采用这种方法。。
		int times=0;
		for (int i = 0; i <a.length;i++) {
			if (a[i]==standard&×==0) {
				left = i;
				times++;
			}
			else if (a[i]==standard&×==0) {
				right = i;
			}
		}
		//System.out.println("m,n="+m+","+n+":standard="+standard);
		QuickSort(a,m,left-1);
		QuickSort(a,right+1,n);
	}
	
	public void sort() {
		QuickSort(a,0,length-1);
	}
	
	public int choose(int[] a, int m, int n){
		int standard = a[m];//选取第一个元素作为基准值
		return standard;
	}
	
	public static void main(String[] args) {
		int a[] = {5,6,4,3,8,6,4,5,234,2,35,23,5};
		QuickSort sort = new QuickSort(a);
		sort.sort();
		for (int i:sort.a)
		System.out.print(i+",");
	}
}



0
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

五种排序算法的JAVA 实现

1.插入排序 函数代码如下: public void insertSort(int length){ int k = 0; for(int present = 2; present <= length; present++){ t...
  • sinnnnnner
  • sinnnnnner
  • 2016-10-09 19:10
  • 278

5种常见排序方法深度剖析

# include # include using namespace std; size_t *InsertSort1(size_t *array, size_t size)//直接插入排序双循环写法 { assert(array); for (int i = 1; i { size_t tem...
  • renchunlin66
  • renchunlin66
  • 2016-04-06 20:05
  • 290

常见的几种排序方法

我们以数组a[ ]={2,6,8,9,1,2}进行排序输出作为列子:下面我来总结几种方法来帮助大家学习 1:常规排序        首先2和6对比,2不比6大不因此不交换,所以还是268912,然后2和89对比2都是比89小,还是268912,到了2和...
  • Hallo_ween
  • Hallo_ween
  • 2016-08-03 18:28
  • 795

java编程题:用Java实现一个简单选择排序算法

import java.util.Arrays; /** * java编程题:用Java实现一个简单选择排序算法 * * 基本思想: * 在长度为N的无序数组中,第一次遍历n-1个数,找到最小的数值与第一个元素交换; * 第二次遍历n-2个数,找到最小的数值与第二个元素交换; ...
  • min996358312
  • min996358312
  • 2017-03-28 12:02
  • 612

java实现9大排序算法

排序大的分类可以分为两种:内排序和外排序。在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序。一般来说外排序分为两个步骤:预处理和合并排序。首先,根据可用内存的大小,将外存上含有n个纪录的文件分成若干长度为t的子文件(或段);其次,利用内部排序的方法,对每个子文...
  • u011514810
  • u011514810
  • 2017-02-28 21:22
  • 1669

JAVA实现拓扑排序

折腾了很久才实现的拓扑排序,把代码和思路整理一下: 拓扑排序是用来对有向无环图进行排序的,和图的广度优先遍历类似,主要是利用队列把节点的入度为0(就是没有指向该节点的节点,只有从节点发出的)的元素入队,然后 1:将队首元素出队输出并寻找该元素的所有相邻元素的节点, 2:对这些节点的入度...
  • qq_20991785
  • qq_20991785
  • 2015-03-13 14:32
  • 741

java代码实现排序二叉树

创建排序二叉树的步骤:          1、以根节点为当前节点开始搜索          2、拿新节点的值和当前节点的值比较  ...
  • yanglun1
  • yanglun1
  • 2015-04-29 17:01
  • 925

快速排序(Quicktsort)之Java实现

快速排序算法介绍 快速排序和归并排序都使用分治法来设计算法,区别在于归并排序把数组分为两个基本等长的子数组,分别排好序之后还要进行归并(Merge)操作,而快速排序拆分子数组的时候显得更有艺术,取一个基准元素,拆分之后基准元素左边的元素都比基准元素小,右边的元素都不小于基准元素,这样只需要分别对两个...
  • kimylrong
  • kimylrong
  • 2013-12-05 13:14
  • 42565

Java实现桶排序

详细讲解见《算法导论》8.4节——桶排序。 Java代码如下: package linetimesort; import java.util.LinkedList; import sort.InsertSort; /** * 桶排序假设输入元素均匀而独立的分布在区间[0,1)上; * 桶排序...
  • l294265421
  • l294265421
  • 2015-05-19 19:24
  • 2145

java编程题:用Java实现一个冒泡排序算法

/** * java编程题:用Java实现一个冒泡排序算法 */ public class Test { public static void main(String[] args) { int[] sortNum = {12,33,28,86,15,62,9,38}; //定义数组...
  • min996358312
  • min996358312
  • 2017-03-21 16:07
  • 2174
    个人资料
    • 访问:908次
    • 积分:99
    • 等级:
    • 排名:千里之外
    • 原创:9篇
    • 转载:3篇
    • 译文:0篇
    • 评论:2条
    文章分类
    最新评论