C++ (Cpp) comparePriority示例

示例#1

文件： evaluate_reverse_polish_notation.cpp 项目： halooooJeffrey/Leetcode

    //将表达式转化成逆波兰式
	vector<string> convertToRPN(const string& s) {
		vector<string> retVec;	//要返回的vector，里面的元素构成逆波兰式
		stack<char> operatorStack;	//存放操作符的栈
		operatorStack.push('\0');	//首先将\0入栈，否则如果表达式第一个就是操作符，那么就无法与栈中的元素比较
		string::size_type sz = 0;
		while (sz != s.size()) {
			if (isdigit(s[sz])) {	//如果是数字，那么直接放到逆波兰式中
				retVec.push_back(string(&s[sz], 1));
				++sz; //看接下来的元素
			}
			else {	//如果是操作符，那么与栈中的操作符比较
				char op = comparePriority(operatorStack.top(), s[sz]);
				switch (op) {
                    case '<': {		//如果栈中的操作符大，那么元素入栈，看接下来的元素
                        operatorStack.push(s[sz]);
                        ++sz;
                        break;
                    }
                    case '=': {		//如果相等，这说明栈中是左括号，元素是右括号，它们都不用放入逆波兰式
                        operatorStack.pop();
                        ++sz;
                        break;
                    }
                    case '>': {		//如果栈中的操作符大，说明要先计算栈中的操作符，所以将它弹出放到逆波兰式中，注意，这里sz不增加，因为还要
                    				//比较当前元素与新栈顶的元素优先级
                        string op = string(&operatorStack.top(), 1);
                        retVec.push_back(op);
                        operatorStack.pop();
                        break;
                    }
                    default:
                        exit(-1);
				}
			}
		}	
		while (!operatorStack.empty()) {	//现在我们已经都将所有元素比较好了，如果栈中还有元素，就要依次的放入逆波兰式中
			retVec.push_back(string(&operatorStack.top(), 1));	
			operatorStack.pop();
		}
		retVec.erase(retVec.begin() + retVec.size() - 1);	//注意，由于开始放入了\0，最后要讲它从逆波兰式中去除
		return retVec;
	}

示例#2

文件： test_PriorityLinked.c 项目： poonjon/RTOS

void test_compare_priority_list_element_smaller_shouled_return_1(void){
  int result;
  TCB list = {.priority = 1};
  TCB insert = {.priority = 2};
  
  result = comparePriority(&list, &insert);
  
  TEST_ASSERT_EQUAL(1, result);
}

void test_compare_priority_list_element_larger_should_return_0(void){
  int result;
  TCB list = {.priority = 2};
  TCB insert = {.priority = 1};
  
  result = comparePriority(&list, &insert);
  
  TEST_ASSERT_EQUAL(0, result);
}

void test_compare_priority_list_element_same_priority_should_return_0(void){
  int result;
  TCB list = {.priority = 1};
  TCB insert = {.priority = 1};
  
  result = comparePriority(&list, &insert);
  
  TEST_ASSERT_EQUAL(result, 0);
}

void test_removeFromHeadPriorityLinkedList_TCB1_should_be_removed_TCB2_should_be_head(){
  PriorityLinkedList list;
  TCB *removedElement;
  createPriorityLinkedList(&list);
  
  TCB TCB2 = {.next = NULL, .priority = 2};
  TCB TCB1 = {.next = &TCB2, .priority = 1};
  
  list.head = &TCB1;
  list.tail = &TCB2;
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  
  TEST_ASSERT_EQUAL(list.head, &TCB2);
  TEST_ASSERT_EQUAL(list.tail, &TCB2);
  TEST_ASSERT_EQUAL(removedElement, &TCB1);
  
  
}

void test_removeFromHeadPriorityLinkedList_TCB1_should_be_removed_head_should_be_null(){
  PriorityLinkedList list;
  TCB *removedElement;
  createPriorityLinkedList(&list);
  
  TCB TCB1 = {.next = NULL, .priority = 1};
  
  list.head = &TCB1;
  list.tail = &TCB1;
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  
  TEST_ASSERT_NULL(list.head);
  TEST_ASSERT_NULL(list.tail);
  TEST_ASSERT_EQUAL(removedElement, &TCB1);
  
}

void test_removeFromHeadPriorityLinkedList_TCB1_TCB2_should_be_removed_TCB3_should_be_head(){
  PriorityLinkedList list;
  TCB *removedElement;
  createPriorityLinkedList(&list);
  
  TCB TCB3 = {.next = NULL, .priority = 1};
  TCB TCB2 = {.next = &TCB3, .priority = 2};
  TCB TCB1 = {.next = &TCB2, .priority = 3};
  
  list.head = &TCB1;
  list.tail = &TCB3;
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB1, removedElement);
  TEST_ASSERT_EQUAL(&TCB2, list.head);
  TEST_ASSERT_EQUAL(&TCB3, list.head->next);
  TEST_ASSERT_EQUAL(&TCB3, list.tail);
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB2, removedElement);
  TEST_ASSERT_EQUAL(&TCB3, list.head);
  TEST_ASSERT_EQUAL(&TCB3, list.tail);
  TEST_ASSERT_EQUAL(NULL, list.head->next);
  
}

