部分排序
import java.util.Arrays;
class SStudent
{
private int num;
String name;
public int getNum()
{
return num;
}
public String toString()
{
// TODO Auto-generated method stub
return "学号:"+num+"姓名:"+name;
}
public SStudent(int num, String name)
{
super();
this.num = num;
this.name = name;
}
public void setNum(int num)
{
this.num = num;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
public class ObjectSort
{
//定义一个对象数组
static SStudent s[]={new SStudent(9,"java"),new SStudent(5,"C语言"),new SStudent(13,"Linux"),new SStudent(6,"Oracle"),new SStudent(8,"JavaEE")};
/**
* 对象数组的冒泡排序
*/
public static void fun()
{
for(int i=0;i<s.length-1;i++)
{
for(int j=i+1;j<s.length;j++)
{
if(s[i].getNum()>s[j].getNum())
{
int temp=s[i].getNum();
s[i].setNum(s[j].getNum());
s[j].setNum(temp);
}
}
}
System.out.println("冒泡排序的结果为:");
System.out.print(Arrays.toString(s));
}
/**
* 对象数组的选择排序
*/
public static void select()
{
for(int i=0;i<s.length;i++)
{
int min=i;
for(int j=i+1;j<s.length;j++)
{
if(s[min].getNum()>s[j].getNum())
{
min=j;
}
}
if(min!=i)
{
int temp=s[i].getNum();
s[i].setNum(s[min].getNum());
s[min].setNum(temp);
}
}
System.out.println("\n选择排序的结果为:");
System.out.print(Arrays.toString(s));
}
public static void main(String[] args)
{
//调用对象数组的冒泡排序
fun();
//调用对象数组的选择排序
select();
}
}
对象数组的整体排序
import java.util.Arrays;
class SStudent
{
private int num;
String name;
public int getNum()
{
return num;
}
public String toString()
{
// TODO Auto-generated method stub
return "学号:"+num+"姓名:"+name;
}
public SStudent(int num, String name)
{
super();
this.num = num;
this.name = name;
}
public void setNum(int num)
{
this.num = num;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
public class ObjectSort
{
//定义一个对象数组
static SStudent s[]={new SStudent(9,"java"),new SStudent(5,"C语言"),new SStudent(13,"Linux"),new SStudent(6,"Oracle"),new SStudent(8,"JavaEE")};
/**
* 对象数组的冒泡排序
*/
public static void fun()
{
for(int i=0;i<s.length-1;i++)
{
for(int j=i+1;j<s.length;j++)
{
if(s[i].getNum()>s[j].getNum())
{
SStudent temp=s[i];
s[i]=s[j];
s[j]=temp;
}
}
}
System.out.println("冒泡排序的结果为:");
System.out.print(Arrays.toString(s));
}
/**
* 对象数组的选择排序
*/
public static void select()
{
for(int i=0;i<s.length;i++)
{
int min=i;
for(int j=i+1;j<s.length;j++)
{
if(s[min].getNum()>s[j].getNum())
{
min=j;
}
}
if(min!=i)
{
SStudent temp=s[i];
s[i]=s[min];
s[min]=temp;
}
}
System.out.println("\n选择排序的结果为:");
System.out.print(Arrays.toString(s));
}
public static void main(String[] args)
{
//调用对象数组的冒泡排序
fun();
//调用对象数组的选择排序
select();
}
}
二叉树排序
package hashMap;
/**
*二插树的排序
*@author 郑云飞
*2010年8月14日
*/
public class BinaryTree
{
private Node root;//根节点
public void add(Comparable<?>data)
{
Node newNode=new Node(data);//实例化节点类
if(this.root==null)//没有根节点
{
this.root=newNode;//第一个节点作为根节点
}
else
{
this.root.addNode(newNode);
}
}
public void print()
{
this.root.printNode();//输出全部的节点
}
class Node
{
private Comparable data;//保存操作的数据内容
private Node leftNode;//左子树
private Node rightNode;//右子树
public Node(Comparable<?> data)
{
this.data=data;
}
public void addNode(Node newNode)
{
if(newNode.data.compareTo(this.data)<0)//放在左子树
{
if(this.leftNode==null)//还没有左子树,可以直接保存在此节点下的左子树
{
this.leftNode=newNode;//保存左子树
}
else
{
this.leftNode.addNode(newNode);//向下继续判断
}
}
if(newNode.data.compareTo(this.data)>0)//放在右子树
{
if(this.rightNode==null)//还没有左子树,可以直接保存在此节点下的右子树
{
this.rightNode=newNode;//保存右子树
}
else
{
this.rightNode.addNode(newNode);//向下继续判断
}
}
}
public void printNode()//采用中序遍历
{
if(this.leftNode!=null)//存在左子树
{
this.leftNode.printNode();//继续找到下面的左子树
}
System.out.println(this.data);//找到根内容
if(this.rightNode!=null)//存在右子树
{
this.rightNode.printNode();//继续找到下面的右子树
}
}
}
public static void main(String[] args)
{
BinaryTree bt=new BinaryTree();
bt.add(3);
bt.add(5);
bt.add(1);
bt.add(0);
bt.add(9);
bt.add(1);
bt.print();
}
}
快速排序
package d;
/**
* 快速排序
* 后比前 ：临<前 交换 e--
* 不交换 s++
* 前比后: 临>后 交换 s++
* 不交换 e--
* 只有插入排序是稳定的
*/
public class Sort_quick
{
public static void main(String[] args)
{
int []a= {5,8,2,7,9,6,4};
quick_sort(a,0,a.length-1);
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
private static void quick_sort(int[] a,int begin,int end)
{
if(begin<end)
{
int spos=begin;
int epos=end;
int temp=a[spos];
boolean turn=false;//交换的标志:turn=flase从前往后比，turn=true从后往前比
while(spos<epos)
{
if(!turn)//从前往后比
{
if(temp>a[epos])
{
swap(a,spos, epos);
spos++;
turn=true;
}
else
{
epos--;
}
}
else //从后往前比
{
if(temp<a[spos])
{
swap(a, spos, epos);
epos--;
turn=false;
}
else
{
spos++;
}
}
}
quick_sort(a, begin, spos-1);
quick_sort(a, spos+1, end);
}
}
private static void swap(int[] a, int spos, int epos)
{
int t=a[spos];
a[spos]=a[epos];
a[epos]=t;
}
}
用容器实现高级排序算法
package hashMap;
import java.util.ArrayList;
import java.util.List;
class MM
{
int age;
String name;
public MM(int age,String name)
{
this.age=age;
this.name=name;
}
public String toString()
{
return "姓名:"+name+"年龄:"+age;
}
}
public class A
{
private static List<MM> al=new ArrayList<MM>();
public static void main(String[] args)
{
al.add(new MM(52,"zhuang zi"));
al.add(new MM(32,"xun zi"));
al.add(new MM(42,"kong zi"));
al.add(new MM(12,"meng zi"));
al.add(new MM(22,"lao zi"));
quick_sort(0,(al.size()-1));
System.out.println(al);
if(binary_sort(52)!=-1)
{
System.out.println("找到元素所在的下标是:"+binary_sort(52));
System.out.println("找到元素的值"+al.get(binary_sort(52)));
}
else
{
System.out.println("没有找到该元素");
}
}
private static void quick_sort(int begin,int end)
{
/*****************对象数组的快速排序*******************/
/**
* 快速排序的规则
* 从前往后比较:前>临 交换:s++
* 不交换 e--
* 从后往前比较 前<临 交换: e--
* 不交换 s++
*/
if(begin<end)
{
int spos=begin;//起始坐标
int epos=end;//结束坐标
MM temp=al.get(spos);
boolean turn=false;//定义转换的标志
while(spos<epos)//前面的坐标小于后面的坐标时 ，一直循环
{
if(!turn)//从前往后比较
{
if(temp.name.compareTo(al.get(epos).name)>0)
{
//交换
swap(spos, epos);
turn=true;
spos++;
}
else
{
epos--;
}
}
else
{
if(temp.name.compareTo(al.get(spos).name)<0)
{
swap(spos, epos);
turn=false;
epos--;
}
else
{
spos++;
}
}
quick_sort(begin,spos-1);
quick_sort(spos+1,end);
}
}
}
private static void swap(int spos, int epos)
{
MM mm=al.get(spos);
al.set(spos, al.get(epos));
al.set(epos, mm);
}
/**********************************折半查找或二分法查找容器中的元素*********************/
private static int binary_sort(int index)
{
int start=0;
int end=al.size()-1;
int temp=(start+end)/2;
while(start<=end)
{
if(index>al.get(temp).age)
{
start=temp+1;
}
if(index<al.get(temp).age)
{
end=temp-1;
}
else
{
return temp;
}
temp=(start+end)/2;
}
return -1;
}
}
分享到：
相关推荐
iOS开发·必会的算法操作：字符串数组排序 模型对象数组排序
这个例子定义了一个int数组，然后使用Array.Sort(arr)静态方法对此数组进行排序，最后输出排序后的数组。以上例子将毫无意外的依次输出1，2，3，4，5，6. 为什么Array的Sort方法可以正确的对int数组进行排序呢，...
数据结构很重要，算法+数据结构+文档=程序使用PHP描述冒泡排序算法，对象可以是一个数组复制代码 代码如下://冒泡排序（数组排序）function bubble_sort($array) {$count = count($array);if ($count <= 0)return...
面向对象实现队列的排序，包括排序的算法，用VC++面向对象实现，继承封装多态的基本用法
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料 杨教授工作室，版权所有，盗版必究， 1/29 页 1 跟我学 Java 面向对象程序设计技术及应用——应用冒泡排序算法实 现数组元素排序的 Java 程序实现示例 1.1 ...
本文实例讲述了JS实现json数组排序操作。分享给大家供大家参考，具体如下： 有时需要根据json对象的某个属性排序json数组，javascript端有sort这个函数，具体可以参考：...
要求：用一个类来描述一个排序算法，类中的sort方法通过调用比较、交换方法来实现数组排序。排序类放入一个特定的包MySort中。 作业详细说明： （1）写一个final参数类M，包括比较次数、交换次数、探测次数属性，...
提供五种排序算法的C++实现方法，输入（待排序元素个数、排序码上界（采用随机生成数组方式）），可选择输出（原始数组、排序后数组、原始数组有序度和无序度、排序过程中数据比较次数与数据移动次数、数组中出现...
arr-sort按一个或多个属性（甚至嵌套属性）对对象数组进行排序。 此外，您甚至可以在每个属性排序中提供比较功能来确定方向。更新1.2.5版本提供了近2倍的更好性能1.2.0版本可以提供近100倍的更好性能！ 通过代码优化...
排序可以分为按单个字段排序和按多个字段不同排序方向排序。单字段排序局限性较大，不能满足用户对数据的关注点变化的需求，而多字段排序就可以较好的弥补这个缺陷。 多字段排序，实现的方式从大的层面上可以分为...
假设有一个对象数组，我们想要根据某个对象属性对数组进行排序。而传递给数组sort()方法的比较函数要接收2个参数，即要比较的值。 可是，我们需要一种方式指明按照哪个属性来排序。 要解决这个问题，可以定义一个...
使用React和Redux设计的常见排序算法的可视化演示。 （使用create-react-app开发构建） 特征 状态由Redux存储管理，并根据需要传递给React组件prop -store利用组合化的reducer来提高模块化和可扩展性，还使用redux-...
本文实例讲述了JS实现json对象数组按对象属性排序操作。分享给大家供大家参考，具体如下： 在实际工作经常会出现这样一个问题：后台返回一个数组中有i个json数据，需要我们根据json中某一项进行数组的排序。 例如...
选择排序，插入排序，希尔排序，堆排序，快速排序，冒泡排序，性能比较。 对于一个随机的数组，可以知道排序所需的比较次数和移动次数。用c++面向对象构建。
要求：用一个类来描述一个排序算法，类中的sort方法通过调用比较、交换方法来实现数组排序。排序类放入一个特定的包MySort中。 作业详细说明： （1）写一个final参数类M，包括比较次数、交换次数、探测次数属性，...
本文实例讲述了JavaScript基于对象方法实现数组去重及排序操作。分享给大家供大家参考，具体如下： [removed] //用对象方法实现数组去重 Array.prototype.unique = function() { var newArr = []; for (var i =...
C 冒泡排序算法的实例源代码，一些排序方法的代码集锦，该函数模板使用冒泡法对集合元素进行排序，参数说明： collection 集合对象，集合对象必须提供 [] 操作。 element 集合元素，该参数的作用仅仅是确定集合...
这些函数仅适用于对象数组（与数据库行相比）。 关键比较具有强制性，因此Date也应该起作用。 对于合并类型的联接，可以提供合并功能以定制输出数组。 默认情况下，所有联接的行都是从LoDash的assign函数生成的： ...
里面有几个很好的javaSe基础题目，比如有javaSe的冒泡排序，求数组的最大值，求数组的最小只，求数组是否对称等等算法实例。
（1）对象数组排序 java没有结构体，所以在算法竞赛中有时候对于有多个属性属于同一个事物，这时候就要创建一个类来存储，而算法竞赛中往往有多个数据，所以要用对象数组来存储。如果要按照某一个属性来对这个对象...