Question

它是一个python代码..使用链表实现....这样有效...........

data = []            # data storage for stacks represented as linked lists
stack = [-1, -1, -1] # pointers to each of three stacks (-1 is the "null" pointer)
free = -1            # pointer to list of free stack nodes to be reused

def allocate(value):
    ''' allocate a new node and return a pointer to it '''
    global free
    global data
    if free == -1:
        # free list is empty, need to expand data list
        data += [value,-1]
        return len(data)-2
    else:
        # pop a node off the free list and reuse it
        temp = free
        free = data[temp+1]
        data[temp] = value
        data[temp+1] = -1
        return temp

def release(ptr):
    ''' put node on the free list '''
    global free
    temp = free
    free = ptr
    data[free+1] = temp

def push(n, value):
    ''' push value onto stack n '''
    global free
    global data
    temp = stack[n]
    stack[n] = allocate(value)
    data[stack[n]+1] = temp

def pop(n):
    ''' pop a value off of stack n '''
    value = data[stack[n]]
    temp = stack[n]
    stack[n] = data[stack[n]+1]
    release(temp)
    return value

def list(ptr):
    ''' list contents of a stack '''
    while ptr != -1:
        print data[ptr],
        ptr = data[ptr+1]
    print

def list_all():
    ''' list contents of all the stacks and the free list '''
    print stack,free,data
    for i in range(3):
        print i,":",
        list(stack[i])
    print "free:",
    list(free)

push(0,"hello")
push(1,"foo")
push(0,"goodbye")
push(1,"bar")
list_all()
pop(0)
pop(0)
push(2,"abc")
list_all()
pop(1)
pop(2)
pop(1)
list_all()

有没有办法有效地做到这一点除了这个？在c / c ++中用这种方式实现会有效吗???

Answer 1

在python中，列表是一个堆栈：

>>> l = [1, 2, 3, 4, 5]
>>> l.pop()
5
>>> l.pop()
4
>>> l.append(9)
>>> l
[1, 2, 3, 9]
>>> l.pop()
9
>>> l.pop()
3
>>> l.append(12)
>>> l
[1, 2, 12]

虽然在python中实现一个c风格的链表可能是一个有趣的练习，但这是不必要的，而且可能非常慢。只需使用列表即可。

Answer 2

更好的解决方案可能是使用list而不是stack来实现链表。给出的代码是链表的堆栈实现，我认为这是python的一个标准，但在C / C ++中你可以使用list来实现高效的实现。

C中的示例代码如下： -

#include <stdio.h>
#include <stdlib.h>

struct node{
    int data;
    struct node *next;
};

struct node* add(struct node *head, int data){
    struct node *tmp;

    if(head == NULL){
        head=(struct node *)malloc(sizeof(struct node));
        if(head == NULL){
            printf("Error! memory is not available\n");
            exit(0);
        }
        head-> data = data;
        head-> next = head;
    }else{
        tmp = head;

        while (tmp-> next != head)
            tmp = tmp-> next;
        tmp-> next = (struct node *)malloc(sizeof(struct node));
        if(tmp -> next == NULL)
        {
            printf("Error! memory is not available\n");
            exit(0);
        }
        tmp = tmp-> next;
        tmp-> data = data;
        tmp-> next = head;
    }
    return head;
}

void printlist(struct node *head)
{
    struct node *current;
    current = head;
    if(current!= NULL)
    {
        do
        {
            printf("%d\t",current->data);
            current = current->next;
        } while (current!= head);
        printf("\n");
    }
    else
        printf("The list is empty\n");

}

void destroy(struct node *head)
{
    struct node *current, *tmp;

    current = head->next;
    head->next = NULL;
    while(current != NULL) {
        tmp = current->next;
        free(current);
        current = tmp;
    }
}
void main()
{
    struct node *head = NULL;
    head = add(head,1); /* 1 */
    printlist(head);

    head = add(head,20);/* 20 */
    printlist(head);

    head = add(head,10);/* 1 20 10 */
    printlist(head);

    head = add(head,5); /* 1 20 10 5*/
    printlist(head);

    destroy(head);
    getchar();
}

在上面的例子中，如果你创建一个大小为3的指针数组，每个指针指向head，你可以创建三个链表。这样可以最大限度地处理空间，也不需要检查空闲节点。

Answer 3

def finding_element(a,k):
    print a
    i = 0
    while k < a[i]:
        i = i-1
        print k,a[i]
        if k > a[i]:
            i = i+1
            print k,a[i]
            if k == a[i]:
                print k,a[i]
    else:
        print "not found"

a = [ 1,3,5,7,8,9]
k = 5
finding_element(a,k)

Answer 4

当Python开箱即用时，您真的不必去解决所有麻烦。如果您有一些复杂的对象要操作，但不要过分考虑，并且让Python担心内存分配（再也没有人手动做），那么可以确保将其包装在函数中。

这相当于您在非常基本的Python中进行的所有函数调用：

stacks = [ [] for _ in range(3) ]

stacks[0].append("hello")   # push(0,"hello")
stacks[1].append("foo")     # push(1,"foo")
stacks[0].append("goodbye") # push(0,"goodbye")
stacks[1].append("bar")     # push(1,"bar")
print(stacks)               # list_all()
stacks[0].pop()             # pop(0)
stacks[0].pop()             # pop(0)
stacks[2].append("abc")     # push(2,"abc")
print(stacks)               # list_all()
stacks[1].pop()             # pop(1)
stacks[2].pop()             # pop(2)
stacks[1].pop()             # pop(1)
print(stacks)               # list_all()

如何有效地在单个阵列中实现3个堆栈？

4 个答案: