Java 当我使用5位数或更长的序列时，程序似乎在排序错误的东西

我的程序是要按字典顺序打印出一个可能序列的所有排列

它通过以下方式做到这一点：

查找旁边有较大数字的最右边的数字。（打这个号码x）

将x与其右侧大于x的最小数字交换

将所有数字按x原始索引右侧的升序排序

据我所知，我的程序似乎在第三步遇到了问题。它将事物按升序排列

我的排序代码是：

java.util.Arrays.sort（seq，seenCount，l-2）

seq是存储数字的数组。seenCount是x的索引位置。l是不是从0开始的数组长度

老实说，我不知道为什么它是
l-2
，我只是在摆弄，这似乎让它在4个数字的序列上工作。然而，如果我把它设为l-1，它将在3个字符长的序列上工作，而不是4个字符。然后，我尝试将其设置为
l-3
，长度为5个字符，但这只是给了我一个索引自动失效错误

如果在4个字符的序列上设置为
l-1
，则会出现以下问题：

它达到了：3-2-4-1

这意味着它必须接受2并与4交换。它会这样做，生成这个列表：3-4-2-1。2>1，因此它需要交换周围的数据，但它会执行以下操作：
3-2-4-1并将其放回原来的位置

程序设法从1-2-3-4一直到那一点没有任何问题。但是，如果我成功了：
java.util.Arrays.sort（seq，seenCount，l-2）它可以毫无问题地运行，并且可以管理手头的任务。然而，如果我用5个数字序列运行它，它在不同的点上有相同的问题

如果你需要我发布我的整个程序，我可以，尽管它有点凌乱

提前谢谢

好的，这是我根据要求编写的代码，如果有人对如何改进代码有任何建议，我们将不胜感激

