实验八--排序算法

实验八 排序算法的实现
一、 实验目的：
1. 熟练掌握常用的直接插入排序、简单选择排序、冒泡排序等算法。
2. 深入理解各种查找排序的结构特点及各算法之间的区别。
二、 实验内容：
1. 采用直接插入排序、简单选择排序、冒泡排序等常用的排序算法实现给数据的排序。
2. 各种排序算法的结构特点及各算法之间的区别。
代码如下：
RecordNode.java

package sort;
import java.util.Scanner;

public class RecordNode
{
    public int key  ;  // 关键字
    public String element;   // 记录的其它部分 

    Scanner sin = new Scanner(System.in);
    public RecordNode()
    {
        System.out.println("请输入关键字：");
        this.key=sin.nextInt();
        System.out.println("请输入元素值：");
        this.element=sin.next();        
    }

    public RecordNode(int key)
    {
        this.key =key;
    }

    public RecordNode(int key , String element)
    {
        this.element = element;
        this.key =key;
    }

    public String toString()
    {
        return this.key+" "+this.element+" ";
    }
}

SeqList_Sort.java（主要填写算法部分）

/* 
 *构造用于排序的线性表，
 *元素位置从下标1开始
 *分别设置各种不同的排序算法*/
package sort;
import java.util.Scanner;
import java.util.Random;

public class SeqList_Sort  
{
    public RecordNode [ ] r;
    public int curlen;

    public SeqList_Sort(int maxSize) //构造方法，用参数做为线性表的初始空间大小
    {
        this.curlen=0;
        this.r = new RecordNode[maxSize];
    }

    public SeqList_Sort()  //构造方法，以默认100做为初始空间大小
    {
        this(100);
    }

    public void create(int n)  // 输入生成线性表，参数为输入元素个数
    {
        Scanner sin =new Scanner(System.in);
        System.out.println("\t输入"+n+"个线性表的元素：");
        for(int i=1;i<=n;i++)
        {
            try {
                        RecordNode newdata=new   RecordNode  ();
                        this.insert(i,newdata);             
                  }
            catch(Exception e)
            {
                System.out.println("\t插入位置不合适，无法创建");
            }
        }
    }

    public void create( )// 随机数生成10个元素
    {           
        Scanner sc = new Scanner(System.in);
        System.out.print("\t输入元素个数：  ");
        int  n = sc.nextInt();
        for(int i=1;i<=n ;i++)
        {
            try {
                Random rd = new Random();
                RecordNode newdata = new RecordNode(rd.nextInt(100)," ");
                this.insert(i,newdata);             
                }
            catch(Exception e)
            {
                System.out.println("\t插入位置不合适，无法创建");
            }
        }
    }

    public void clear()//清空
    {
        this.curlen=0;
    }

    public boolean isEmpty() //判断是否为空
    {
        if ( this.curlen ==0 )
            return true;
        else
            return false;
    }

    public int length() //求长度
    {
        return this.curlen;
    }

    public RecordNode get(int i) throws Exception //求指定位置元素
    {
        if ( i < this.curlen)
           return  this.r[i];
        else
        {
            throw new Exception("elem no."+i+" not exist!");
        }
    }

    public void insert(int i,RecordNode x)throws Exception //在指定的位置上插入数据元素
    {
        if (this.curlen == this.r.length)
        {
        //  throw new Exception("overflow!");
            RecordNode newlist[]=new RecordNode[2*this.curlen];
            for(int j=this.curlen;j>0;j--)
            {
                newlist[j]=this.r[j];
            }
            this.r=newlist;         
        }
        if (i<1|| i>this.curlen+1)
            throw new Exception("position  error!");        
        for(int j =this.curlen ; j >=i ; j-- )
        {
            this.r[ j+1] =this.r[j] ;
        }
        this.r[i]= x;
        this.curlen++;      
    }   

    public void remove(int i) //删除指定位置上的元素
    {
        for (int  j = i+1 ; j<= this.curlen ; j++)
        {
            this.r[j-1]=this.r[j];
        }
        this.curlen--;
    }   

    public int indexOf(RecordNode x)//查找指定元素的位置
    {
         int i;
         for( i=this.curlen; i>0 ; i--)
         {
            if (this.r[i].equals(x))
                     break; 
         }
         return i;        
    }

    public void display() //输出线性表的所有元素值
    {
         System.out.println("\n\t线性表的元素是");
         for (int i = 1; i <= curlen ;i++)
           {
                System.out.print("\t"+this.r[i] );
                if (i %10==0)
                    System.out.println(); 
           }
        System.out.println();
    } 

    //---------------------Sort---------------------------
    //------------------insertSort-----------------------
    public void insertSort() // 插入排序
    {
        RecordNode temp;
        int i,j;
        for(i = 1;i <= this.curlen; i++)
        {
            temp = r[i];
            for(j = i-1;j>=0&&Integer.valueOf(temp.key).compareTo(r[j].key)<0;j--)
            {
                r[j+1]= r[j];
            }
            r[j+1]=temp;
        }
    }

