【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]);
        }