//Lexicographical Sorting

   import javax.swing.*;



   public class LexiSort
   {
      public static void main (String[] args)
      {

         String sInput = JOptionPane.showInputDialog("enter seq");
         int seq[];
         int l = sInput.length();
         int input = Integer.parseInt(sInput);
         seq = new int[l];
         boolean check = false;
         char[] charArray = sInput.toCharArray();
         int seen[];
         seen = new int[l];
         int count = 0;
         int compare[];
         compare = new int[l];
         int indexPos = 0;
         int compareL = 0;
         int smallest = 0;
         int swap = 0;
         int bigCheckCount = 0;
         int trueLength = 0;
         int trueIndex = 0;
         int lengthOfArray = l-1;
         int compare2Count = 0;
         int compare2[];
         int biggerNumberIndex = 0;
         compare2 = new int[l];
         int seenCount = 0;
         int reOrder[];
         reOrder = new int[l];
            int sortL = 0;

      //Converts it into Int Array

         //System.out.println("Original Sequence: ");

         for(int i = 0; i <= l-1; i++)
         {
            int ch2int = charArray[i] - '0';
            seq[i] = ch2int;
           // System.out.println(seq[i]);
         } 

        //Sorts the sequence into acsending order
         /*int temp;
         for(int i=0; i < l-1; i++)
         {

            for(int j=1; j < l-i; j++)
            {
               if(seq[j-1] > seq[j])
               {
                  temp=seq[j-1];
                  seq[j-1] = seq[j];
                  seq[j] = temp;
               }
            }
         }

        //Prints the sorted sequence
         System.out.println("Sorted Sequence: ");
         for(int k = 0; k <= l-1;k++)
         {
            System.out.println(seq[k]);
         } 
        */

        // Adds items in the sequence that are smaller than the number on the right to  seen[]

         while(count<10000)
         {

            for(int i = 0; i<l-1;i++)
            {


               if(seq[i] < seq[i+1])
               {

                  seen[seenCount++] = seq[i];
                  indexPos++;
                  trueIndex = indexPos;


               }
               else
               {
                  indexPos++;
                  count++;

               }


            }

            System.out.println("SEEN COUNT::::::::::::" + seenCount);

         //Prints out seen[] and gets the value of the last digit in the seen array
            System.out.println("seen[i]: ");
            for(int i = 0; i <seenCount; i++)
            {

               System.out.println(seen[i]);


            }


            int newLength = l-trueIndex;
            int newTrueIndex = trueIndex-1;

         //Finds all numbers after the last nuber that has a bigger number on the right and stores them in the compare array
            System.out.println("COMPARE :");
            for(int i = 0; i <newLength; i++)
            {
               compare[i] = seq[trueIndex++];
               System.out.println(compare[i]);

            }

         //Finds all ints in the compare array that are bigger than the number at trueIndex
            System.out.println("Numbers that are allowed to be comapred: ");
            compareL = compare.length;
            for(int i = 0; i<l-1; i++)
            {
               if(compare[i] > seq[seenCount-1])//hrtr
               {
                  compare2[i] = compare[i];
                  System.out.println(compare2[i]);
                  compare2Count++;

               }


 }

     //Finds the smallest number of the numbers stored in compare2 and swaps it with the number at indexPos of seq[i]
        smallest = compare[0];
        trueLength = lengthOfArray - newTrueIndex;
        System.out.println("TRUE LENGTH: " + trueLength);


        if(trueLength == 1)
        {
           int temp2 = seq[newTrueIndex];
           seq[newTrueIndex] = compare2[0];
           seq[newTrueIndex+1] = temp2;
        }

        else
        {
           for(int i = 0; i< compare2Count; i++)
           {
              if(compare2[i] < smallest && compare2[i] > seq[seenCount-1] )
              {
                 smallest = compare2[i];
              }
           }
           System.out.println("SMALLEST :" +smallest);
           while(check != true)
           {
              if(smallest == seq[bigCheckCount])
              {
                 biggerNumberIndex = bigCheckCount;
                 System.out.println("Bigger Number INdex :" + biggerNumberIndex);
                 check = true;

              }
              else
              {
                 check = false;
                 bigCheckCount++;
              }
           }

           int temp3 = seq[newTrueIndex];
           seq[newTrueIndex] = seq[biggerNumberIndex];
           System.out.println(seq[biggerNumberIndex]);
           seq[biggerNumberIndex] = temp3;

           System.out.println("New Seq[] :");
           for(int i = 0; i<l;i++)
           {
              System.out.println(seq[i]);

           }
           System.out.println("SEEN COUNT :" + seenCount);
           System.out.println("l:" + l);

           java.util.Arrays.sort(seq, seenCount, l-1);

        }



     //Sorts Remaining numbers out that are on the right ofNew True Index 
        System.out.println("NEWTRUEINDEX: " + newTrueIndex);
     //IT WENT UNDER HERE
        System.out.println("Final Seq: ");
        for(int i = 0; i<l; i++)
        {
           System.out.println(seq[i]);
        }

        trueIndex =0;
        indexPos = 0;
        seenCount = 0;
        compareL = 0;
        smallest = 0;
        newTrueIndex =0;
        compare2Count = 0;
        newLength = 0;
        biggerNumberIndex = 0;
        bigCheckCount = 0;
        check = false;

}

//词典排序
导入javax.swing.*；
公共类LexiSort
{
公共静态void main（字符串[]args）
{
字符串sInput=JOptionPane.showInputDialog（“输入顺序”）；
int-seq[]；
int l=sInput.length（）；
int input=Integer.parseInt（sInput）；
seq=新整数[l]；
布尔检查=假；
char[]charArray=sInput.toCharArray（）；
int seen[]；
SEED=新整数[l]；
整数计数=0；
int比较[]；
比较=新整数[l]；
int indexPos=0；
int compareL=0；
int=0；
整数交换=0；
int bigCheckCount=0；
int trueLength=0；
int-trueIndex=0；
int lengthOfArray=l-1；
int compare2Count=0；
int compare2[]；
int biggerNumberIndex=0；
比较2=新的整数[l]；
int seenCount=0；
int重新排序[]；
重新排序=新整数[l]；
int-sortL=0；
//将其转换为Int数组
//System.out.println（“原始序列：”）；
对于（int i=0；i seq[j]）
{
温度=顺序[j-1]；
序号[j-1]=序号[j]；
seq[j]=温度；
}
}
}
//打印已排序的序列
System.out.println（“排序序列：”）；
对于（int k=0；k）是的，发布您的代码，或者至少发布相关部分好的，我发布了。@morgano