Java数据结构与算法之数组（二）

import java.util.Scanner;

//如下数组未考虑值重复
class HighArrayClass
{
    /*  
    定义一个私有成员变量
    该变量类型为int 类型 
    */
    private int[] array;

    /* 
    定义一个数据记录指针
    用于记录该数组中的元素个数
    起名数组记录指针
     */
    private int index;

    //定义一个无参构造方法
    public HighArrayClass(){}

    /* 
    定义一个有参构造方法
    用于初始化数组的长度
    同时初始化数组记录指针为0
    */
    public HighArrayClass(int maxSize)
    {
        array = new int[maxSize];
        index = 0;
    }

    /*
    定义一个插入元素方法
    用于插入元素到数组中
    由于是无序数组
    故只需在最后添加一个数据即可
    */
    public void insertElemets(int value)
    {
        array[index] = value;
        index++;
    }

    /*
    定义一个显示数组的方法
    用于将数组中的元素显示出来
    */
    public void displayElements()
    {
        for(int i = 0;i<index;i++)
        {
            System.out.print(""+array[i]+'\t');
        }
        System.out.println();
    }

    /*
    定义一个查找元素的方法
    用于查找数组中某个元素的位置
    */
    public void findElements(int value)
    {
        int posTemp;
        for(posTemp = 0;posTemp<index;posTemp++)
            if(array[posTemp] == value)
                break;

        if(posTemp == index)
        {
            System.out.println("我不能找到你想要的"+value);
        }
        else
        {
            System.out.println("你想要的数"+value);
            System.out.println("它在数组第"+(posTemp+1)+"个位置上！");
        }
    }

    /*
    定义一个删除数组元素的方法
    用于删除数组中的某个元素
    */
    public void deleteElements(int value)
    {
        int posTemp;
        for(posTemp = 0;posTemp<index;posTemp++)
            if(array[posTemp] == value)
                break;

        if(posTemp == index)
        {
            System.out.println("你想要的数"+value);
            System.out.println("它不在数组中，故无法删除该数据！");
        }
        else
        {
            for(int k=posTemp;k<index-1;k++)
            {
                array[k]=array[k+1];
            }
            index--;

            System.out.println("已经删除了该数据");
        }
    }

    /*
    定义一个获取最大值的方法
    用于获取该数组中最大的值
    */
    public int getMax()
    {
        if(index == 0)
        {
            return -1;
        }

        int max = 0;
        for(int i = 1;i<index;i++)
        {
            if(array[max]<array[i])
                //array[max]=array[i];
                /*
                上述的错误是将最大值放到第一个位置上了。
                直接更改角标对应的元素值。
                */
                max = i;
        }

        return array[max];
    }

    /*
    定义一个删除最大值的方法
    用于删除该数组中最大的值
    */
    public void removeMax()
    {
        int valueMax = getMax();

        //System.out.println("[removeMax]现在该数组的最大值是："+valueMax);
        //System.out.println("[removeMax]现在数组的长度是："+index);
        //System.out.println("[removeMax]现在数组中的元素如下：");
        //displayElements();

        int posTemp;

        for(posTemp = 0;posTemp<index;posTemp++)
        {
            //System.out.println("[removeMax]array["+posTemp+"]="+array[posTemp]);

            if(array[posTemp] == valueMax)
            {
                //System.out.println("[removeMax]获取到最大值的位置了！");
                break;
            }
            //System.out.println("[removeMax]正在找寻最大值的位置。。。。");
        }

        //System.out.println("[removeMax]最大值的位置是："+(posTemp+1));

        for(int k=posTemp;k<index-1;k++)
        {
            array[k]=array[k+1];
        }
        index--;
    }