    //----------------带岗哨的插入排序-------------
    public void insertSortWithGuard() // 带岗哨的插入排序
    {
       int i,j;
       for(i = 1;i<=this.curlen;i++)
       {
        r[0] =r[i];
        for(j = i-1;Integer.valueOf(r[0].key).compareTo(r[j].key)<0;j--)
        {
            r[j+1]=r[j];
        }
        r[j+1] = r[0];
       }
    }   

    //----------------选择排序------------- 
    public void  selectSort()  //选择排序
    {
        RecordNode temp;
        for(int i = 0 ; i <= this.curlen ;i++)
        {
            int min = i;
            for(int j = i+1;j<=this.curlen;j++)
            {
                if(Integer.valueOf(r[j].key).compareTo(r[min].key)<0)
                {
                    min = j;
                }
            }
            if(min!=i)
            {
                temp = r[i];
                r[i] = r[min];
                r[min]=temp;
            }
        }   
    }

    //----------------冒泡排序------------- 
    public void bubbleSort() //冒泡排序
    {
        RecordNode temp;
        boolean flag = true;
        for(int i = 1;i<= this.curlen&&flag;i++)
        {
            flag = false;
            for(int j = 0;j<=this.curlen-i;j++)
            {
                if(Integer.valueOf(r[j].key).compareTo(r[j+1].key)>0)
                {
                    temp = r[j];
                    r[j]=r[j+1];
                    r[j+1]= temp;
                    flag = true;
                }
            }
        }
    }

    //----------------快速排序------------- 
    private int Partition(int i,int j) // 在区间[i,j]上进行元素的划分，以i位置上的元素为支点记录
    {
        RecordNode pivot = r[i];
        while(i<j)
        {
            while(i<j&&Integer.valueOf(pivot.key).compareTo(r[j].key)<=0)
            {
                j--;
            }
            if(i<j)
            {
                r[i]=r[j];
                i++;
            }
            while(i<j&&Integer.valueOf(pivot.key).compareTo(r[i].key)>0)
            {
                i++;
            }
            if(i<j)
            {
                r[j] = r[i];
                j--;
            }
        }
        r[i]=pivot;
        return i;
    }

    private void qSort(int low,int high)  //从low到high进行递归的快速排序
    {
        if(low < high)
        {
            int p = Partition(low,high);
            qSort(low,p-1);
            qSort(p+1,high);
        }
    }

    public void quickSort() // 快速排序
    {
        qSort(1,this.curlen);
    }

    //----------------堆排序-------------  
    public void heapSort() // 堆排序
    {
        int n=this.curlen;
        for(int i=n/2; i>=1; i--) // 建堆
        {
                sift(i,n);
        }

        for(int i=n;  i>=2; i--) // 利用堆排序
        {
                //交换r[1]和r[i]，即得到最大值r[i]
               RecordNode temp = this.r[1];
                this.r[1] = this.r[i];
                this.r[i] = temp;           
                sift(1,i);  
        }   
    }

    private void sift(int low,int high) // 以low为根的子树调整成大根堆
    {
        if (low <high)
        {
            int i=low;
            int j=2*i ;
            this.r[0] = this.r[i];
            while( j  <  high)
            {
                    if (j<high-1 && this.r[j].key < this.r[j+1].key) // i有右孩子，并且右孩子大于左孩子,j将表示右孩子
                            j++;
                    if (this.r[0].key < this.r[j].key)
                    {
                            this.r[i] = this.r[j];
                            i=j;
                            j=2*i;
                    }
                    else
                            j=high +1; // 可以退出调整过程              
            }
            this.r[i]=this.r[0];        
        }   
    }   
}

Sort_Test.java

import sort.SeqList_Sort;
import java.util.Scanner;

public class Sort_Test
{
    private static int total;  //排序次数

    private static void showMenu()
    {
        System.out.println("    ---------Menu--------");
        System.out.println("    1  insertSort");
        System.out.println("    2  insertSortWithGuard ");
        System.out.println("    3  bubbleSort ");
        System.out.println("    4  quickSort ");
        System.out.println("    5  selectSort ");
        System.out.println("    6  heapSort ");
        System.out.println("    0  Quit  ");
        System.out.println("    ---------end----------");
    }

    public static void main(String [] args)
    {
        Scanner sin = new Scanner(System.in);       
        SeqList_Sort  test = new SeqList_Sort ();               
        do
        {

            showMenu();
            System.out.print("  请选择排序算法：");
            int choice = sin.nextInt();
            total++;

            if (choice == 0 )
                        System.exit(0);

            System.out.println("    初始数据：");
            test.create();      
            test.display();

            if (choice >=1 && choice <=6)
            {
                String sortName = null;
                        switch(choice)
                        {
                                case 1: test.insertSort(); sortName = "插入排序" ; break;
                                case 2: test.insertSortWithGuard();  sortName = "带岗哨的插入排序" ; break;
                                case 3: test.bubbleSort();  sortName = "冒泡排序";break;
                                case 4: test.quickSort();  sortName = "快速排序" ;break;
                                case 5: test.selectSort(); sortName = "选择排序" ; break;
                                case 6: test.heapSort();  sortName = "堆排序" ;break;          
                        }
                       System.out.println("**第  "+total+"  次选择，"+sortName+"结果是：");
                       test.display();
              }
              else
                       System.out.println("error,end");

            System.out.println("_______请继续选择_________");

            test.clear();  //清除上次数据
        }while(true);
    }
}