数据结构(Java)——查找和排序(2)

原创 2015年11月19日 13:27:10

简单就是平凡,平凡即是伟大

1. 排序辅助类

Contact.java

package ds.java.ch09;
/** 
 * @author LbZhang
 * @version 创建时间:2015年11月19日 下午1:27:57 
 * @param <T>
 * @description 实现了Comparable的Contact类
 */
public class Contact implements Comparable<Contact> {

    private String firstName;
    private String lastName;
    private String phone;

    public Contact(){

    }
    public Contact(String firstName, String lastName, String phone) {
        super();
        this.firstName = firstName;
        this.lastName = lastName;
        this.phone = phone;
    }


    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.firstName+","+this.lastName+":"+this.phone;
    }

    @Override
    public int compareTo(Contact o) {

        if(firstName.equals(o.firstName)){
            return lastName.compareTo(o.lastName);
        }else{
            return firstName.compareTo(o.firstName);
        }
    }


    public String getFirstName() {
        return firstName;
    }


    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }


    public String getLastName() {
        return lastName;
    }


    public void setLastName(String lastName) {
        this.lastName = lastName;
    }


    public String getPhone() {
        return phone;
    }


    public void setPhone(String phone) {
        this.phone = phone;
    }
}

SortPhoneList.java

package ds.java.ch09;
/** 
 * @author LbZhang
 * @version 创建时间:2015年11月19日 下午1:37:05 
 * @description 测试主类
 */
public class SortPhoneList {
    public static void main(String[] args) {
        //测试数据添加
        Contact[] friends = new Contact[7];

        friends[0] = new Contact("John", "Smith", "610-555-7384");
        friends[1] = new Contact("Sarah", "Barnes", "215-555-3827");
        friends[2] = new Contact("Mark", "Riley", "733-555-2969");
        friends[3] = new Contact("Laura", "Getz", "663-555-3984");
        friends[4] = new Contact("Larry", "Smith", "464-555-3489");
        friends[5] = new Contact("Frank", "Phelps", "322-555-2284");
        friends[6] = new Contact("Marsha", "Grant", "243-555-2837");

        //SortAlgorithm.insertionSort(friends);
        //SortAlgorithm.selectionSort(friends);
        SortAlgorithm.bubbleSort(friends);
        for (Contact friend : friends)
            System.out.println(friend);
    }

}

2. 直接选择排序

设数组为a[0…n-1]。
1. 初始时,数组全为无序区为a[0..n-1]。令i=0
2. 在无序区a[i…n-1]中选取一个最小的元素,将其与a[i]交换。交换之后a[0…i]就形成了一个有序区。
3. i++并重复第二步直到i==n-1。排序完成。

/**
     * 选择排序: 选择排序算法通过反复地将某一特定值放到它在列表中的最终已排序位置,从而完成某一列表值的排序。 选择排序的策略:
     * 【1】扫描整个列表找到最小值,将这个值与第一个元素交换
     * 【2】扫描除了有序列表之外的部分无序列表找到最小值,然后将它与无序列表第1个位置上的元素交换 
     * 【3】不断重复【2】一直到无序列表只剩一个元素
     * 
     * @param data
     * <T extends Comparable<? super T>> 用于约束T
     * 
     */
    public static <T extends Comparable<? super T>> void selectionSort(T[] data) {
        int min;
        T temp;
        for (int i = 0; i < data.length - 1; i++) {
            min = i;
            // /找出最小的下标
            for (int j = i + 1; j < data.length; j++) {
                if (data[min].compareTo(data[j]) > 0) {
                    min = j;
                }
            }
            // 交换位置
            swap(data, min, i);
        }

    }

3. 直接插入排序

设数组为a[0…n-1]。首先构造有序区域
1. 初始时,a[0]自成1个有序区,无序区为a[1..n-1]。令i=1
2. 将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。
3. i++并重复第二步直到i==n-1。排序完成。

/**
     * 插入排序: 通过反复的将某一特定值插入到该列表的某个已经排序的子集中完成对列表值的排序。 插入排序的策略:
     * 【1】对列表中的开始的两个值依据其相对大小对其进行排序,如果有必要则将它们互换。 
     * 【2】将列表的第三个值插入到已经有序的列表中的恰当位置
     * 【3】然后不断的将无序列表的元素一次取出插入到有序列表的合适位置,继续这一个过程最后实现全部有序。
     * 
     * @param data
     */
    public static <T extends Comparable<? super T>> void insertionSort(T[] data) {

        // 从第一个开始比较
        for (int i = 1; i < data.length; i++) {
            T key = data[i];
            int pos = i;//
            // /有序列表 当前这个元素是否需要前移 如果当前的待插入元素比有序列表pos位置的小
            while (pos > 0 && data[pos - 1].compareTo(key) > 0) {
                data[pos] = data[pos - 1];
                pos--;
            }
            data[pos] = key;
        }

    }

4. 冒泡排序

