void reverse_node(node_t **pp_node) { if(*pp_node == NULL) return; node_t *current = *pp_node; node_t *next_node = current -> next; if(current-> next == NULL) return; reverse_node(&next_node); current -> next -> next = current; current -> next = NULL; *pp_node = next_node; }
void reverse_node(node_t **pp_node, node_t *head) { if(*pp_node == head) return; node_t *current = *pp_node; node_t *next_node = current -> next; if(current-> next == head) return; reverse_node(&next_node, head); node_t *temp = current -> next -> next; current -> next -> next = current; current -> next = temp; *pp_node = next_node; }
int main() { int ret, len; Node *single_linked_list; single_linked_list = create_list(3); ret = show_list(single_linked_list); //len = list_lenth(single_linked_list); //printf("the length of the list is %d\n", len); //single_linked_list = delete_node(single_linked_list, 3); //single_linked_list = insert_node(single_linked_list, 4); //single_linked_list = sort_node(single_linked_list); single_linked_list = reverse_node(single_linked_list); ret = show_list(single_linked_list); return 0; }
void list_reverse(t_list *list) { int index; t_node *current; t_node *tmp; index = 0; if (list && list->size > 1) { current = list->head; while (index < list->size) { tmp = current->next; reverse_node(current); current = tmp; index++; } tmp = list->head; list->head = list->tail; list->tail = tmp; } }
osrm::matching::CandidateLists getCandidates( const std::vector<FixedPointCoordinate> &input_coords, const std::vector<std::pair<const int, const boost::optional<int>>> &input_bearings, const double gps_precision, std::vector<double> &sub_trace_lengths) { osrm::matching::CandidateLists candidates_lists; // assuming the gps_precision is the standart-diviation of normal distribution that models // GPS noise (in this model) this should give us the correct candidate with >0.95 double query_radius = 3 * gps_precision; double last_distance = coordinate_calculation::haversine_distance(input_coords[0], input_coords[1]); sub_trace_lengths.resize(input_coords.size()); sub_trace_lengths[0] = 0; for (const auto current_coordinate : osrm::irange<std::size_t>(0, input_coords.size())) { bool allow_uturn = false; if (0 < current_coordinate) { last_distance = coordinate_calculation::haversine_distance( input_coords[current_coordinate - 1], input_coords[current_coordinate]); sub_trace_lengths[current_coordinate] += sub_trace_lengths[current_coordinate - 1] + last_distance; } if (input_coords.size() - 1 > current_coordinate && 0 < current_coordinate) { double turn_angle = ComputeAngle::OfThreeFixedPointCoordinates( input_coords[current_coordinate - 1], input_coords[current_coordinate], input_coords[current_coordinate + 1]); // sharp turns indicate a possible uturn if (turn_angle <= 90.0 || turn_angle >= 270.0) { allow_uturn = true; } } // Use bearing values if supplied, otherwise fallback to 0,180 defaults auto bearing = input_bearings.size() > 0 ? input_bearings[current_coordinate].first : 0; auto range = input_bearings.size() > 0 ? (input_bearings[current_coordinate].second ? *input_bearings[current_coordinate].second : 10) : 180; auto candidates = facade->NearestPhantomNodesInRange(input_coords[current_coordinate], query_radius, bearing, range); if (candidates.size() == 0) { break; } // sort by foward id, then by reverse id and then by distance std::sort( candidates.begin(), candidates.end(), [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs) { return lhs.phantom_node.forward_node_id < rhs.phantom_node.forward_node_id || (lhs.phantom_node.forward_node_id == rhs.phantom_node.forward_node_id && (lhs.phantom_node.reverse_node_id < rhs.phantom_node.reverse_node_id || (lhs.phantom_node.reverse_node_id == rhs.phantom_node.reverse_node_id && lhs.distance < rhs.distance))); }); auto new_end = std::unique( candidates.begin(), candidates.end(), [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs) { return lhs.phantom_node.forward_node_id == rhs.phantom_node.forward_node_id && lhs.phantom_node.reverse_node_id == rhs.phantom_node.reverse_node_id; }); candidates.resize(new_end - candidates.begin()); if (!allow_uturn) { const auto compact_size = candidates.size(); for (const auto i : osrm::irange<std::size_t>(0, compact_size)) { // Split edge if it is bidirectional and append reverse direction to end of list if (candidates[i].phantom_node.forward_node_id != SPECIAL_NODEID && candidates[i].phantom_node.reverse_node_id != SPECIAL_NODEID) { PhantomNode reverse_node(candidates[i].phantom_node); reverse_node.forward_node_id = SPECIAL_NODEID; candidates.push_back( PhantomNodeWithDistance{reverse_node, candidates[i].distance}); candidates[i].phantom_node.reverse_node_id = SPECIAL_NODEID; } } } // sort by distance to make pruning effective std::sort(candidates.begin(), candidates.end(), [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs) { return lhs.distance < rhs.distance; }); candidates_lists.push_back(std::move(candidates)); } return candidates_lists; }
// Filters PhantomNodes to obtain a set of viable candiates void filterCandidates(const std::vector<util::Coordinate> &coordinates, MatchPlugin::CandidateLists &candidates_lists) { for (const auto current_coordinate : util::irange<std::size_t>(0, coordinates.size())) { bool allow_uturn = false; if (coordinates.size() - 1 > current_coordinate && 0 < current_coordinate) { double turn_angle = util::coordinate_calculation::computeAngle(coordinates[current_coordinate - 1], coordinates[current_coordinate], coordinates[current_coordinate + 1]); // sharp turns indicate a possible uturn if (turn_angle <= 90.0 || turn_angle >= 270.0) { allow_uturn = true; } } auto &candidates = candidates_lists[current_coordinate]; if (candidates.empty()) { continue; } // sort by forward id, then by reverse id and then by distance std::sort(candidates.begin(), candidates.end(), [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs) { return lhs.phantom_node.forward_segment_id.id < rhs.phantom_node.forward_segment_id.id || (lhs.phantom_node.forward_segment_id.id == rhs.phantom_node.forward_segment_id.id && (lhs.phantom_node.reverse_segment_id.id < rhs.phantom_node.reverse_segment_id.id || (lhs.phantom_node.reverse_segment_id.id == rhs.phantom_node.reverse_segment_id.id && lhs.distance < rhs.distance))); }); auto new_end = std::unique(candidates.begin(), candidates.end(), [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs) { return lhs.phantom_node.forward_segment_id.id == rhs.phantom_node.forward_segment_id.id && lhs.phantom_node.reverse_segment_id.id == rhs.phantom_node.reverse_segment_id.id; }); candidates.resize(new_end - candidates.begin()); if (!allow_uturn) { const auto compact_size = candidates.size(); for (const auto i : util::irange<std::size_t>(0, compact_size)) { // Split edge if it is bidirectional and append reverse direction to end of list if (candidates[i].phantom_node.forward_segment_id.enabled && candidates[i].phantom_node.reverse_segment_id.enabled) { PhantomNode reverse_node(candidates[i].phantom_node); reverse_node.forward_segment_id.enabled = false; candidates.push_back( PhantomNodeWithDistance{reverse_node, candidates[i].distance}); candidates[i].phantom_node.reverse_segment_id.enabled = false; } } } // sort by distance to make pruning effective std::sort(candidates.begin(), candidates.end(), [](const PhantomNodeWithDistance &lhs, const PhantomNodeWithDistance &rhs) { return lhs.distance < rhs.distance; }); } }