如何在C ++中检查整数单链列表的对称性？

Question

I have a question about singly-linked list in C++.

An integer array[0..n] is called symmetric if array[0] = array[n], array[1] = array[n-1], ...

For example: 1 2 3 4 5 4 3 2 1

So, is there any way to check the symmetry of an integer singly-linked list?

I've thought about copying the value of them downto an array then check the symmetry of this array but I think it is not good because the featured of link list will be lost.

Answer 1

If by "simple-linked" you actually mean singly linked, then you have to copy half of them - whether on the stack using recursion or to an array.

bool is_symmetric(Node* p, int n)
{
    Value values[n / 2]; // use alloca or std::vector if your compiler doesn't support
    for (int i = 0; i < n / 2; ++i, p = p->next)
         values[i] = p->value;
    if ((n + 1) % 2) p = p->next; // for odd number of elements, middle one's ok
    for (; i >= 0; --i, p = p->next)
         if (values[i] != p->value)
             return false;
    return true;
}

Note: I haven't tested this, and it might have an error or two, but the general idea's there....

If it's doubly linked, it's even easier - iterate half way then iterate in both directions doing the comparisons.

Answer 2

The classic way is to fold over the list and push elements on a stack until half way, then pop from the stack and compare with remaining elements.

bool isPalindrome(forward_list<int> &l){
 forward_list<int> stack;
 auto it = l.begin();
 int len = 0;
 int i   = 0;
 while (it != l.end()){
   ++len;
   ++it;
 }
 if (len <= 1)
   return true;
 it = l.begin();
 while (i < (len / 2)) {
   stack.push_front(*it);
   ++i;
   ++it;
 }
 if ((len % 2) == 1) 
   ++it;
 while (!stack.empty()){
   if (stack.front() != *it)
     return false;
   stack.pop_front();
   ++it;
 }
 return true;
}

bool test_good(const int i){
 int j = i / 2;
 forward_list<int> l;
 for (int k = 0; k < j; k++){
   l.push_front(k); 
 }
 if (i % 2 == 1){
   l.push_front(j);
 }
 for (int k = j-1; k >= 0; k--){
   l.push_front(k);
 }
 return isPalindrome(l);
}

bool test_bad(const int i){
 forward_list<int> l;
 for (int k = 0; k < i; k++){
   l.push_front(k); 
 }
 l.push_front(i);
 l.push_front(i+1);
 return !isPalindrome(l);
}

int main(){
 for (int i = 0; i < 20; i++){
   cout << "test for " << i << "...";
   if (test_good(i))
     cout << "ok...";
   else return i;
   if (test_bad(i))
     cout << "ok." << endl;
   else return i;
 }

 return 0;
}

I used a forward_list to implement the stack, rather than using the dedicated std::stack template. Also, note that the problem is trickier when using generic lists of T , since you don't necessarily want to instantiate copies of values in the list when pushing on the stack, but you can't push references to values of primitive types (like char or int ). For that problem, you would have to provide two different templated implementations, which would be enable_if ed according to what T is. You would probably also add the comparison operator to the template.