【Java】Java复习笔记－三大排序算法，堆栈队列，生成无重复的随机数列

冒泡排序

 package com.lcw.bubble;

 public class BubbleSort
 {
     /**
      * 冒泡排序
      * @param args
      * @author 成鹏致远
      */

     public static int[] bubleSort(int[] before)
     {
         int temp;
         for (int i = 0; i < before.length; i++)
         {
             for (int j = 0; j < before.length-i-1; j++)//依次进行排序
             {
                 if (before[j] > before[j+1])
                 {
                     temp = before[j+1];
                     before[j+1] = before[j];
                     before[j] = temp;
                 }
             }
         }
         return before;
     }

 }

选择排序

 package com.lcw.select;
 /**
  *@author 成鹏致远
  *@net http://infodown.tap.cn
  */
 public class SelectionSort
 {
     public static  void selectionSort(int[] number)
     {
         for(int i=0; i<number.length-1; i++)
         {
             int m =i;//每次确定一个最小数
             for (int j=i+1; j<number.length; j++)
             {
                 if(number[j] <number[m])
                 {
                     m =j;
                 }
             }
             if (i != m)
             {
                 swap(number,i,m);
             }
         }
     }

     private static void swap(int[] number, int i, int j)//用于交换数组中的索引为i，j的数
     {
         int t;
         t = number[i];
         number[i] = number[j];
         number[j] = t;
     }
 }

快速排序

 package com.lcw.quick;

 /**
  * @author 成鹏致远
  * @net http://infodown.tap.cn
  */
 public class Quick
 {
     //排序方法，接受一个int[]参数，将会调用快速排序方法进行排序
     public static void sort(int[] number)
     {
         quickSort(number, 0, number.length-1);
     }

     public static void quickSort(int[] number, int left, int right)
     {
         if (left < right)
         {
             int s = number[left];//基准元素
             int i = left;
             int j = right+1;
             while (true)
             {
                 //向右找大于s的数的索引
                 while(i+1 < number.length && number[++i] < s);
                 //向左找小于s的数的索引
                 while(j-1 > -1 && number[--j] > s);
                 //如果i>=j;退出循环
                 if (i >= j)
                 {
                     break;
                 }
                 //否则交换索引i 和j 的元素
                 swap(number,i,j);
             }
             //此时 number[left]为基准元素
             //      number[(left+1)~i]<number[left]
             //      number[(j+1)~right]>number[left]
             //      number[j]存放最小数(j从右往左，比较完所有的数)
             number[left] = number[j];//最小数放在数组的最前面
             number[j] = s;//s为基准元素，遍历一遍后，从j位置分为两个无序数组继续递归排序

             //对左边进行递归
             quickSort(number, left, j-1);
             //对右边进行递归
             quickSort(number, j+1, right);
         }
     }

     private static void swap(int[] number, int i, int j)//用于交换数组中的索引为i，j的数
     {
         int t;
         t = number[i];
         number[i] = number[j];
         number[j] = t;
     }
 }

三大排序算法测试代码

 package com.lcw.test;

 import java.util.Arrays;

 import com.lcw.bubble.BubbleSort;
 import com.lcw.quick.Quick;
 import com.lcw.select.SelectionSort;
 import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader.Array;

 public class Test
 {
     public static void main(String[] args)
     {
         int test[] = {4,3,5,9,1};    //数组的静态初始化

 //        BubbleSort.bubleSort(test);    //冒泡排序
 //        Arrays.sort(test);    //利用Arrays类的静态方法对数组进行排序
 //        SelectionSort.selectionSort(test);//选择排序
         Quick.sort(test);//快速排序

         System.out.println("排序后：");
         for (int i=0; i<test.length; i++)
         {
             System.out.println(test[i]);
         }
     }

 }

队列

 package com.lcw.queue;

 public class Queue
 {
     /**
      * 队列
      * @param args
      * @author 成鹏致远
      * @net http://infodown.tap.cn
      */

     private int front = -1, rear = -1;//队头和队尾
     private String[] queue;//定义一个数组模拟队列

     public Queue(int maxElements)//构造器，参数为队列长度
     {
         queue = new String[maxElements];
     }

     public void enqueue(String s)//入列
     {
         queue[++rear] = s;
     }

     public boolean isEmpty()//判断是否为空
     {
         return front == rear;
     }

     public boolean isFull()//判断是否已满
     {
         return rear== queue.length - 1;
     }

     public String dequeue()//出列
     {
         return queue[++front];
     }
 }

队列测试代码

 package com.lcw.test;

 import com.lcw.queue.Queue;

 public class Test
 {
     public static void main(String[] args)
     {
         Queue queue = new Queue(10);

         queue.enqueue("1->lcw");
         queue.enqueue("2->mystery");

         System.out.println("队列中第一个元素："+queue.dequeue());
         System.out.println("队列中第二个元素："+queue.dequeue());

         if (queue.isEmpty())
         {
             System.out.println("队列已空！");
         }
     }

 }

栈

 package com.lcw.stack;

 public class Stack
 {
     /**
      * 栈
      * @param args
      * @author 成鹏致远
      * @net http://infodown.tap.cn
      */

     private int capacity = 100;
     private String[] items;
     private int top = 0;

     public Stack()//不带参构造器
     {
         this(100);
     }

     public Stack(int cap)//带参数构造器
     {
         this.capacity = cap;
         items = new String[cap];
     }

     public void push(String s)//入栈
     {
         top++;
         items[top] = s;
     }

     public void pop()//出栈
     {
         items[top] = null;
         top--;
     }

     public void empty()//清空堆栈
     {
         top = 0;
     }

     public String top()//取出最顶端的堆栈元素
     {
         return items[top];
     }

     public int size()//获取堆栈元素个数
     {
         return top;
     }
 }

栈测试代码

 package com.lcw.test;

 import com.lcw.stack.Stack;

 public class Test
 {
     public static void main(String[] argv)
     {
         Stack myStack = new Stack(5);

         myStack.push("lcw");
         myStack.push("mystery");

         System.out.println("堆栈中元素个数："+myStack.size());
         System.out.println("最上面的是："+myStack.top());

         myStack.pop();
         System.out.println("POP后->堆栈中元素个数："+myStack.size());
         System.out.println("POP后->最上面的是："+myStack.top());
     }
 }

生成不重复的随机数队列

     /**
      * 生成不重复的随机数
      * @param args
      * @author 成鹏致远
      * @net http://infodown.tap.cn
      */

         Random random = new Random(System.currentTimeMillis());
         //利用Random（当前时间）生成随机数

         StudentInfo info = new StudentInfo();    

         System.out.print("请输入需要输出的学生信息个数：");
         Scanner sc = new Scanner(System.in);
         int num = sc.nextInt();    //得到需要输出学生信息的个数

         int record[] = new int[num];
         int intRd = 0;//存放随机数
         int count = 0;//记录生成的随机数个数
         boolean IsRecord = false;//是否已经生成过标志
 //        System.out.println("数组的长度是："+record.length);

         while (count < num)//生成指定范围内无重复的随机数
         {
             intRd = Math.abs(random.nextInt()%30);
             //将随机数限制为30以下的非负数
             for (int i = 0; i < count; i++)
             {
                 if(record[i] == intRd)
                 {
                     IsRecord = true;
                     break;
                 }
                 else
                 {
                     IsRecord = false;
                 }
             }
             if(!IsRecord)
             {
                 record[count++] = intRd;
             }
         }

         for(int a=0; a<num; a++)
         {
             info.getStudentInfo(record[a]);
         }