給你把程序改好了，用冒泡法排序。希望能對你有所幫助。

1. #include <reg51.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. uchar code  key_table[]={0xee,0xde,0xbe,0x7e,0xed,0xdd,0xbd,0x7d,0xeb,0xdb};//鍵碼
   
5. uchar code dula_table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//段碼
   
6. uchar code wela_table[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//位碼
   
7. uchar numn[8];//緩存
   
8. uchar nums[8];//緩存
   
9. 
   
10. 
    
11. void keyscan()        //按鍵掃描
    
12. {
    
13.         static uchar count=0;//消抖計數
    
14.         static bit sign=0;//按鍵自鎖標志
    
15.         uchar i,j,temp;//臨時變量
    
16.         P3=0xf0;
    
17.         if(P3!=0xf0)
    
18.         {
    
19.                 if((++count>=20)&&(sign==0))
    
20.                 {
    
21.                         sign=1;
    
22.                         temp=P3;
    
23.                         P3=temp|0x0f;               
    
24.                         temp=P3;
    
25.                         for(i=0;i<10;i++)
    
26.                         {
    
27.                                 if(temp==key_table[i])
    
28.                                 {      
    
29.                                         for(j=7;j>0;j--)
    
30.                                                 numn[j]=numn[j-1];//按輸入順序移位保存鍵值，超出拋棄
    
31.                                         numn[0]=i;                        //保存最后輸入鍵值
    
32.                                         for(j=0;j<8;j++)
    
33.                                         {
    
34.                                                 nums[j]=numn[j];//轉移有效數據
    
35.                                         }
    
36.                                         break;
    
37.                                 }
    
38.                         }
    
39.                 }
    
40.         }
    
41.         else  //鍵抬起
    
42.         {               
    
43.                 count=0;//計數清0
    
44.                 sign=0;//自鎖清0
    
45.         }
    
46. }
    
47. void Line_up()//冒泡法排序程序
    
48. {
    
49.         uchar i, j, temp;
    
50.         for(i=0; i<8-1; i++)
    
51.         {
    
52.                 for(j=0;j<8-1-i;j++)
    
53.                 {
    
54.                         if(nums[j]>nums[j+1])
    
55.                         {
    
56.                                 temp=nums[j];
    
57.                                 nums[j]=nums[j+1];
    
58.                                 nums[j+1]=temp;
    
59.                         }
    
60.                 }
    
61.         }
    
62. }
    
63. void display()//動態顯示程序
    
64. {
    
65.         static uchar i=0;
    
66.         P0=0x00;//消隱
    
67.         P2=wela_table[i];//位碼
    
68.         P0=dula_table[nums[i]];//段碼
    
69.         if(++i==8)
    
70.                 i=0;
    
71. }
    
72. 
    
73. void main()
    
74. {
    
75.         while(1)
    
76.         {
    
77.                 keyscan();//按鍵掃描
    
78.                 Line_up();//排序程序
    
79.                 display();//顯示程序
    
80.         }
    
81. }
    

復制代碼

冷瞳啊 發表于 2019-3-20 20:06
請問一下
1.第一次進入main函數的時候switch（i） 是為什么，這里的i應該沒有賦值啊。又是怎么從0到8循 ...

變量i就是從零到八的循環
第一次進入的switch就是你按鍵的次數并給顯示緩存賦值
第二個問題就是消影。

HC6800-ES-V2.0 發表于 2019-3-20 14:26
#include

#define GPIO_DIG P0

請問一下
1.第一次進入main函數的時候switch（i） 是為什么，這里的i應該沒有賦值啊。又是怎么從0到8循環的呢。
2.還有這里j=10;
                while(j--);        
                GPIO_DIG=0x00;
這里是做了什么，每次都給j賦10的話while判定的時候一定為真啊 為什么每次要讓數碼管熄滅?

C語言有成型的排序比較方法，你只需要處理好鍵盤接收數據和屏幕顯示數據就好了

#include<reg51.h>

#define GPIO_DIG P0
#define GPIO_KEY P3

unsigned char code DIG_CODE[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,
0x77,0x7c,0x39,0x5e,0x79,0x71};

unsigned char KeyValue;

bit KeyState;

unsigned char DisplayData[8];

void Delay10ms();
void KeyDown();
void DigDisplay();

void main(void)
{
        unsigned char i;
        KeyState=0;
        while(1)
        {
                KeyDown();
                 if(KeyState==1)
                {
                        switch (i)
                        {
                                case (0):DisplayData[7]=DIG_CODE[KeyValue];break;
                                case (1):DisplayData[6]=DIG_CODE[KeyValue];break;
                                case (2):DisplayData[5]=DIG_CODE[KeyValue];break;
                                case (3):DisplayData[4]=DIG_CODE[KeyValue];break;
                                case (4):DisplayData[3]=DIG_CODE[KeyValue];break;
                                case (5):DisplayData[2]=DIG_CODE[KeyValue];break;
                                case (6):DisplayData[1]=DIG_CODE[KeyValue];break;
                                case (7):DisplayData[0]=DIG_CODE[KeyValue];break;
                        }                       
                        i++;
                        if (i==8)
                        {
                                i=0;
                        }
                        KeyState=0;
                }
                DigDisplay();
        }                               
}

void DigDisplay()
{
        unsigned char i,j;
        for(i=0;i<8;i++)
        {
                switch(i)
                {
                        case(0):
                                P2=0xfe; break;
                        case(1):
                                P2=0xfd; break;
                        case(2):
                                P2=0xfb; break;
                        case(3):
                                P2=0xf7; break;
                        case(4):
                                P2=0xef; break;
                        case(5):
                                P2=0xdf; break;
                        case(6):
                                P2=0xbf; break;
                        case(7):
                                P2=0x7f; break;
                }
                GPIO_DIG=DisplayData[i];
                j=10;
                while(j--);       
                GPIO_DIG=0x00;
        }
}

void KeyDown(void)
{
        unsigned char a=0;
        GPIO_KEY=0x0f;
        if(GPIO_KEY!=0x0f)
        {
                Delay10ms();
                if(GPIO_KEY!=0x0f)
                {
                        KeyState=1;
                        switch(GPIO_KEY)
                        {
                                case(0X07):        KeyValue=0;break;
                                case(0X0b):        KeyValue=1;break;
                                case(0X0d): KeyValue=2;break;
                                case(0X0e):        KeyValue=3;break;
                        }
                        GPIO_KEY=0Xf0;
                        Delay10ms();
                        switch(GPIO_KEY)
                        {
                                case(0X70):        KeyValue=KeyValue;break;
                                case(0Xb0):        KeyValue=KeyValue+4;break;
                                case(0Xd0): KeyValue=KeyValue+8;break;
                                case(0Xe0):        KeyValue=KeyValue+12;break;
                        }
                        while((a<200)&&(GPIO_KEY!=0xf0))
                        {
                                Delay10ms();
                                a++;
                        }
                        a=0;
                }
        }
}

void Delay10ms(void)
{
    unsigned char a,b,c;
    for(c=1;c>0;c--)
        for(b=38;b>0;b--)
            for(a=130;a>0;a--);
}

把數據存在數組中，在進行“冒泡排序”，“快速排序”....

用數組，然后，全部獨個比較，變換大小位置，幾個循環后就好了。