void test_removeFromHeadPriorityLinkedList_TCB1_TCB2_TCB3_should_be_removed(){
  PriorityLinkedList list;
  TCB *removedElement;
  createPriorityLinkedList(&list);
  
  TCB TCB3 = {.next = NULL, .priority = 1};
  TCB TCB2 = {.next = &TCB3, .priority = 2};
  TCB TCB1 = {.next = &TCB2, .priority = 3};
  
  list.head = &TCB1;
  list.tail = &TCB3;
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB1, removedElement);
  TEST_ASSERT_EQUAL(&TCB2, list.head);
  TEST_ASSERT_EQUAL(&TCB3, list.head->next);
  TEST_ASSERT_EQUAL(&TCB3, list.tail);
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB2, removedElement);
  TEST_ASSERT_EQUAL(&TCB3, list.head);
  TEST_ASSERT_EQUAL(&TCB3, list.tail);
  TEST_ASSERT_EQUAL(NULL, list.head->next);  

  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB3, removedElement);
  TEST_ASSERT_NULL(list.head);
  TEST_ASSERT_NULL(list.tail);
    
}

void test_addPriorityLinked_TCB1_into_empty_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);
  

  TCB TCB1 = {.next = NULL, .priority = 1};

  list.head = NULL;
  list.tail = NULL;

  addPriorityLinkedList(&list, &TCB1, comparePriority);

  TEST_ASSERT_NOT_NULL(list.head);
  TEST_ASSERT_NOT_NULL(list.tail);
  

}

void test_addPriorityLinked_lower_priority_TCB1_into_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);  
  
  TCB TCB1 = {.next = NULL, .priority = 1};
  TCB TCB2 = {.next = NULL, .priority = 20};

  list.head = &TCB2;
  list.tail = &TCB2;
  
  addPriorityLinkedList(&list, &TCB1, comparePriority);

  TEST_ASSERT_EQUAL(list.head, &TCB2);
  TEST_ASSERT_EQUAL(list.tail, &TCB1);
  TEST_ASSERT_EQUAL(TCB2.next, &TCB1);
  TEST_ASSERT_NULL(TCB1.next);
  
}

void test_addPriorityLinked_lower_priority_TCB3_into_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);
  
  TCB TCB3 = {.next = NULL, .priority = 20};
  TCB TCB2 = {.next = NULL, .priority = 20};
  TCB TCB1 = {.next = NULL, .priority = 20};

  list.head = &TCB1;
  list.tail = &TCB1;
  
  addPriorityLinkedList(&list, &TCB2, comparePriority);
  addPriorityLinkedList(&list, &TCB3, comparePriority);

  TEST_ASSERT_EQUAL(list.head, &TCB1);
  TEST_ASSERT_EQUAL(list.tail, &TCB3);
  TEST_ASSERT_EQUAL(TCB1.next, &TCB2);
  TEST_ASSERT_EQUAL(TCB2.next, &TCB3);
  TEST_ASSERT_NULL(TCB3.next);
  
}

void test_addPriorityLinked_higher_priority_TCB1_into_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);
  
  TCB TCB1 = {.next = NULL, .priority = 40};
  TCB TCB2 = {.next = NULL, .priority = 20};

  list.head = &TCB2;
  list.tail = &TCB2;

  addPriorityLinkedList(&list, &TCB1, comparePriority);
  TEST_ASSERT_EQUAL(&TCB1, list.head);
  TEST_ASSERT_EQUAL(&TCB2, list.tail);
  TEST_ASSERT_EQUAL(&TCB2, TCB1.next);
  TEST_ASSERT_NULL(TCB2.next);
  
}

void test_addPriorityLinked_inbetween_priority_TCB1_into_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);
  
  TCB TCB3 = {.next = NULL, .priority = 20};
  TCB TCB2 = {.next = &TCB3, .priority = 50};
  TCB TCB1 = {.next = NULL, .priority = 40};

  list.head = &TCB2;
  list.tail = &TCB3;

  addPriorityLinkedList(&list, &TCB1, comparePriority);
  TEST_ASSERT_EQUAL(&TCB2, list.head);
  TEST_ASSERT_EQUAL(&TCB3, list.tail);
  TEST_ASSERT_EQUAL( &TCB1, TCB2.next);
  TEST_ASSERT_EQUAL(&TCB3, TCB1.next);
  TEST_ASSERT_NULL(TCB3.next);
  
}

