Very good, just as I did in my answer to your question related to this topic, I am going to try to show you a code that is simple to understand and handle.

previous comments

Let's forget about all those stacks in the first place, we just need a list . On the other hand, to make it easier to debug, we are going to create a function that allows us to simplify the conditionals.

Concept

What we are going to do is go through our list and analyze the elements in pairs between the current and the previous one . For example: if my current element is a ( , the previous has to be an operator by force +,-,/,* , otherwise the expression is wrong.

In order not to have problems in our loop, we will analyze the first case independently.

Code

import java.util.LinkedList;
import java.util.Scanner;
public class Prueba 
{
    public static boolean esOperador(String e)
    {
        return (e.equals("+") || e.equals("-") || e.equals("*") || e.equals("/"));
    }
    public static void main(String[] args) 
    {
        Scanner x = new Scanner(System.in);
        System.out.println("De que tamaño sera su expresion?");
        int n = x.nextInt();
        int numParentesisAbiertos = 0;
        //Declarandolo con <String> 
        //te ahorras tener que hacer luego los casting
        LinkedList<String> lista = new LinkedList<String>(); 

        x.nextLine(); //esto debe ir fuera del bucle
        for (int i = 0; i < n; i++) 
        {
            System.out.println("Introduzca su elemento");
            String e = x.nextLine();
            lista.add(e);
        }
        //hasta aquí hemos guardado en nuestra lista 
        //analizamos el primer caso fuera del bucle
        String primero = lista.get(0);
        if(esOperador(primero) || primero.equals(")"))
        {
            System.out.println("La expresión es incorrecta");
            System.exit(0);
        }
        if(primero.equals("("))
        {
            numParentesisAbiertos++;
        }
        for(int i = 1; i < lista.size(); i++)
        {
            String previo = lista.get(i-1);
            String actual = lista.get(i);
            System.out.println(actual);
            switch(actual)
            {
                case "(":
                {
                    if(!esOperador(previo))
                    {
                        System.out.println("La expresión es incorrecta");
                        System.exit(0);
                    }
                    numParentesisAbiertos++;
                    break;
                }
                case ")":
                {
                    if(numParentesisAbiertos == 0 || esOperador(previo))
                    {
                        System.out.println("La expresión es incorrecta " + numParentesisAbiertos);
                        System.exit(0);
                    }
                    numParentesisAbiertos--;
                    break;
                }
                case "+":
                case "-":
                case "/":
                case "*":
                {
                    if(esOperador(previo) || previo.equals("("))
                    {
                        System.out.println("La expresión es incorrecta");
                        System.exit(0);
                    }
                    break;
                }
                default: //es una variable
                {
                    if(!esOperador(previo) && !previo.equals("("))
                    {
                        System.out.println("La expresión es incorrecta");
                        System.exit(0);
                    }
                    break;
                }
            }
        }
        if(numParentesisAbiertos==0)
        {
            System.out.println("La expresión es correcta");
        }
        else
        {
            System.out.println("La expresión es incorrecta");
            System.exit(0);
        }
    }
}

code notes

Notice a couple of things about the code:

1. As soon as the expression is incorrect in any section, the program stops. Therefore, it will only check the entire expression if it is correct or the element giving the error is the last one. This will make your executions faster.
2. Notice how easy it is to read a well-tabulated code, with its {}settings in all the blocks. I recommend that you try to get used to following a good code style. I use curly braces even for 1-line conditionals.
3. I've made a couple of changes to the first part of your code since it wasn't working properly. For example the case of x.nextLine();within the for.

Input/output example

Input: a+b*(c+d)-a
Output: The expression is correct

I hope you understand and serve you.

Solution of the exercise using only batteries :

import java.lang.*;
import java.util.*;

public class Solucion {

public static void main(String[] args) {

    Scanner x = new Scanner(System.in);
    System.out.println("De que tamaño sera su expresion?");
    int n = x.nextInt();

    LinkedList pila = new LinkedList();
    LinkedList pila1 = new LinkedList();
    LinkedList pila2 = new LinkedList();
    LinkedList pila3 = new LinkedList();
    LinkedList pila4 = new LinkedList();
    LinkedList pila5 = new LinkedList();
    LinkedList pp = new LinkedList();
    LinkedList ppo = new LinkedList();
    LinkedList pilaC = new LinkedList();

    x.nextLine();
    for (int i = 0; i < n; i++) {
        System.out.println("Introduzca su elemento");

        String e = x.nextLine();
        pila.push(e);
        pila1.push(e);
        pila2.push(e);
        pila3.push(e);
        pila4.push(e);
        pila5.push(e);

    }

    int a = 0, b = 0;

    if (pila1.size() == 1) {
        String u = (String) pila1.pop();
        if (0 == u.compareTo("+") || 0 == u.compareTo("-") || 0 == u.compareTo("*") || 0 == u.compareTo("/")
                || 0 == u.compareTo("(") || 0 == u.compareTo(")")) {
            System.out.println("Expresion incorrecta");
        }
    } else if (pila5.size() == 2) {
        String xx = (String) pila5.pop();
        String yy = (String) pila5.pop();
        if (0 == xx.compareTo("+") || 0 == xx.compareTo("-") || 0 == xx.compareTo("*") || 0 == xx.compareTo("/")
                || 0 == yy.compareTo("+") || 0 == yy.compareTo("-") || 0 == yy.compareTo("*") || 0 == yy.compareTo("/")) {
            System.out.println("La expresion es incorrecta.");
        }
    } else {

        while (!pila.isEmpty()) {
            String element = (String) pila.pop();

            if (0 == element.compareTo(")") && !pila.isEmpty()) {
                String sim = (String) pila.pop();
                if (0 == sim.compareTo("+") || 0 == sim.compareTo("-") || 0 == sim.compareTo("*") || 0 == sim.compareTo("/")) {
                    a++;
                }
            }
        }

        if (a != 0) {
            System.out.println("La expresion no esta escrita de manera  correcta");
        } else {

            while (!pila2.isEmpty()) {
                String simbolo = (String) pila2.pop();
                if ((0 == simbolo.compareTo("+") || 0 == simbolo.compareTo("-") || 0 == simbolo.compareTo("*") || 0 == simbolo.compareTo("/")) && !pila2.isEmpty()) {
                    String el = (String) pila2.pop();
                    if (0 == el.compareTo("(") || 0 == el.compareTo("+") || 0 == el.compareTo("-") || 0 == el.compareTo("*") || 0 == el.compareTo("/")) {
                        b++;
                    }
                }
            }

            if (b != 0) {
                System.out.println("La expresion no esta escrita de manera correcta :/");
            } else { 
                String w = null;
                int c = 0, d = 0, k = 0;
                while (!pila4.isEmpty()) {
                    String v = (String) pila4.pop();
                    if (0 == v.compareTo("(") && !pila4.isEmpty()) {
                        w = (String) pila4.pop();
                        if (0 == w.compareTo("+") || 0 == w.compareTo("-") || 0 == w.compareTo("*") || 0 == w.compareTo("/") || 0 == w.compareTo("(")) {
                            c++;
                        } else {
                            k++; 
                        }
                    }

                }

                if (k != 0) {
                    System.out.println("La expresion no esta escrita de manera correcta.");
                } else {

                    while (!pila3.isEmpty()) {
                        String e = (String) pila3.pop();
                        if (0 == e.compareTo("(") || 0 == e.compareTo(")")) {
                            pp.push(e);
                        }
                    }
                    while (!pp.isEmpty()) {
                        ppo.push(pp.pop());
                    }

                    int ww = 0;
                    while (!ppo.isEmpty() && ww != 1) {
                        String s = (String) ppo.pop();
                        if (0 == s.compareTo("(") && !pilaC.isEmpty()) {
                            pilaC.pop();
                        } else if (0 == s.compareTo("(") && pilaC.isEmpty()) {
                            System.out.println("La expresion no esta escrita de manera correcta :(");
                            ww = 1;
                        } else {
                            pilaC.push(s);
                        }
                    }
                    if (ww == 1)
                    {
                        System.out.println();
                    } else if (!pilaC.isEmpty()) {
                        System.out.println("La expresion no esta escrita de manera correcta :-(");
                    } else {
                        System.out.println("La expresion esta escrita de manera correcta :)");
                    }

                }

            }
        }

    }
}
}

Note: Like DanielGS's answer, if input: a+(), output:"La expresion es correcta". And so it must be, because what he is saying is that to aadd "vacio" o () o 0.