冒泡排序并行数组

Question

我需要读取和加载一个数据文件到2个数组(1并行)。该数据由一个包含100个整数(ID#)的列表组成，这些整数与双精度(Price)相对应，如下所示:

[ID] - [Price]

196 - 20.47

我需要使用bubbleSort()方法按降序排列ID(及其对应的价格)。最后，我需要使用Binary 和顺序搜索方法来定位我将要显示的特定目标。

My Issue -当我运行这个程序时，我的顺序搜索是成功的，但我的二进制搜索不是。我把我的代码贴在下面，希望有人能来救我。

public class StoreInventory
{
    public int[] storeItem = new int[200];
    public double[] itemPrice = new double[200];
    public int itemCount = 0;
    StoreInventory() {}
    public void loadItems() 
    {       
        try {
            String filename = "MasterStoreInv.dat";
            Scanner infile = new Scanner(new FileInputStream(filename));
            while (infile.hasNext()) {                  
                storeItem[itemCount] = infile.nextInt();
                itemPrice[itemCount] = infile.nextDouble();
                itemCount += 1;             
            }
            infile.close();
        } catch (IOException ex) {
            itemCount = -1;
            ex.printStackTrace();
        }
    }
    public double getItemPrice(int item)
    {
        return itemPrice[item];
    }
    public void bubbleSort() 
    {   
        for (int i = 0; i < itemCount; i++) {
            for (int x = 1; x < itemCount - i; x++) {
                if (storeItem[x - 1] > storeItem[x] && itemPrice[x - 1] > itemPrice[x]) {
                    int temp = storeItem[x - 1];
                    double tempi = itemPrice[x - 1];
                    storeItem[x - 1] = storeItem[x];
                    itemPrice[x - 1] = itemPrice[x];
                    storeItem[x] = temp;
                    itemPrice[x] = tempi;
                } 
            }
        }
    }
    public int binSearch (int target)
    {
     int low = 0;
     int high = itemCount - 1;
     while(high >= low) {
      int mid = (low + high) / 2;
        if(storeItem[mid] == target) {
        return mid;
        }
        if(storeItem[mid] < target) {
          low = mid + 1;
          }
        if(storeItem[mid] > target) {
          high = mid - 1;
          }
       }
         return -1;
    }
    public int seqSearch (int target)
    {
        int ind = 0;
        int found = -1;
        while (ind < itemCount) {
          if(target==storeItem[ind]) {
              found = ind;
              ind = itemCount;
            }else {
              ++ind;
            }
        }
        return found;
    }   
    public static void main(String[] args) 
    {
        StoreInventory inventory = new StoreInventory();
        Scanner myScanner = new Scanner(System.in);
        int target, item;
        double itemPrice;

        inventory.loadItems();      
        inventory.bubbleSort();
        do {
            System.out.println("Which item number do you want to see -->");     
            target = myScanner.nextInt();
        /* Sequential Search */
        item = inventory.seqSearch(target);     
            if (item >= 0) {
                itemPrice = inventory.getItemPrice(item);
                System.out.print("nSequential search - Successful!nID number: " + target + "  Price: $" + itemPrice+ "n");   
            }else {
                System.out.print("nSequential search - FailednID number not foundnn");
            }
        /* Binary Search */
        item = inventory.binSearch(target);     
            if (item >= 0) {
                itemPrice = inventory.getItemPrice(item);
                System.out.print("nBinary search - Successful!nID number: " + target + "  Price: $" + itemPrice+ "nn"); 
            }else {         
                System.out.print("nBinary search - FailednID number not foundnn");
            }
        System.out.print("Enter '1' to make another searchnEnter '0' to quit -->");
        }while (myScanner.nextInt() >= 1);
        myScanner.close();  

    }//END main
}

Answer 1

你的问题在这里:

if (storeItem[x - 1] > storeItem[x] && itemPrice[x - 1] > itemPrice[x])

只有当和价格都更高时，你才会移动物品——这不是一个合适的排序。假设数据如下:

5,10
1,20

这些不会被交换，也不会被交换:

1,20
5,10

你需要选择一个合适的顺序，比如:

storeItem[x - 1] > storeItem[x] || (storeItem[x - 1] == storeItem[x] && itemPrice[x - 1] > itemPrice[x])

这将确保所有条目有严格的顺序。

BTW -您可能希望考虑构建一个class来存储对并使其实现Comparable。