标签: data-structures

我希望这可以根据价格排序...

final case class Case(price: Int) {}

但这实际上是一个更大的案例类，我从中删除了字段。我想这样排序...

val queue = PriorityQueue.empty[Case](Ordering.by((_: Case).price).reverse)

^按降序排序。

现在我希望这种排序保持不变...

queue.enqueue(Case(price = 2))
println(queue.toString)

queue.enqueue(Case(price = 3))
println(queue.toString)

queue.enqueue(Case(price = 4))
println(queue.toString)

queue.enqueue(Case(price = 1))
println(queue.toString)

queue.enqueue(Case(price = 0))
println(queue.toString)

但是我的输出没有在第四和第五行排序...

PriorityQueue(Case(2))
PriorityQueue(Case(2), Case(3))
PriorityQueue(Case(2), Case(3), Case(4))
PriorityQueue(Case(1), Case(2), Case(4), Case(3))
PriorityQueue(Case(0), Case(1), Case(4), Case(3), Case(2))

而且，该foreach方法没有按顺序迭代...

queue.foreach{ q =>
  print(q + ", ")
}

打印...

Case(0), Case(1), Case(4), Case(3), Case(2), 

如何使我的队列保持降序排列？

我已经多次看到C ++中的节点类被定义为：

struct node
{
    whatever data;
    struct node* pointerToAnyLinkedNode;
}

现在的问题是为什么排在第。4，'struct'是在node *之前写的？它有特殊目的吗？因为如果我不写它不会造成任何问题。很抱歉，如果这个问题重复。我找不到一个BTW。

def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n-1)


def rec():
    print fact(5)

rec()

[来自新手的问题]

Python脚本.

这个问题在很长一段时间内仍然存在,让我解释一下到目前为止我对递归的理解.

在rec()函数中,我再调用了一个函数fact(5),现在该过程转到了fact(n)函数.

函数调用自身直到基本情况.

在其他部分:

5*事实(4)

5*4*事实(3)

5*4*3*事实(2)

5*4*3*2*事实(1)

现在n的值变为0,并返回1

我的问题是,为什么事实(n)函数返回120而不是1.

def check(x):
    if x == 1:
        return 10
    else:
       return 20

print check(1) // Prints 10
print check(3) // Prints 20

我希望你理解我的问题.

谢谢.

我在Hackerrank的反向挑战中解决了Print问题

该void ReversePrint(Node* head)方法采用一个参数 - 链表的头部.你不应该从stdin/console读取任何输入.头部可能是空的,因此不应打印任何东西.以相反的顺序将链接列表的元素打印到stdout/console(使用printf或cout),每行一个.

样本输入

1 - > 2 - > NULL

2 - > 1 - > 4 - > 5 - > NULL

样本输出

2
1
5
4
1
2

Run Code Online (Sandbox Code Playgroud)

我用这个解决了它

    #include <vector>
    void ReversePrint(Node *head)
{
  // This is a "method-only" submission. 
  // You only need to complete this method. 

    std::vector<int> nodeList;
    if(head != NULL){

        while(head != NULL){
            nodeList.push_back(head->data);
            head = head->next;            
        }

        for (std::vector<int>::iterator it = nodeList.end()-1 ; it …

在Java中的数据结构和算法中,陈述了有序数组的优点.其中一个优点,我希望我有一些真实的例子.这不是作业,而是自我澄清.什么是插入/删除不频繁,但搜索频繁的真实情况？即使你可以指向一些github存储库的方向,任何事情都会有所帮助.谢谢.

任何人都可以解释下面描述的给定问题的方法如何在O(N)时间和O(1)空间中运行？

问题:给定2个排序数组,找到共同的元素数.数组长度相同,每个都有不同的元素.

以下面的2个数组为例:

A: 13, 27, 35, 40, 49, 55, 59
B: 17, 35, 39, 40, 55, 58, 60

1. 在B中对A [0] = 13进行线性搜索.从B [0] = 17开始.停止在B [0] = 17.未找到
2. 在B中对A [1] = 27进行线性搜索.从B [0] = 17开始.在B [1] = 35处停止未找到
3. 在B中对A [2] = 35进行线性搜索.从B [1] = 35开始.在B [1] = 35处停止
4. 在B中对A [3] = 40进行线性搜索.从B [2] = 39开始.在B [3] = 40处停止
5. 在B中对A [4] = 49进行线性搜索.从B [3] = 40开始.在B [4] = 55处停止.

我很困惑我们正在进行线性循环的部分,以获得A的所有元素已经制作O(N)时间,然后再次在B中进行线性搜索以找到元素.B中的班轮搜索正在最后一个停止的地方.这不会使给定方法的时间复杂度为O(N ^ 2)吗？如果没有,为什么？

我如何证明n ^ 3.5不是O(n ^ 3)？

我正在为我的算法类做这个.

它说我需要使用Contradiction证明来证明它!

我已经在很多网站上搜索了这个问题.他们通过一些不同的方法来做到这一点.如果我将数组的第一个元素作为最大值输入,则此代码不提供输出a[0].我认为需要做一些小改动.有人可以告诉我吗？

#include <stdio.h>

int main() {
    int a[10], n;
    int largest1, largest2, i;

    printf("enter number of elements you want in array");
    scanf("%d", &n);
    printf("enter elements");
    for (i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    largest1 = a[0];
    for (i = 0; i < n; i++) {
        if (a[i] > largest1) {
            largest1 = a[i];
        }
    }
    largest2 = a[0];
    for (i = 1; i < n; i++) {
        if (a[i] > largest2 && a[i] < …

我被赋予指向链表的头节点的指针,要添加到列表的整数以及必须插入整数的位置.将此节点插入所需位置后,我需要返回头节点.

我写的代码由于某种原因不起作用,并且进入无限循环.

  class Node {
     int data;
     Node next;
  }


Node InsertNth(Node head, int data, int position) {
    int count = 0;
    Node node = head;
    Node prev = null;
    while(count != position){
      count++;
      node = node.next;
      prev = node;
    }

    Node newNode = new Node();
    newNode.data = data;


    newNode.next = node;
    if(count == 0){
          head = newNode;
       }else{
          prev.next = newNode;
    }

    return head;          
}

当我尝试运行下面的快速排序代码时,它会进入无限循环.最后一次迭代将进入无限循环.

class QuickSort {
    public static void main(String[] args) {
        int arr[] = {10, 7, 8, 9, 1, 5,2};
        QuickSort ob = new QuickSort();
        ob.sort(arr, 0,arr.length-1);
        for(int s:arr){
            System.out.print(" "+s);
        }
    }
    int partition(int[] arr,int l,int h){
        int piv = arr[h];
        int i=l-1;
        for(int j=l;j<=h-1;j++){
            if(arr[j] <= piv){
                i++;
                int temp = arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
        int tp = arr[i+1];
        arr[i+1]=arr[h];
        arr[h]=tp;
        return i+1;
    }

    void sort(int[] arr,int l,int h){
        while(l<h){
            int p = partition(arr, l, h);
            sort(arr, l, …