Algorithm.Sort （各类排序）

最新推荐文章于 2021-12-23 23:14:42 发布
最新推荐文章于 2021-12-23 23:14:42 发布
阅读量509 收藏 1
点赞数
分类专栏： 算法 文章标签： Java 算法 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34690598/article/details/51175169
版权

(排序的递归分为 分治法和归纳法)

    冒泡排序及其递归实现

    堆排序

    插入排序及其递归实现

    合并排序及其递归实现

    快速排序

    选择排序及其递归实现

    希尔排序

package Algorithm.Sort;

import java.util.Vector;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class BubbleSwapSort<E extends Comparable<E> > {
	public void Sort(Vector<E> v)
	{
		for(int i = 0 ; i < v.size() ; ++i)
		{
			for(int j = i+1 ; j < v.size() ; ++j)
			{
				E first = v.get(i);
				E second = v.get(j);
				if(first.compareTo(second) > 0)
				{
					v.set(i, second);
					v.set(j, first);
				}
			}
		}
	}
	
	public void SortByExcursion(Vector<E> v,int low)
	{
		if(low == v.size()) return;
		for(int j = low+1;j < v.size() ;++j)
		{
			E first = v.get(low);
			E second = v.get(j);
			if(first.compareTo(second) > 0)
			{
				v.set(low, second);
				v.set(j, first);
			}
		}
		SortByExcursion(v,low+1);
	}
	

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<Integer>();
		v.add(10);
		v.add(20);
		v.add(30);
		v.add(15);
		v.add(50);
		v.add(25);
		v.add(40);
		v.add(80);
		v.add(100);
		v.add(1);
		v.add(2);
		
		BubbleSwapSort<Integer> s = new BubbleSwapSort<Integer>();
		//s.Sort(v);
		s.SortByExcursion(v, 0);
		System.out.println(v);
	}

}

package Algorithm.Sort;
import java.util.Vector;
import Structure.Heap.MaxHeap;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class HeapSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<Integer>();
		v.add(30);
		v.add(60);
		v.add(8);
		v.add(40);
		v.add(70);
		v.add(12);
		v.add(10);
		
		MaxHeap<Integer> mh = new MaxHeap<Integer>(10);
		mh.BuildHeap(v);
		mh.Print();
		System.out.println();
		
		mh.Sort();
		mh.Print();

	}

}

package Algorithm.Sort;
import java.util.Vector;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class InsertionSort<E extends Comparable<E> > {
	private void Swap(Vector<E> v,int i,int j)
	{
		E temp = v.get(i);
		v.set(i, v.get(j));
		v.set(j, temp);
	}
	
	public void Sort(Vector<E> v)
	{
		for(int i = 1; i < v.size() ; ++i)
		{
			E cur = v.get(i);
			int j = i-1;
			while(j>=0 && v.get(j).compareTo(cur) > 0)
			{
				Swap(v,j,j+1);
				j--;
			}
			v.set(j+1, cur);
		}
	}

	public void SortByExcursion(Vector<E> v,int low)
	{
		if(low > 1)
		{
			E cur = v.get(low);
			SortByExcursion(v,low-1);
			int j = low - 1;
			while(j >= 0 && v.get(j).compareTo(cur) > 0)
			{
				Swap(v,j,j+1);
				j--;
			}
			v.set(j+1, cur);
		}
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<Integer>();
		v.add(10);
		v.add(20);
		v.add(30);
		v.add(15);
		v.add(50);
		v.add(25);
		v.add(40);
		v.add(80);
		v.add(100);
		v.add(1);
		v.add(2);
		
		InsertionSort<Integer> i = new InsertionSort<Integer>();
		//i.Sort(v);
		
		i.SortByExcursion(v, v.size()-1);
		System.out.println(v);

	}

}

package Algorithm.Sort;
import java.util.Vector;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class MergeSort<E extends Comparable<E> > {
	
	public void Copy(Vector<E> src,Vector<E> dst)
	{
		for(int i = 0 ; i < src.size() ; ++i)
		{
			dst.insertElementAt(src.get(i), i);
		}
	}
	public void Sort(Vector<E> v)
	{
		int size = 1;
		int times = v.size()%2 + v.size()/2;
		Vector<E> tempVector = new Vector<E>(v.size());
		for(int i = 0 ; i < times ; ++i)
		{
			tempVector.clear();
			Copy(v, tempVector);
			int lLow;
			int lHigh;
			int rLow;
			int rHigh;
			int currentRound = v.size()/(2*size)+v.size()%(2);
			for(int j = 0;j< currentRound;++j)
			{
				lLow = 2*size*j;
				lHigh = lLow+size-1;
				rLow = lHigh+1;
				if(j != currentRound -1)
				{
					rHigh = rLow+size-1;
				}else rHigh = v.size()-1;
				Sort(v,tempVector,lLow,lHigh,rLow,rHigh);
			}
			v.clear();
			Copy(tempVector,v );
			size *= 2;
		}
	}
	
	public void Sort(Vector<E> v,int low,int high)
	{
		if(low < high)
		{
			int mid = (low+high)/2;
			Sort(v,low,mid);
			Sort(v,mid+1,high);
			
			Vector<E> dst = new Vector<E>(v);
			Sort(v,dst,low,mid,mid+1,high);
			for(int i = low;i <= high; ++i)
			{
				v.set(i, dst.get(i));
			}
		}
	}
	
	private void Sort(Vector<E> v,Vector<E> dst,int leftLow,int leftHigh,int rightLow,int rightHigh)
	{
		int i = leftLow;
		int j = rightLow;
		int p = leftLow;
		while(i <= leftHigh && j <= rightHigh)
		{
			E left = v.get(i);
			E right = v.get(j);
			if(left.compareTo(right) > 0)
			{
				dst.set(p, right);
				j++;
			}
			else{
				dst.set(p, left);
				i++;
			}
			++p;
		}
		if(j == 1+ rightHigh) 
		{
			while(i <= leftHigh)
			{
				dst.set(p++, v.get(i));
				++i;
			}
		}else if(i == 1+ leftHigh)
		{
			while(j <= rightHigh)
			{
				dst.set(p++, v.get(j));
				++j;
			}
		}
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<Integer>();
		v.add(10);
		v.add(20);
		v.add(30);
		v.add(15);
		v.add(50);
		v.add(25);
		v.add(40);
		v.add(80);
		v.add(100);
		v.add(1);
		v.add(2);
		
		MergeSort<Integer> ms = new MergeSort<Integer>();
		//ms.Sort(v);
		
		ms.Sort(v, 0, v.size()-1);
		
		System.out.println(v);
	}

}

package Algorithm.Sort;
import java.util.Vector;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class QuickSort<E extends Comparable<E> > {
	private void Swap(Vector<E> v,int i,int j)
	{
		E temp = v.get(i);
		v.set(i, v.get(j));
		v.set(j, temp);
	}
	
	public void Pick(Vector<E> v,int low,int high,int m)
	{
		if(low >= high) return;
		int mid = (low+high)/2;
		
		if(v.get(low).compareTo(v.get(mid))  >0) Swap(v,low,mid);
		if(v.get(low).compareTo(v.get(high)) >0) Swap(v,low,high);
		if(v.get(mid).compareTo(v.get(high)) >0) Swap(v,mid,high);
		Swap(v,mid,high-1);
		
		if(low == high -1) return;
		
		int k =low;
		int r = high-1;
		
		E compare = v.get(high-1);
		while(true)
		{
			while(v.get(++k).compareTo(compare)<0);
			while(v.get(--r).compareTo(compare)>0);
			if(k < r) Swap(v,k,r);
			else break;
		}
		Swap(v,k,high-1);
		
		if(m<k) Pick(v,low,k-1,m);
		else Pick(v,k+1,high,m-k);
	}
	
	public void Sort(Vector<E> v,int low,int high)
	{
		if(low >= high) return;
		int mid = (low+high)/2;
		
		if(v.get(low).compareTo(v.get(mid))  >0) Swap(v,low,mid);
		if(v.get(low).compareTo(v.get(high)) >0) Swap(v,low,high);
		if(v.get(mid).compareTo(v.get(high)) >0) Swap(v,mid,high);
		Swap(v,mid,high-1);
		
		if(low == high -1) return;
		
		int k =low;
		int r = high-1;
		
		E compare = v.get(high-1);
		while(true)
		{
			while(v.get(++k).compareTo(compare)<0);
			while(v.get(--r).compareTo(compare)>0);
			if(k < r) Swap(v,k,r);
			else break;
		}
		Swap(v,k,high-1);
		
		Sort(v,low,k-1);
		Sort(v,k+1,high);
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<Integer>();
		v.add(10);
		v.add(20);
		v.add(30);
		v.add(15);
		v.add(50);
		v.add(25);
		v.add(40);
		v.add(80);
		v.add(100);
		v.add(1);
		v.add(2);
		
		QuickSort<Integer> q = new QuickSort<Integer>();
		//q.Sort(v,0,v.size()-1);
		//System.out.println(v);
		
		q.Pick(v, 0, v.size()-1, 7);
		System.out.println(v.get(7));
	}

}

package Algorithm.Sort;
import java.util.Vector;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class SelectionSort<E extends Comparable<E> > {
	public void Sort(Vector<E> v)
	{
		for(int i = 0 ; i < v.size() ; ++i)
		{
			int current = i;
			for(int j = i+1 ; j < v.size() ; ++j)
			{
				E cur = v.get(current);
				E now = v.get(j);
				if(now.compareTo(cur) < 0) current = j;
			}
			if(current != i)
			{
				E temp = v.get(current);
				v.set(current, v.get(i));
				v.set(i, temp);
			}
		}
	}
	
	public void SortByExcursion(Vector<E> v,int low)
	{
		if(low == v.size()) return;
		int current = low;
		for(int j = low + 1; j < v.size() ; ++j)
		{
			E cur = v.get(current);
			E now = v.get(j);
			if(now.compareTo(cur) < 0) current = j;
		}
		if(current != low)
		{
			E temp = v.get(current);
			v.set(current, v.get(low));
			v.set(low, temp);
		}
		SortByExcursion(v,low+1);
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<Integer>();
		v.add(10);
		v.add(20);
		v.add(30);
		v.add(15);
		v.add(50);
		v.add(25);
		v.add(40);
		v.add(80);
		v.add(100);
		v.add(1);
		v.add(2);
		
		SelectionSort<Integer> s = new SelectionSort<Integer>();
		s.SortByExcursion(v, 0);
		//s.Sort(v);
		
		System.out.println(v);
	}

}