冒泡排序是非常容易理解和实现,以从小到大排序举例: 设数组长度为N。
1.比较相邻的前后二个数据,如果前面数据大于后面的数据,就将二个数据交换。
2.这样对数组的第0个数据到N-1个数据进行一次遍历后,最大的一个数据就“沉”到数组第N-1个位置。
3.N=N-1,如果N不为0就重复前面二步,否则排序完成。


> 引用块内容

Java
/**
     * 冒泡排序:通过重复的比较相邻元素且在必要时将它们互换,从而完成对某个列表的排序.
     * 【1】扫描该列表且比较邻接元素如果他们不是相对顺序排序排列将其互换。这里就是就是将最大值冒泡到列表最后的位置.
     * @param data
     */
    public static <T extends Comparable<? super T>> void bubbleSort(T[] data){

/**
 *      for(int i=1;i<data.length;i++){
            ///已经有序的部分
            for(int j =0;j<data.length-i;j++){              
                if(data[j].compareTo(data[j+1])>0){
                    swap(data,j,j+1);
                }

            }

        }
 */
        int pos;
        int scan;

        for(pos = data.length-1;pos>=0;pos--){
            for(scan=0;scan<pos;scan++){
                if(data[scan].compareTo(data[scan+1])>0){
                    swap(data,scan,scan+1);
                }
            }
        }

    }

泛型理解
PECS原则:ProducerExtends,ConsumerSuper。
集合用泛型操作时,装入集合用super,从集合取出用extends。又称Get and Set 原则。
辅助方法

/**
     * 交换位置
     * 
     * @param data
     * @param index1
     * @param index2
     */
    private static <T extends Comparable<? super T>> void swap(T[] data, int i,
            int j) {
        T temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
版权声明:本文为博主原创文章,未经博主允许不得转载。

数据结构(Java)——查找和排序(1)

查找是这样一个过程,即在某个项目组中寻找某一指定目标元素,或者确定该组中并不存在该目标元素。 对其进行查找的项目的组有时也成为查找池。 两种常见的查找方式:线性查找和二分查找。 为了能够查找某...
  • zhangyifei521
  • zhangyifei521
  • 2015年11月19日 09:58
  • 576

数据结构与算法--查找与排序(一)

Top 线性查找二分查找冒泡排序插入排序选择排序快速排序归并排序 1 线性查找 1.1 问题 线性查找,又称为顺序查找,是指在所有给定的值中从一端开始逐个检查每个元素是否为要查...
  • opera95
  • opera95
  • 2016年04月22日 08:30
  • 2755

数据结构实验:查找和排序

查找和排序 实验目的   1. 掌握顺序查找,二分法查找,分块查找的算法。   2.掌握各种排序算法及其性能的比较 二、实验内容 1.编写一个程序输出在顺序表{13,22,35,43,54,...
  • u012278856
  • u012278856
  • 2014年06月03日 22:12
  • 649

排序二叉树、查找、二分法查找、数据结构,实验报告

#include #include #include #include #include using namespace std; typedef int ElemType ; typed...
  • u011042188
  • u011042188
  • 2013年12月11日 22:45
  • 1360

Java数据结构 遍历 排序 查找 算法实现

1. 遍历算法(遍历二叉树6种方法) 排序算法 查找算法
  • zhanghao_Hulk
  • zhanghao_Hulk
  • 2014年06月27日 23:43
  • 4474

数据结构中排序和查找各种时间复杂度

(1)冒泡排序         冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排...
  • wangwenwen
  • wangwenwen
  • 2013年09月28日 23:26
  • 5720

《常见算法和数据结构》元素排序(1)——简单排序(附动画)

元素排序(1)——简单排序 本系列文章主要介绍常用的算法和数据结构的知识,记录的是《Algorithms I/II》课程的内容,采用的是“算法(第4版)”这本红宝书作为学习教材,通过这系列文章,可...
  • hk2291976
  • hk2291976
  • 2016年04月06日 21:58
  • 822

Java实现动态表查找--二叉排序树

定义 二叉排序树或者是一棵空树,或者是具有下列性质的二叉树:  (1)若左子树不空,则左子树上所有结点的键值均小于或等于它的根结点的键值;  (2)若右子树不空,则右子树上所有结点的键值均大于或等于它...
  • u011514810
  • u011514810
  • 2017年03月04日 15:01
  • 357

数据结构——排序查找算法实现

前面转载了一篇讲排序算法的文章,这几天将排序和查找算法进行了实现,在这里贴出代码来。...
  • u010757264
  • u010757264
  • 2016年08月18日 16:13
  • 432

数据结构基础 查找 之 二分查找

二分查找又称折半查找,对排好序的数组,每次取这个数和数组中间的数进行比较,复杂度是O(logn)。本文在阐述二分查找算法思想的基础上给出递归、非递归以及STL三种方式的源码实现,现详述如下。...
  • u013630349
  • u013630349
  • 2015年07月28日 10:51
  • 1889
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:数据结构(Java)——查找和排序(2)
举报原因:
原因补充:

(最多只允许输入30个字)