    /*
    定义一个删除重复数据的方法
    用于删除该数据中重复的数据
    */
    public boolean noDup()
    {
        int countSame = 0;
        boolean dupFlag = false;

        for(int i = 0;i<index-1;i++)
        {
            if(array[i] == -1)
                continue;

            for(int j = i+1;j<index;j++)
            {
                if(array[i]==array[j])
                {
                    array[j]=-1;
                    countSame++;
                    dupFlag = true;
                }
            }
        }

        //System.out.println("[noDup]经过处理后的数据如下：");
        //displayElements();
        //System.out.println("[noDup]-1的个数为"+countSame);

        while( countSame != 0 )
        {
            int posTemp;
            for(posTemp = 0;posTemp<index;posTemp++)
                if(array[posTemp] == -1)
                    break;

            for(int k=posTemp;k<index-1;k++)
            {
                array[k]=array[k+1];
            }
            index--;
            countSame--;
        }

        return dupFlag;
    }
}

public class HighArrayClassApp
{
    public static void main(String[] args)
    {

        Scanner sc_maxSize = new Scanner(System.in);
        System.out.println("你希望数组的长度有多长？");
        int maxSize = sc_maxSize.nextInt();

        HighArrayClass hac = new HighArrayClass(maxSize);

        System.out.println("我们已经得到一个长度为"+maxSize+"的数组");

        System.out.println("现在该数组的最大值是："+hac.getMax());

        System.out.println("现在我们需要填充它。");
        System.out.println("这里使用1到100的随机数来填充它");

        for(int i = 0;i<maxSize;i++)
        {
            int tempInt = (int)(Math.random()*100+1);
            hac.insertElemets(tempInt);
        }

        System.out.println("填充好的数组如下");
        hac.displayElements();

        System.out.println("你想找寻哪个数字？");
        Scanner sc_find = new Scanner(System.in);
        int goalNum = sc_find.nextInt();

        System.out.println("正在尝试搜索。。。。");
        System.out.println("搜索结果如下：");
        hac.findElements(goalNum);

        System.out.println("你想删除哪个数字？");
        Scanner sc_delete = new Scanner(System.in);
        int deleteNum = sc_delete.nextInt();

        System.out.println("正在尝试删除。。。。");
        System.out.println("删除结果如下：");
        hac.deleteElements(deleteNum);

        System.out.println("删除后的数组如下：");
        hac.displayElements();

        //if((int tempMax = hac.getMax()) != -1)//java不支持这种表达方法
        System.out.println("现在该数组的最大值是："+hac.getMax());

        System.out.println("现在正在删除最大值。。。。。");
        hac.removeMax();
        System.out.println("已经删除了最大值");

        System.out.println("删除后的数组如下：");
        hac.displayElements();

        System.out.println("现在要对数组进行排序：");
        HighArrayClass hacOrder = new HighArrayClass(maxSize);

        for(int i = 0;i<maxSize;i++)
        {
            int tempMax = hac.getMax();
            if(tempMax ==  -1)
                break;
            hacOrder.insertElemets(tempMax);
            hac.removeMax();
        }
        System.out.println("排序后的数组为：");
        hacOrder.displayElements();

        System.out.println("该数组中是否有相同的元素？");
        if(hacOrder.noDup())
            System.out.println("数组中有相同元素。");
        else
            System.out.println("数组中没有相同元素。");

        System.out.println("经过处理后的数组如下：");
        hacOrder.displayElements();

        System.out.println("-------------------------------");

        System.out.println("插入一些新的数据用于测试：");
        HighArrayClass hac_noDup = new HighArrayClass(10);
        hac_noDup.insertElemets(12);
        hac_noDup.insertElemets(56);
        hac_noDup.insertElemets(12);
        hac_noDup.insertElemets(2);
        hac_noDup.insertElemets(17);
        hac_noDup.insertElemets(12);
        hac_noDup.insertElemets(4);
        hac_noDup.insertElemets(17);
        hac_noDup.insertElemets(6);
        hac_noDup.insertElemets(12);

        System.out.println("插入后数组的数据为：");
        hac_noDup.displayElements();

        System.out.println("该数组中是否有相同的元素？");
        if(hac_noDup.noDup())
            System.out.println("数组中有相同元素。");
        else
            System.out.println("数组中没有相同元素。");

        System.out.println("经过处理后的数组如下：");
        hac_noDup.displayElements();
    }
}