package Algorithm.Sort;
import java.util.Vector;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class ShellSort<E extends Comparable<E> > {
	private void Swap(Vector<E> v,int i,int j)
	{
		E temp = v.get(i);
		v.set(i, v.get(j));
		v.set(j, temp);
	}
	
	private void ShellStep(Vector<E> v,int step,int start)
	{
		for(int i = start+step; i < v.size(); i = i + step)
		{
			E temp = v.get(i);
			int j = i - step;
			while(j >= start && v.get(j).compareTo(temp) > 0)
			{
				Swap(v,j,j+step);
				j = j - step;
			}
			v.set(j+step, temp);
		}
	}
	
	public void Sort(Vector<E> v)
	{
		int size = 1;
		for(; size < v.size() ; )
		{
			size = 3*size+1;
		}
		size = (size - 1)/3;
		while(size >= 1)
		{
			for(int i = 0 ; i < size ;++i )
			{
				ShellStep(v,size,i);
				size = (size - 1)/3;
			}
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<Integer>();
		v.add(10);
		v.add(20);
		v.add(30);
		v.add(15);
		v.add(50);
		v.add(25);
		v.add(40);
		v.add(80);
		v.add(100);
		v.add(1);
		v.add(2);
		
		ShellSort<Integer> s = new ShellSort<Integer>();
		s.Sort(v);
		System.out.println(v);

	}

}


qq_34690598
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Algorithm-Sort算法
zy2317878的博客
05-01 390
写在前面 今天来整理一下排序算法，排序也是算法中的经典问题，平时练习的机会其实不多，因为一般直接sort(v.begin(), v.end())，就解决了。所以，还是系统学习一下，其实以后涉及到sort函数可以手写。参考文章：常用排序算法总结(一)。 最好例题就是：LeetCode-75. Sort Colors。 排序算法大致分为两种： 比较排序：时间复杂度：O(nlogn) ~ O(...
sort函数的用法(C++排序库函数的调用)
weixin_30680385的博客
01-11 1047
对数组进行排序，在c++中有库函数帮我们实现，这们就不需要我们自己来编程进行排序了。 （一）为什么要用c++标准库里的排序函数 Sort（）函数是c++一种排序方法之一，学会了这种方法也打消我学习c++以来使用的冒泡排序和选择排序所带来的执行效率不高的问题！因为它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)，执行效率较高！ （二）c++标准库里的排序函数的使用方法 I）...
Sort Algorithm
Hcode4的博客
09-17 354
1. DirectInsert sort   直接插入排序，将所要排序的数字放到有序队列中 void DirectInsert(int a[10] , int num){ int i = 0; int j ; int temp ; for( ; i &lt; num ; i++){ for( j = i ; j &gt; 0 ; j-- ){ if(a[j] &lt; a[...
algorithm——sort（eg.The Dragon of Loowater)
LightOn
09-01 204
algorithm 中 sort函数（快排实现，时间复杂度 O(nlogn)）： sort函数：sort（first，end，method）//其中第三个参数为可选参数。 参数含义： first：需要排序数组的起始位置 end：终止位置 method：是一个方法，用来决定sort函数的排序方式 1.当只有两个参数时，则默认排序为从小到大 （应用见例题） 2.当有3个参数时，则要实现...
algorithm中sort函数
Pastthewind的博客
05-24 811
先看一个nowcoder.com的一道考研复试题： https://www.nowcoder.com/practice/b744af632ac4499aa485d7bb048bb0aa?tpId=40&tqId=21556&tPage=1&rp=1&ru=/ta/kaoyan&qru=/ta/kaoyan/question-ranking 题目描述 对N个长度最长可达到1000的数进行排
sort-algorithm.rar_时间排序
09-24
实现简单的排序，如冒泡排序，选择排序等，并能计算排序时间
sort-algorithm.zip_mfc sort_mfc 排序过程
09-19
该MFC程序对插入排序，希尔排序，堆排序的排序原理和过程通过动画的形式展示给用户，让用户更加直观了解排序算法的原理。
Sort-algorithm.zip_插入排序_直接插入排序
09-21
几种内部排序算法总结!(冒泡排序、快速排序、直接插入排序、拆半插入排序、简单选择排序)
SortAlgorithm.rar
06-10
几种今典的排序算法
sort_algorithm.c
05-20
冒泡、快排和插入
algorithm中的sort函数
不管风雨有多少丶的博客
04-20 488
#include<cstdio> #include<algorithm> #include<iostream> using namespace std; bool cmp(int a,int b){ return a>b;//此处为定义函数为从大到小排序； //若为a<b为从小到大排序！ } int main(){ int a[100]={3...
使用algorithm中的sort函数对数据进行排序
qq_36769722的博客
07-10 1012
// 使用sort()函数对自定义类型排序.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include&lt;algorithm&gt; #include&lt;string&gt; #include&lt;iostream&gt; #include&lt;functional&gt; using namespace std; #include&lt...
关于algorithm的sort函数
ACM_Cmy的博客
01-16 290
sort函数是我们算法比赛中最简单的最快的一个算法，他的时间复杂度是nlogn，最坏的时候是n^2，基本思想是快速排序，但是被封装的时候进行了许多优化，所以基本达不到n^2的速度 那么我们如何使用好这个东西是一个非常关键的问题，因为我们打比赛的时候，可以说是不可能写出比sort还快的排序算法 用好sort我们需要学好如何重构（operator）和写cmp函数 其实，鄙人觉得，...
排序算法--Sort Algorithm
YZG ' BLOG
12-23 1233
一、排序算法的概念： 排序也称排序算法 (Sort Algorithm)，排序是将一 组数据，依指定的顺序进行排列 的过程 二、排序算法的分类： 1) 内部排序: 指将需要处理的所有数据都加载 到内部存储器中进行排序。 2) 外部排序法： 数据量过大，无法全部加载到内 存中，需要借助外部存储进行 排序 三、算法的时间复杂度 时间频度:一个算法中的语句执行次数称为语句频度或时间频度。记为T(n) 时间复杂度：一般情况下，算法中的基本操作语句的...
STL下<algorithm>下的sort函数
weixin_30339457的博客
09-08 259
定义： sort函数用于C++中，对给定区间所有元素进行排序，默认为升序，也可进行降序排序。sort函数进行排序的时间复杂度为nlog2n，比冒泡之类的排序算法效率要高，sort函数包含在头文件为#include<algorithm>的c++标准库中。 语法： sort(start,end,cmp) （1）start表示要排序数组的起始地址； （2）end表示数组结...
STL c++ algorithm--sort
梦想之深邃
05-09 254
头文件#include&lt;algorithm&gt;常用sort函数：默认为升序序列         时间复杂度O(nlog2n)1）sort()             //排序      2参数：sort(begin,end)、3参数：sort(begin,end,compare)     //compare为比较规则//begin为起始位置，end为终止位置，对区间[begin,end-...
Sort algorithm 10
GeorgeDiDi的博客
02-11 1332
10个经典排序算法
sort algorithm(2)
Daria
09-22 147
sort algorithm(2) merge_sort 千好万好对空间不友好,不仅额外需要辅助数组空间(tmp),还在tmpA与tmp之间倒来倒去 ; 实际情况不用于内排序,外排序(空间非主要矛盾时)应用效果好 1.merger sort click for power! 指针不一定为指针变量,只要起到指示位置(下标)作用即可 在归并排序开始声明临时数组并传入,整个归并排序过程中...
C++ 实现十大排序算法
weixin_38169798的博客
07-29 229
教你手撕排序，这里有一个概念就是稳定排序。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。并不是其算法复杂度的稳定，注意一下 代码均经过测试，如果找到代码bug可以留言 算法（Algo...
algorithm.algorithm_variant.tactic
最新发布
02-08
algorithm.algorithm_variant.tactic 是 CSDN 开发的 C知道 中的一个主题，它涉及到算法的变种和策略。在算法设计中，有时候我们需要根据不同的情况选择不同的算法变种或者策略来解决问题。这个主题主要包括以下内容...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值