void test_addPriorityLinked_add_same_priority_TCB3_into_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);
  
  TCB TCB3 = {.next = NULL, .priority = 0};
  TCB TCB2 = {.next = NULL, .priority = 0};
  TCB TCB1 = {.next = &TCB2, .priority = 0};

  list.head = &TCB1;
  list.tail = &TCB2;

  addPriorityLinkedList(&list, &TCB3, comparePriority);
  TEST_ASSERT_EQUAL(&TCB1, list.head);
  TEST_ASSERT_EQUAL(&TCB3, list.tail);
  TEST_ASSERT_EQUAL(&TCB2, TCB1.next);
  TEST_ASSERT_EQUAL(&TCB3, TCB2.next);
  TEST_ASSERT_NULL(TCB3.next);
  
}

void test_addPriorityLinked_add_4_same_priority_into_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);
  
  TCB TCB4 = {.next = NULL, .priority = 0};
  TCB TCB3 = {.next = NULL, .priority = 0};
  TCB TCB2 = {.next = NULL, .priority = 0};
  TCB TCB1 = {.next = NULL, .priority = 0};

  list.head = &TCB1;
  list.tail = &TCB1;

  addPriorityLinkedList(&list, &TCB2, comparePriority);
  addPriorityLinkedList(&list, &TCB3, comparePriority);
  addPriorityLinkedList(&list, &TCB4, comparePriority);
  TEST_ASSERT_EQUAL(&TCB1, list.head);
  TEST_ASSERT_EQUAL(&TCB4, list.tail);
  TEST_ASSERT_EQUAL(&TCB2, TCB1.next);
  TEST_ASSERT_EQUAL(&TCB3, TCB2.next);
  TEST_ASSERT_EQUAL(&TCB4, TCB3.next);
  TEST_ASSERT_NULL(TCB4.next);
  
}

void test_addPriorityLinked_add_3_same_priority_into_list_and_removeFromHeadPriorityLinkedList_remove_3_from_list(){
  PriorityLinkedList list;
  createPriorityLinkedList(&list);
  TCB *removedElement;
  
  TCB TCB4 = {.next = NULL, .priority = 0};
  TCB TCB3 = {.next = NULL, .priority = 0};
  TCB TCB2 = {.next = NULL, .priority = 0};
  TCB TCB1 = {.next = NULL, .priority = 0};

  list.head = &TCB1;
  list.tail = &TCB1;

  addPriorityLinkedList(&list, &TCB2, comparePriority);
  TEST_ASSERT_EQUAL(&TCB2, list.head->next);
  TEST_ASSERT_EQUAL(&TCB1, list.head);
  TEST_ASSERT_EQUAL(&TCB2, list.tail);
  TEST_ASSERT_EQUAL(&TCB2, TCB1.next);
  TEST_ASSERT_NULL(TCB2.next);
  
  addPriorityLinkedList(&list, &TCB3, comparePriority);
  TEST_ASSERT_EQUAL(&TCB3, list.tail);
  TEST_ASSERT_EQUAL(&TCB2, TCB1.next);
  TEST_ASSERT_EQUAL(&TCB3, TCB2.next);
  TEST_ASSERT_NULL(TCB3.next);
  
  addPriorityLinkedList(&list, &TCB4, comparePriority);
  TEST_ASSERT_EQUAL(&TCB4, list.tail);
  TEST_ASSERT_EQUAL(&TCB2, TCB1.next);
  TEST_ASSERT_EQUAL(&TCB3, TCB2.next);
  TEST_ASSERT_EQUAL(&TCB4, TCB3.next);
  TEST_ASSERT_NULL(TCB4.next);
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB1, removedElement);
  TEST_ASSERT_EQUAL(&TCB2, list.head);
  TEST_ASSERT_EQUAL(&TCB3, list.head->next);
  TEST_ASSERT_EQUAL(&TCB4, list.tail);
  TEST_ASSERT_EQUAL(&TCB3, TCB2.next);
  TEST_ASSERT_EQUAL(&TCB4, TCB3.next);
  TEST_ASSERT_NULL(TCB4.next);
  TEST_ASSERT_NULL(TCB1.next);
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB2, removedElement);
  TEST_ASSERT_EQUAL(&TCB3, list.head);
  TEST_ASSERT_EQUAL(&TCB4, list.tail);
  TEST_ASSERT_EQUAL(&TCB4, list.head->next);  
  TEST_ASSERT_EQUAL(&TCB4, TCB3.next);
  TEST_ASSERT_NULL(TCB4.next);
  
  removedElement = removeFromHeadPriorityLinkedList(&list);
  TEST_ASSERT_EQUAL(&TCB3, removedElement);
  TEST_ASSERT_EQUAL(&TCB4, list.head);
  TEST_ASSERT_EQUAL(&TCB4, list.tail);
  TEST_ASSERT_NULL(TCB4.next);
}