实验八--排序算法

Posted 2020-10-16

实验八 排序算法的实现
一、 实验目的：

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

4. 各种排序算法的结构特点及各算法之间的区别。
   代码如下：
   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);
   }
   }