Question

哪个堆栈和队列实现会更快，更优化，为什么？基于数组（动态或静态）还是列表？

例如，我有以下几种方式：

基于动态数组：

const screen2Config = {
  duration: 300,
  easing: Easing.out(Easing.poly(4)),
  timing: Animated.timing,
};

export const ScreenStack = createStackNavigator({
  Screen1: {
    screen: Screen1,
    navigationOptions: ({ navigation }) => ({
      headerTitle: 'Screen1',
      headerTitleAllowFontScaling: false,
    }),
  },
  Screen2: {
    screen: Screen2,
    navigationOptions: ({ navigation }) => ({
      headerTitle: 'Screen2',
      headerTitleAllowFontScaling: false,
      tabBarVisible: false,
    }),
  },
  Screen3: {
    screen: Screen3,
    navigationOptions: ({ navigation }) => ({
      headerTitle: 'Screen3',
      headerTitleAllowFontScaling: false,
    }),
  },
  Screen4: {
    screen: Screen4,
    navigationOptions: ({ navigation }) => ({
      headerTitle: 'Screen4',
      headerTitleAllowFontScaling: false,
    }),
  },
}, {
  headerMode: 'float',
  mode: 'modal',
  transitionConfig: sceneProps => ({
    transitionSpec: sceneProps.scene.route.routeName === 'Screen2' ? screen2Config : {},
    screenInterpolator: (sceneProps) => {
      if (sceneProps.scene.route.routeName === 'Screen2') {
        const { layout, position, scene } = sceneProps;
        const { index } = scene;

        const width = layout.initWidth;
        const translateX = position.interpolate({
          inputRange: [index - 1, index, index + 1],
          outputRange: [width, 0, 0],
        });

        const opacity = position.interpolate({
          inputRange: [index - 1, index - 0.99, index],
          outputRange: [0, 1, 1],
        });

        return { opacity, transform: [{ translateX }] };
      }
    },
  }),
});

基于列表：

typedef struct Stack {
    char* values;
    int avl_el;
    int now_el;
    int top;
}Stack;

void push(Stack* stack, char data) {
    if (stack->now_el >= stack->avl_el) {
        stack->avl_el += INCR;
        stack->values = (char*)malloc(stack->avl_el * sizeof(char));
    }
    if (stack->top == -1) {
        stack->top++;
        stack->values[stack->top] = data;
        stack->now_el++;
    }else {
        stack->top++;
        stack->values[stack->top] = data;
        stack->now_el++;
    }
}

char pop(Stack* stack) {
    char tmp = stack->values[stack->top];
    stack->values[stack->top] = 0;
    stack->top--;
    stack->now_el--;
    return tmp;
}

基于动态的堆栈和基于静态数组的堆栈会有所不同吗？

Answer 1

假设您修复了错误，让我们讨论原理。最大的性能错误是使用INC常量增加大小。使用此错误，插入n个元素的复杂度为O（n ²）。为了获得更好的复杂度，请以2或1.5的倍数重新分配，修复后，插入n个元素的复杂度将变为O（n），或者对于单次插入将摊销O（1）。

这两种方法已经用C ++进行了广泛的测试：什么是更快的std:: vector（类似于您的堆栈）或std::list（一个双向链接列表）。这是资源列表：

Bjarne Stroustrup，c ++的创建者，比较了列表和向量。
stack overflow: Relative performance of std::vector vs. std::list vs. std::slist?

列表更易于实现，并且具有更好的可预测性（不调整大小），但是向量在堆栈场景中的平均速度更快，并且内存效率更高。

向量（问题中的堆栈）：

大小：无需存储指向下一个元素的指针。这样更有效。

速度：连续的元素彼此靠近，从而提高了内存可预测性，并提高了缓存效率。

列表：

大小：无需找到一个大的内存块（在碎片内存中效果更好）。

速度：可预测-无需偶尔复制大块内存。

在c中实现列表和队列的最快方法是什么？

1 个答案: