Java IntStack.add方法代码示例

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksort(double[] array, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partition(array, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortValues(double[] array, long[] index, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionValues(array, index, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortIndex(long[] array, double[] values, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array  so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionIndex(array, values, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksort(long[] array, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partition(array, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksort(byte[] array, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partition(array, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortValues(double[] array, int[] index, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionValues(array, index, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortIndex(int[] array, double[] values, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array  so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionIndex(array, values, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksort(float[] array, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partition(array, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortValues(int[] array, long[] index, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionValues(array, index, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortIndex(long[] array, int[] values, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array  so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionIndex(array, values, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortValues(int[] array, int[] index, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionValues(array, index, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortIndex(int[] array, int[] values, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array  so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionIndex(array, values, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksort(int[] array, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partition(array, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortValues(float[] array, int[] index, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionValues(array, index, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}
 

import edu.jhu.prim.list.IntStack; //导入方法依赖的package包/类
private static void quicksortIndex(int[] array, float[] values, int left, int right, boolean asc) {
    IntStack leftStack = new IntStack();
    IntStack rightStack = new IntStack();
    leftStack.add(left);
    rightStack.add(right);
    while (leftStack.size() > 0) {
        left = leftStack.pop();
        right = rightStack.pop();
        if (left < right) {
            // Choose a pivot index.
            // --> Here we choose the rightmost element which does the least
            // amount of work if the array is already sorted.
            int pivotIndex = right;
            // Partition the array  so that everything less than
            // values[pivotIndex] is on the left of pivotNewIndex and everything
            // greater than or equal is on the right.
            int pivotNewIndex = partitionIndex(array, values, left, right, pivotIndex, asc);
            // "Recurse" on the left side.
            leftStack.push(left);
            rightStack.push(pivotNewIndex - 1);
            // "Recurse" on the right side.
            leftStack.push(pivotNewIndex + 1);
            rightStack.push(right);
        }
    }
}