部分排序
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;
}
}
分享到：
相关推荐
二、模型对象数组排序 在实际项目中，我们通常需要对包含自定义模型对象的数组进行排序。假设我们有一个`Person`类，包含`name`属性： ```swift class Person { var name: String // 其他属性和方法... init...
项目中的每个排序算法作为一个独立的类，这种设计遵循了面向对象的原则，便于代码组织和单元测试。 总的来说，理解并掌握这些排序算法有助于提升编程能力，更好地解决实际问题。在处理大量数据时，选择高效且适应...
但请注意，这种方法不适用于Objective-C的对象数组，因为它们涉及到指针的比较，而不是对象的实际内容。 五、性能考虑 数组排序的效率是一个重要的考虑因素。对于大量数据，快速排序或归并排序算法可能更为高效。...
**`Array.Sort()`** 是C#内置的排序函数，它可以对任何实现了`IComparable`接口的对象数组进行排序，或者对包含两个数组元素的元组进行排序。使用`Array.Sort()`方法对数组进行排序非常简洁高效： ```csharp int[] ...
**VB数组排序——冒泡法...总的来说，VB数组排序中的冒泡法是一种直观的教学工具，可以帮助初学者理解和掌握排序算法的基本概念。通过实践和调试代码，可以提升对数据结构和算法的理解，为后续的编程学习打下坚实基础。
三、文本数组排序算法 1. 冒泡排序：是最简单的排序算法之一，通过重复遍历数组，比较相邻元素并交换位置，直到没有任何一对数字需要交换。虽然效率较低，但易于理解。 2. 快速排序：由C.A.R. Hoare提出的高效排序...
在IT行业中，数组排序是基础且重要的编程技能之一，尤其在C++中。数组作为一种基本的数据结构，常常需要进行各种排序操作，以便于数据分析、处理和查找。本篇将深入探讨几种经典排序算法，这些算法不仅理论性强，...
二维数组排序算法则较为复杂，因为二维数组的每个元素本身也是一个数组或对象。在PHP中，可以通过将二维数组中特定的列作为键值进行排序。本文给出的二维数组排序函数array_sort，通过内部的排序函数asort和arsort来...
在本例中，我们首先看到一个简单的整型(int)数组排序示例： ```csharp int[] intArray = new int[]{2,3,6,1,4,5}; Array.Sort(intArray); Array.ForEach(intArray,(i)=>Console.WriteLine(i)); ``` 这段代码定义了...
除了对象数组排序，`Arrays.sort()`还可以处理不同类型的数组。例如： 1. 对于数字数组，可以直接调用`Arrays.sort(intArray)`，它会按升序排列整数。 2. 对于字符串数组，`Arrays.sort(strArray)`会按照字典顺序...
2. 对对象数组排序：对于对象数组，Java 5.0支持自定义比较器。如果对象实现了`Comparable`接口，`Arrays.sort()`会自动使用`compareTo()`方法进行排序。如果没有实现，可以传入一个`Comparator`实例进行定制排序。 ...
然而，理解并实现各种排序算法能帮助我们更好地优化代码性能，应对特定场景的需求。本文将深入探讨一个C#源码实现的排序程序，该程序涵盖了七种常见的排序算法，旨在通过比较次数和移动次数来评估其效率。 1. 冒泡...
在JavaScript编程中，数组排序是一项常见的操作，本文将详细介绍六种常见的排序算法，它们分别是希尔排序、sort排序、桶排序、冒泡排序，以及另外两种未在内容中具体提及的排序算法：快速排序和选择排序。...
数组排序和反转对于数据处理、数据分析和算法实现都非常关键。例如，它们在搜索算法（如二分查找）和数据结构（如堆）中起到基础作用。 总结来说，C#的随机数生成是通过Random类实现的，数组的排序依赖于Array.Sort...
挂号法，或者可以理解为登记法，可能是指一种特定的排序算法，用于处理具有复杂数据结构的数组，比如自定义对象数组。在自定义数据排序中，通常我们需要提供一个比较函数或比较器（Comparator），以便程序知道如何...
总结来说，“易语言挂号法-自定义数据数组排序”涉及到的关键概念包括易语言的基础语法、数组操作、自定义数据类型、比较函数以及优化的排序算法——挂号法。通过掌握这些知识点，开发者可以更高效地处理和排序包含...
在VB6.0编程环境中，数组排序是一项常见的任务，它涉及到对一组数值或对象进行排列，使其按照特定的顺序（如升序或降序）排列。在这个特定的案例中，我们要实现的功能是去除一个数组中非升序的元素，并将剩下的升序...
总的来说，易语言自定义类型数组排序涉及到自定义类型定义、比较函数的实现以及选择合适的排序算法。通过阅读并分析`content.txt`中的源码，我们可以学习如何在易语言环境中有效地处理复杂数据结构的排序问题。
总结来说，这个“17 - 数组排序.rar”文件可能涉及了JavaScript数组排序的各个方面，包括基本用法、自定义比较函数、对象属性排序、稳定性和性能考虑等知识点。通过深入学习和实践这些内容，开发者可以更好地理解和...
本学习笔记主要涵盖了四个关键主题：数组方法、数组排序、数组形状以及对角线操作。以下是对这些知识点的详细阐述。 **一、数组方法** Python中的数组通常通过numpy库实现，numpy提供了强大的ndarray对象。数组...