/*
 * main.c
 *
 *  Created on: 2012-10-18
 *      Author: micro
 */
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#include<stdio.h>
#include<stdlib.h>
#include <sys/ioctl.h>
#define MAXLINE 5

#define SERV_PORT 12345

void do_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen) {
	int n;
	socklen_t len;
	char mesg[MAXLINE];
	for (;;) {
		len = clilen;
		printf("Waiting for Data...\n");
		//等待数据
		n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);
		//将数据返回
		//sendto(sockfd, mesg, n, 0, pcliaddr, len);
		//打印数据
		//printf("%s\n", mesg);
		colcars(mesg[0]);
	}
}
//根据收到的信息执行操作
void colcars(char cmd) {
	if (cmd < '0' || cmd > '10') {
		printf("cmd error\n");
	} else {
		if (cmd == '2') {
//			printf("car back\n");
			car_col('6');
		} else {
			car_col(cmd);
		}
	}
}

void car_col(char cmd) {
	int fd;
	fd = open("/dev/car0", 0);
	if (fd < 0) {
		fd = open("/dev/car", 0);
	}
	if (fd < 0) {
		perror("open device car");
		return;
	}
	ioctl(fd, cmd, 0);
	close(fd);
}

int main(void) {
	int sockfd;
	struct sockaddr_in servaddr, cliaddr;
	//建立socket
	sockfd = socket(AF_INET, SOCK_DGRAM, 0);

	//初始化服务器地址
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY );
	servaddr.sin_port = htons(SERV_PORT);

	//为socket绑定端口
	if (bind(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) == -1) {
		perror("bind error");
		exit(1);
	}
	//执行服务器程序
	do_echo(sockfd, (struct sockaddr *) &cliaddr, sizeof(cliaddr));
	return 0;

}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char **argv)
{
	int cmd;
	int led_no;
	int fd;

	if (argc != 3 || sscanf(argv[1], "%d", &led_no) != 1 || sscanf(argv[2],"%d", &cmd) != 1 ||
			cmd < 0 || cmd > 9 || led_no < 0 || led_no > 3) {
		fprintf(stderr, "Usage: car led_no 0|1\n");
		exit(1);
	}

	fd = open("/dev/car0", 0);
	if (fd < 0) {
		fd = open("/dev/car", 0);
	}
	if (fd < 0) {
		perror("open device car");
		exit(1);
	}

	printf("CMD=%d\n",cmd);
	ioctl(fd, cmd, led_no);
	close(fd);

	return 0;
}

#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <asm/irq.h>
//#include <mach/regs-gpio.h>
#include <mach/hardware.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <asm/unistd.h>

#include <mach/map.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>
#include <mach/gpio.h>

//#include <linux/gpio.h>

#include <plat/gpio-cfg.h>
#include <mach/gpio-bank-e.h>
#include <mach/gpio-bank-k.h>

#define DEVICE_NAME "car"

//控制前后的电机
#define MOTOR_QH_ENA 	S3C64XX_GPM(4)
#define MOTOR_QH_ENB	S3C64XX_GPM(5)
//控制方向的电机
#define MOTOR_FX_ENA	S3C64XX_GPE(3)
#define MOTOR_FX_ENB	S3C64XX_GPE(4)


#define debug 1

static unsigned long motor_table [] = {
	MOTOR_QH_ENA,
	MOTOR_QH_ENB,
	MOTOR_FX_ENA,
	MOTOR_FX_ENB
};

//初始化GPIO口
static int car_motor_init(void)
{
  int ret=0,i;
  	for (i = 0; i < 4; i++) 
	{
	    
		if(gpio_is_valid(motor_table[i])==-EINVAL)
		{
		  printk("ERROR,GPIO used by other devices ! \n");
		  break;
		}
		//上拉GPIO
	  s3c_gpio_setpull(motor_table[i], S3C_GPIO_PULL_UP);
	  //设置为输出
	  s3c_gpio_cfgpin(motor_table[i], S3C_GPIO_OUTPUT);
	  //设置默认值为低电平
	  gpio_set_value(motor_table[i],0);
	 
	}
	
  return ret;
};


static void car_motor_status(void)
{
	printk("MOTOR_QH_ENA=%d\nMOTOR_QH_ENB=%d\nMOTOR_FX_ENA=%d\nMOTOR_FX_ENB=%d\n",
	gpio_get_value(MOTOR_QH_ENA),
	gpio_get_value(MOTOR_QH_ENB),
	gpio_get_value(MOTOR_FX_ENA),
	gpio_get_value(MOTOR_FX_ENB));
	
};

static void car_motor_run(void)
{
  	gpio_set_value(MOTOR_QH_ENA,1);
	gpio_set_value(MOTOR_QH_ENB,0);
};


static void car_motor_stop(void)
{
#if debug
	 car_motor_status();
#endif
  	gpio_set_value(MOTOR_QH_ENA,0);
  	gpio_set_value(MOTOR_QH_ENB,0);
};


static void car_motor_back(void)
{
  	gpio_set_value(MOTOR_QH_ENA,0);
	gpio_set_value(MOTOR_QH_ENB,1);
};

static void car_motor_left(void)
{
  	gpio_set_value(MOTOR_FX_ENA,1);
	gpio_set_value(MOTOR_FX_ENB,0);
};

static void car_motor_right(void)
{
 	gpio_set_value(MOTOR_FX_ENA,0);
	gpio_set_value(MOTOR_FX_ENB,1);
};

static void car_motor_zheng(void)
{
 	gpio_set_value(MOTOR_FX_ENA,0);
	gpio_set_value(MOTOR_FX_ENB,0);
};


static long car_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
#if debug
	printk("cmd=%d\n",cmd);
#endif
	long ret=0;
	switch(cmd)
	{
	  case '0':	case 0:
	  //小车停止
	  car_motor_stop();
	  break;
	  
	  case '1':	case 1:
	  //小车前进
	  car_motor_run();
	  break;
	  //小车后退
	  case '2':	case 2:
	  car_motor_back();
	  break;
	  //左转
	  case '3':	case 3:
	  car_motor_left();
	  break;
	  //右转
 	  case '4':	case 4:
	  car_motor_right();  
	  break;
	  //直走
	  case '5':	case 5:	
	  car_motor_zheng();
	  break;
	  //小车后退
	  case '6':	case 6:
	  car_motor_back();
	  break;

		return 0;
	default:
		return -EINVAL;
	}
	return ret;
}

static struct file_operations dev_fops = {
	.owner			= THIS_MODULE,
	.unlocked_ioctl	= car_ioctl,
};

static struct miscdevice misc = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = DEVICE_NAME,
	.fops = &dev_fops,
};

static int __init dev_init(void)
{
	int ret;

	car_motor_init();
//	car_motor_run();
	ret = misc_register(&misc);

	printk (DEVICE_NAME"\tinitialized\n");

	return ret;
}

static void __exit dev_exit(void)
{
	misc_deregister(&misc);
}

module_init(dev_init);
module_exit(dev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Lintel.");

package 学生运动会成绩管理;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * 学校类
 * 
 * @author Micro
 * 
 */
public class SchoolNode implements Serializable, Comparable<SchoolNode> {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	// 属性：编号，名字，成绩
	private String name = "";// 学校名称
	private int ID;// 学校编号
	private int mScore;// 男子项目成绩
	private int wScore;// 女子项目成绩
	// 存储项目名称的队列
	private ArrayList<String> ItemName = new ArrayList<String>();
	private int pai;
	// 存储具体是哪一项得了多少分的图
	private HashMap<String, String> score = new HashMap<String, String>();

	// 构造方法，在构造对象时要传入名字以及编号
	public SchoolNode(String name, int ID) {
		this.name = name;
		this.ID = ID;
		pai = ID;
	}

	public int getID() {
		return ID;
	}

	public String getName() {
		return name;
	}

	public HashMap<String, String> getScore() {
		return score;
	}

	// 设置排序方式
	public void setPai(int a) {
		if (a == 0) {
			// 以ID排序
			pai = ID;
		} else if (a == 1) {
			// 以总分排序
			pai = wScore + mScore;
		} else if (a == 2) {
			// 以男子项目成绩排序
			pai = mScore;
		} else {
			// 以女子项目成绩排序
			pai = wScore;
		}

	}

	public int getmScore() {
		return mScore;
	}

	public int getwScore() {
		return wScore;
	}

	public int getPai() {
		return pai;
	}

	public ArrayList<String> getItemName() {
		return ItemName;
	}

	// 添加成绩的方法
	public void addScore(String iName, String Score, Tools to) {
		ItemNode in = to.findItByName(iName);
		int v = 0;
		if (in.isBig()) {
			if (Score.equals("第一名")) {
				v = 7;
			}
			if (Score.equals("第二名")) {
				v = 5;
			}
			if (Score.equals("第三名")) {
				v = 3;
			}
			if (Score.equals("第四名")) {
				v = 2;
			}
			if (Score.equals("第五名")) {
				v = 1;
			}
		} else {
			if (Score.equals("第一名")) {
				v = 5;
			}
			if (Score.equals("第二名")) {
				v = 3;
			}
			if (Score.equals("第三名")) {
				v = 2;
			}
		}
		score.put(in.getName(), Score);
		// 分别统计男女项目得分
		if (in.isMan()) {
			mScore += v;
		} else {
			wScore += v;
		}
		ItemName.add(iName);

	}

	@Override
	public int compareTo(SchoolNode o) {
		// TODO Auto-generated method stub
		int p = o.getPai();
		return p - pai;
	}

}

package 哈夫曼压缩;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.PriorityQueue;

public class MainF {
	// 创建根节点
	private static HafNode root;
	// 储存节点编码的图
	HashMap<Character, Code> SaveCode = new HashMap<Character, Code>();

	public HashMap<Character, Code> getSaveCode() {
		return SaveCode;
	}

	// 程序入口
	public static void main(String[] args) throws Exception {
		// 储存字符出现频率的图
		HashMap<Character, Integer> PL = new HashMap<Character, Integer>();
		MainF ma = new MainF();
		ma.setCode(PL);
		PriorityQueue<HafNode> pq = new PriorityQueue<HafNode>();
		pq.add(new HafNode(' ', PL.get(' ')));
		for (char i = 'A'; i <= 'Z'; i++) {
			pq.add(new HafNode(i, PL.get(i)));
		}
		// 根据优先队列创建哈夫曼树
		ma.creatHafTree(pq);
		// 获得各叶节点的哈弗曼编码
		String Code = "";
		ma.getCode(root, Code);
		// 将字符串转化为哈弗曼编码
		String haf = ma
				.toHaf(ma.getSaveCode(), "THIS PROGRAM IS MY FAVORITE  ");
		// 将编码写入文件
		FileOutputStream fos = new FileOutputStream(new File("d:\\CodeFile.txt"));
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		DataOutputStream dos = new DataOutputStream(bos);
		dos.writeUTF(haf);
		dos.flush();
		// 从文件读取编码数据
		FileInputStream fis = new FileInputStream(new File("d:\\CodeFile.txt"));
		BufferedInputStream bis = new BufferedInputStream(fis);
		DataInputStream dis = new DataInputStream(bis);
		String hfcode = dis.readUTF();
		char[] hfchars = hfcode.toCharArray();
		//创建译码映射
		HashMap<String, Character> ym=ma.Setmap(ma.getSaveCode());
		/*******译码**********/
		String res="";
		//待转换的字符串
		String cov="";
		for(int i=0;i<hfchars.length;i++){
			cov+=hfchars[i];
			if(ym.containsKey(cov)){
				res+=ym.get(cov);
				cov="";
				System.out.println(res);
			}
		}
	}

	// 创建哈夫曼树
	public void creatHafTree(PriorityQueue<HafNode> queue) {
		while (queue.size() > 1) {
			HafNode min1, min2;
			min1 = queue.poll();
			min2 = queue.poll();
			// 创建合并的节点
			HafNode result = new HafNode('0', (min1.getPl() + min2.getPl()));
			result.setLeft(min1);
			result.setRight(min2);
			min1.setFather(result);
			min2.setFather(result);
			queue.add(result);
		}
		root = queue.peek();
	}

	// 设置字符频度
	public void setCode(HashMap<Character, Integer> code) {
		code.put(' ', 186);
		code.put('A', 64);
		code.put('B', 13);
		code.put('C', 22);
		code.put('D', 32);
		code.put('E', 103);
		code.put('F', 21);
		code.put('G', 15);
		code.put('H', 47);
		code.put('I', 57);
		code.put('J', 1);
		code.put('K', 5);
		code.put('L', 32);
		code.put('M', 20);
		code.put('N', 57);
		code.put('O', 63);
		code.put('P', 15);
		code.put('Q', 1);
		code.put('R', 48);
		code.put('S', 51);
		code.put('T', 80);
		code.put('U', 23);
		code.put('V', 8);
		code.put('W', 18);
		code.put('X', 1);
		code.put('Y', 16);
		code.put('Z', 1);
	}

	// 获得各叶节点的哈弗曼编码
	public void getCode(HafNode a, String code) {

		if (a.getLeft() == null && a.getRight() == null) {
			System.out.println(a.getN() + "——的哈夫曼编码为：\t" + code);
			Code b = new Code(code.length(), code);
			SaveCode.put(a.getN(), b);
		}
		if (a.getLeft() != null) {
			getCode(a.getLeft(), code + '0');
		}
		if (a.getRight() != null) {
			getCode(a.getRight(), code + '1');
		}
	}

	// 将字符串转化为哈夫曼编码串
	public String toHaf(HashMap<Character, Code> SaveCode, String s) {
		String haf = "";
		char[] msg = s.toCharArray();
		for (int i = 0; i < msg.length; i++) {
			haf += SaveCode.get(msg[i]).getNode();
		}
		System.out.println(haf);
		return haf;
	}

	

	// 创建映射
	public HashMap<String, Character> Setmap(HashMap<Character, Code> SaveCode) {
		HashMap<String, Character> map = new HashMap<String, Character>();
		map.put(SaveCode.get(' ').getNode(), ' ');
		for (char i = 'A'; i <= 'Z'; i++) {
			map.put(SaveCode.get(i).getNode(), i);
		}
		return map;
	}
}

package 哈夫曼压缩;

import java.io.Serializable;

/**
 * 哈夫曼树节点类
 * 
 * @author Micro
 * 
 */
public class HafNode implements Comparable<HafNode>, Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private HafNode father;
	private HafNode left;
	private HafNode right;
	private int pl;
	private char n;

	// 重载构造器
	public HafNode(char n, int pl) {
		this.n = n;
		this.pl = pl;
	}

	public HafNode getFather() {
		return father;
	}

	public void setFather(HafNode father) {
		this.father = father;
	}

	public HafNode getLeft() {
		return left;
	}

	public void setLeft(HafNode left) {
		this.left = left;
	}

	public HafNode getRight() {
		return right;
	}

	public void setRight(HafNode right) {
		this.right = right;
	}

	public void setN(char n) {
		this.n = n;
	}

	public char getN() {
		return n;
	}

	public int getPl() {
		return pl;
	}

	// 设置要比较的对象
	@Override
	public int compareTo(HafNode o) {
		// 要比较的是频率的大小
		int P = o.getPl();
		return pl - P;
	}

}

package 哈夫曼压缩;

/**
 * 存储每一个字节的哈弗曼编码和哈夫曼编码的长度
 * 
 * @author Micro
 * 
 */
public class Code {
	// 哈夫曼编码
	private String node;
	// 编码长度
	private int n;

	// 重载构造器
	public Code(int n, String node) {
		this.n = n;
		this.node = node;
	}

	public String getNode() {
		return node;
	}

	public void setNode(String node) {
		this.node = node;
	}

	public int getN() {
		return n;
	}

	public void setN(int n) {
		this.n = n;
	}

}

import java.awt.event.KeyEvent;  
import java.awt.event.KeyListener;  
  
  
import javax.swing.JFrame;  
/* 
 * To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */  
import javax.swing.JPanel;  
import javax.swing.JTextField;  
/** 
 * 
 * @author 阿迪 
 */  
public class HOHO extends JFrame implements KeyListener{  
      
    private JTextField t;  
    private boolean left = false;  
    private boolean right = false;  
    private boolean up = false;  
    private boolean down = false;  
     public HOHO() {  
       JPanel p = new JPanel();  
       this.add(p);  
       p.setLayout(null);  
       t = new JTextField();  
       t.setEditable(false);  
       p.add(t);  
       t.setSize(100,30);  
       t.setLocation(200,200);  
       this.setFocusable(true);  
       this.addKeyListener(this);  
       this.setSize(480,480);  
       this.setVisible(true);  
       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
         
     }  
    public void keyTyped(KeyEvent e) {  
          
    }  
    public void keyPressed(KeyEvent e) {  
         
       int i = e.getKeyCode();  
       switch(i) {  
           case  KeyEvent.VK_LEFT :  left=true;  break;  
           case  KeyEvent.VK_UP :   up= true;break;  
           case  KeyEvent.VK_DOWN :down = true; break;  
           case  KeyEvent.VK_RIGHT : right = true;break;  
       }  
         
       if(up==false&&down==false&&left==false&&right==false) {  
         t.setText("什么也没按");  
       }  
       else if(up==true&&down==false&&left==false&&right==false) {  
         t.setText("上");  
       }  
       else if(up==false&&down==true&left==false&&right==false) {  
            t.setText("下");  
       }  
       else if(up==false&&down==true&left==true&&right==false) {  
         t.setText("左下");  
       }  
       else if(up==true&&down==false&left==false&&right==true) {  
         t.setText("右上");  
       }  
       else if(up==true&&down==false&left==true&&right==false) {  
         t.setText("左上");  
       }  
        else if(up==false&&down==true&left==false&&right==true) {  
         t.setText("右下");  
       }  
       else if(up==false&&down==false&left==true&&right==false) {  
            t.setText("左");  
       }  
       else if(up==false&&down==false&left==false&&right==true) {  
            t.setText("右");  
       }  
         
    }  
    public void keyReleased(KeyEvent e) {  
      int i = e.getKeyCode();  
       switch(i) {  
           case  KeyEvent.VK_LEFT :  left=false;  break;  
           case  KeyEvent.VK_UP :   up= false;break;  
           case  KeyEvent.VK_DOWN :down = false; break;  
           case  KeyEvent.VK_RIGHT : right = false;break;  
       }  
    }  
      
    public static void main(String[] args){  
     new HOHO();  
    }  
       
}  

#include"stdlib.h"
#include"string.h"
#include"time.h"
#include"stdio.h"
#include"malloc.h"

typedef struct{
        char *ch;
        int length;
        }HString;
        
//初始化 
int InitStr(HString *S)
{
    S->ch=(char *)malloc(sizeof(char));
	if(!S->ch) 
    exit-2;//存储分配失败
	S->length=0;
	return 1;	
	}
    
//在空串中添加元素
int AddStr(HString *S)
{
    char ch;
    int i=0;
    while((ch = getchar()) != '\n') 
    {
           S->ch[i]=ch;
           S->ch=(char *)realloc(S->ch,sizeof(char));// 追加分配存储空间           
           i++;
   	       S->length++; 
     }
	 return (i);
} 

//输出串 
int PrintStr(HString *S)
{
	//输出长度为S->length的字符串 
	int i=0;	
    for(i=0;i<S->length;i++)
    {
         putchar(S->ch[i]);//每次实现一个字符输出 
    }
}

//串的常规匹配
int Index(HString *S,HString *T)
{
    int i=1;
    int j=1;
    while(i<=S->length&&j<=T->length)
    {
         if(S->ch[i-1] == T->ch[j-1])
         {
                       ++i;
                       ++j;
         }//继续比较后继字符 
         else 
         {
             i = i-j+2;
             j = 1;
         }//指针后退，重新开始匹配 
    } 
    if(j>T->length)   return (i-T->length);
    else return 0;
}

//用KMP算法实现串的模式匹配 
int Index_KMP(HString *S,HString *T,int next[])
{
    int i=1;
    int j=1;
    while(i<=S->length&&j<=T->length)
    {
         if(j==1||S->ch[i-1] == T->ch[j-1])
         {
                       ++i;
                       ++j;
         }//继续比较后继字符 
         else
         j = next[j];
    }
    if(j>T->length)   return (i-T->length);
    else return 0;
}

//求模式串T的next函数值并存入数组next
void get_next(HString *T,int next[])
{
     int i=1;
     int j=0;
     next[1]=0;
     while(i<T->length)
     {
          if(j==0||T->ch[i-1]==T->ch[j-1])
          {
              ++i;
              ++j;
              next[i] = j;
          }
          else  j = next[j];
     }
} 

//求模式串T的next函数修正值并存入数组nextval
void get_nextval(HString *T,int nextval[])
{
     int i=1;
     int j=0;
     nextval[1]=0;
     while(i<T->length)
     {
           if(j==0||T->ch[i-1] == T->ch[j-1])
           {
                  ++i;
                  ++j;
                  if(T->ch[i-1] != T->ch[j-1])  nextval[i] = j;
                  else nextval[i] = nextval[j];
           }
           else  j = nextval[j];
     }
} 


                             
    
    
    
main()
{
      int pos1=0;
      int pos2=0;
      HString S,T;
      int next[100];
	  int nextval[100];
	  int i=0;
	  int j=0;
	  
      InitStr(&S);
      printf("\n主串S初始化成功！"); 
      printf("\n请输入主串S：");
      AddStr(&S); 
      printf("\n主串S的长度为：%d\n",S.length);
      InitStr(&T);
      printf("\n子串T初始化成功！");
      printf("\n请子模式串T：");
      AddStr(&T); 
      printf("\n子串T的长度为：%d\n",T.length);
      
      pos1 = Index(&S,&T);
      if(pos1==0)  
      printf("\n串的常规匹配失败！");
      else   
      {
          printf("\n串的常规匹配成功！");
          printf("\n串的常规匹配成功位置为%d\n",pos1);
      }
      
      get_next(&T,next);
      printf("\n求解next函数值为：next[i]=  "); 
      for(i=1;i<=T.length;i++)
      printf("%d\t",next[i]);
      get_nextval(&T,nextval);
      printf("\n求解nextval函数值为：nextval[i]=  "); 
      for(i=1;i<=T.length;i++)
      printf("%d\t",nextval[i]);
      pos2=Index_KMP(&S,&T, next);
      if(pos2==0)  
      printf("\nKMP匹配失败!");
      else   
      {
             printf("\nKMP匹配成功!");
             printf("\nKMP匹配成功位置为%d",pos2);
      } 
      
      getch();
}

#include<stdio.h>
#include<malloc.h>
#define MAXQSIZE 100

typedef int QElemType;
typedef struct{
        QElemType *base;
        int front;
        int rear;
        }SqQueue;
        
       SqQueue Q;//定义一个全局变量。 
      
//初始化 
int InitQueue(SqQueue *Q) 
{
     Q->base = (QElemType *)malloc(MAXQSIZE *sizeof(QElemType));//分配存储空间 
     if(!Q->base)
     {
                 printf("\n存储分配失败！");
                 exit -2;
     }
     Q->front = Q->rear = 0;
     printf("\n循环队列初始化成功！");
     return 1;
}

//求队列的长度 
int QueueLength(SqQueue *Q)
{
    return (Q->rear - Q->front + MAXQSIZE) % MAXQSIZE;
}

//插入元素 e为Q的新队尾元素 
int EnQueue(SqQueue *Q)
{
    QElemType e;
    if((Q->rear + 1) % MAXQSIZE == Q->front)//判断队列是否已满 
    {
                printf("\n队列已满！");
                return 0;
    }
    printf("\n请输入入队列的元素值：");
    scanf("%d",&e);
    Q->base[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MAXQSIZE;//入队 
    return 1;
}

//打印队列中的所有元素 
QElemType PrintQueue(SqQueue *Q)
{
          QElemType e;
          QElemType p;
          int i;
          if(Q->front == Q->rear)
          {
                      printf("\n队列为空，请先插入元素！");
                      return 0;
          }
          p = Q->front;
          for(i=0;i<((Q->rear-p+MAXQSIZE)%MAXQSIZE);i++)
          {
              e = Q->base[Q->front];
              printf("%d\t",e);
              Q->front = (Q->front+1)%MAXQSIZE;
          }
          Q->front = p;
          return 1;
}

//删除队头e，并返回其值 
int DeQueue(SqQueue *Q)
{
    QElemType e;
    if(Q->front == Q->rear)
    {
                printf("\n队列为空！");
                return 0;
    }
    e = Q->base[Q->front];
    Q->front = (Q->front+1) % MAXQSIZE;
    return e;
}



//**************主函数*************** 
main()
{
      int length;
      int i,n,head;
      QElemType print;
      InitQueue(&Q);
      printf("\n请输入要入队列的元素个数：");
      scanf("%d",&n);
      for(i=0;i<n;i++)
      EnQueue(&Q);
      length = QueueLength(&Q);
      printf("\n该队列长度为：%d",length);
      printf("\n队列中的元素为：");
      PrintQueue(&Q);
      head = DeQueue(&Q);
      printf("\n队头元素 %d 已被删除！",head);
      printf("\n删除队头后新队列中的元素为：");
      PrintQueue(&Q);
      getch();
}

#include<stdio.h>
#include<malloc.h>

typedef int QElemType;
typedef struct QNode{
        QElemType data;
        struct QNode *next;
        }QNode,*QueuePtr;
typedef struct {
        QueuePtr front;
        QueuePtr rear;
        }LinkQueue;
LinkQueue Q;//定义一个全局变量 

//初始化 
//队列的基地址为-1 
int InitQueue(LinkQueue *Q)
{
     Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));//存储空间分配 
     if(!Q->front)
     {
           printf("\n存储空间分配失败！");
           exit -2;
     }
     Q->front->next = NULL;
     printf("\n队列初始化成功！");
     return 1;
}

//插入元素 e到队尾 
int EnQueue(LinkQueue *Q,QElemType e)
{
     QueuePtr p;
     p = (QueuePtr)malloc(sizeof(QNode));//为新加入元素分配存储空间 
     if(!p)
     {
           printf("\n存储空间分配失败！");
           exit -2;
     }
     printf("\n请输入要入队列的元素："); 
     scanf("%d",&e);
     p->data = e;
     p->next = NULL;
     Q->rear->next = p;
     Q->rear = p;
     return 1;
}
     
//打印队列中的所有元素 
int PrintQueue(LinkQueue *Q)
{
    QueuePtr p;
    p=Q->front;
    while(Q->front!=Q->rear)
    {
          printf("%d\t",Q->front->next->data);
          Q->front = Q->front->next;
    }
    Q->front=p;
    return 1;
}

//删除队头元素 e，并返回其值 
QElemType DeQueue(LinkQueue *Q)
{
    QueuePtr p;
    QElemType e;
    if(Q->front == Q->rear)
    {
          printf("\n队列为空，出队列失败！");
          return 0;
    }
    p = Q->front->next;
    e = p->data;
    Q->front->next = p->next;
    if(Q->rear == p)
    Q->rear = Q->front;
    printf("\n队头元素%d出队列成功！",e);
    free(p);
    return e;
}

//获得队头元素 e 
QElemType GetHead(LinkQueue *Q)
{
     QElemType e;
     if(Q->front == Q->rear)
    {
          printf("\n队列为空,无法得到队头！");
          return 0;
    }
    e = Q->front->next->data;
    
    return e;
}


//**************主函数**************** 
main()
{
      int i=0;
      int n=0;
      int k;
      int head,de;
      InitQueue(&Q);
      printf("\n请输入要入队列的元素个数：");
      scanf("%d",&n);
      for(i=0;i<n;i++)
      EnQueue(&Q,k);
      printf("\n队列中的元素为："); 
      PrintQueue(&Q);
      head = GetHead(&Q);
      printf("\n队头元素为：%d",head); 
      de = DeQueue(&Q);
      printf("\n删除队头后队列中的元素为：");
      PrintQueue(&Q);
      getch();
}

#include<stdio.h>
#include<malloc.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT  10

typedef int SElemType;
typedef struct{
        SElemType *base;
        SElemType *top;
        int stacksize;
        }SqStack;
        
void InitStack(SqStack *S)
{
     S->base = (SElemType *)malloc(STACK_INIT_SIZE *sizeof(SElemType));
     if(!S->base)
     {
                printf("\n存储分配失败！");
                exit -2;
     }
     S->top = S->base;
     S->stacksize = STACK_INIT_SIZE;
     printf("\n栈初始化成功！");
}

SElemType GetTop(SqStack *S)
{
          int e;
          if(S->top == S->base)
          {
                    printf("\n栈内没有数据！");
                    return 0;
          }
          e = *(S->top-1);
          printf("\n栈顶元素为：%d",e);
          return 1;
}

void Push(SqStack *S)
{
     SElemType e;
     printf("\n请输入要入栈的元素：");
     scanf("%d",&e);
     if(S->top - S->base>=S->stacksize)
     {
               S->base = (SElemType *)realloc(S->base,(S->stacksize + STACKINCREMENT) *sizeof(SElemType));
               if(!S->base)
               {
                           printf("\n追加存储空间失败！");
                           exit -2;
               }
               S->top = S->base + S->stacksize;
               S->stacksize += STACKINCREMENT;
     }
     *S->top++ = e;
}

SElemType Pop(SqStack *S)
{
          SElemType e;
          if(S->top == S->base)
          {
                    printf("\n栈内没有数据，不能弹出栈顶元素！");
                    return 0;
          }
          e = *--S->top;
          printf("\n弹出的栈顶元素为：%d",e);
          return 1;
}


main()
{
      int i,n;
      SqStack S;
      SElemType gettop;
      InitStack(&S);
      gettop = GetTop(&S);
      printf("\n请输入要入栈的元素个数：");
      scanf("%d",&n);
      for(i=0;i<n;i++)
      Push(&S);
      gettop = GetTop(&S);
      Pop(&S);
      getch();
}

#include<stdio.h>
#include<malloc.h>

typedef int ElemType;
typedef struct DuList{
        ElemType data;
        struct DuList *prior;
        struct DuList *next;
        }DuList;
        
//双向链表的创建 
DuList *CreatList_L( )
{
       int n,i;
       DuList *p,*L,*r;
       L = (DuList *)malloc(sizeof(DuList));
       L->prior = NULL;
       L->next = NULL;
       r=L;
       printf("\n请输入元素个数：");
       scanf("%d",&n);
       for(i=1;i<=n;i++)
       {
             p = (DuList *)malloc(sizeof(DuList));
             printf("\n请输入元素值");
             scanf("%d",&p->data);
             p->next = r->next;
             r->next = p;
             p->prior = r;
             r = r->next;
       }
       return(L);
}

//打印双向链表中的所有元素 
Print_DuL(DuList *L)
{
        DuList *p,*r;
        r = L;
        if(L->next==NULL)
	    printf("\n没有数据");
     	while(r->next)
        {
		    p=r->next;
            r=r->next;
            printf("%d\t",p->data);
	     }
}

//在链表中插入新元素 
Insert_DuL(DuList *L)
{
      DuList *p,*s;
      int i,j,e;
      p=L;
      j=0;
      printf("\n请输入要插入的位置");
      scanf("%d",&i);
      while(p&&j<i)
      {
        p=p->next;
        ++j;
      }
      if(!p||j>i)
      {
        printf("\n不存在第%d个结点，插入失败!\n",i);
        return(0);
      }
      printf("\n请输入要插入元素：");
      scanf("%d",&e);
      if(!(s = (DuList *)malloc(sizeof(DuList))))
      {
             printf("\n新元素内存分配失败"); 
             return(0);
      }
      s->data = e;
      s->prior = p->prior;
      p->prior->next = s;
      s->next = p;
      p->prior = s;
      printf("\n插入成功！");
      return(1);
}

//删除双向链表中的某个元素 
Delet_DuL(DuList *L)
{
    DuList *p;
    int i,j;
    p=L;
    j=0;
    printf("\n请输入要删除的结点位置");
    scanf("%d",&i);
    while(p->next&&j<i-1)
    {
         p=p->next;
         ++j;
    }
    if(!(p->next)||j>i-1)
    {
       printf("\n无此结点，删除失败！"); 
       return(0);
    }
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return(1);
}
      

//**************************主函数************************* 
main()
{
   DuList *L;
   L=CreatList_L();
   printf("\n双链表中元素为：");
   Print_DuL(L);
   Insert_DuL(L);
   printf("\n插入元素后双链表中数据为：");
   Print_DuL(L);
   Delet_DuL(L);
   printf("\n删除元素后双链表中数据为：");
   Print_DuL(L);
   getch();
}  

#include"malloc.h"
#include"stdio.h"

typedef struct list{
        int num;
        struct list *next;
        }linklist;

//创建一个链表 
linklist *CreatList(int n)
{
         int x,i;
         linklist *L,*r,*p;
         L=(linklist *)malloc(sizeof(linklist));
         L->next=NULL; 
         r=L;
         for(i=1;i<=n;i++)
         {
             p=(linklist *)malloc(sizeof(linklist));
             printf("\n请输入元素:");
             scanf("%d",&p->num);
             p->next=NULL;/*尾插法*/
             r->next=p;
             r=r->next;
         }
         return(L);
} 

//打印链表中的所有元素 
PrintLlist(linklist *L)
{
      linklist *p,*r;
      r=L;
      if(L->next==NULL)//判断链表是否为空 
      printf("链表为空！\n");
      while(r->next)
      {
                    p=r->next;
                    r=r->next;
                    printf("%d\t",p->num);
      }
}

//合并两个链表 
linklist *meagerlist(linklist *L,linklist *H)
{
         int i; int x;
         linklist *p,*q,*r,*T,*g;
         p=L;
         q=H;
         while(q->next)
         {
             x=p->next->num;
             if(q->next->num==x)
             {
                   p=p->next;
                   q=q->next;            
             }
             q->next=p->next;
             p->next=q;
         }
         free(q);
         p->next=H->next;
         return(L); 
}

//元素的排序 
linklist *SortList(linklist *head)
{
         linklist *p,*q,*small;
         int temp;
         for(p=head->next;p->next!=NULL;p=p->next)
         {
              small=p;                                                                                                           
              for(q=p->next;q;q=q->next)
              if(q->num<small->num) 
              small=q;
              if(small!=p)//采用选择排序的方法 
              {
                   temp=p->num;
                   p->num=small->num;
                   small->num=temp;
              }
         }
         return(head);
}

//********************主函数********************** 
main()
{
      linklist *L,*H,*G,*S;
      int n;int m;int y;
      printf("创建链表 A:\n");
      printf("输入链表中元素个数:");
      scanf("%d",&n);
      L=CreatList(n);
      printf("\nA链表中的元素为：");
      PrintLlist(L); 
      printf("\n创建链表 B:\n");
      printf("输入链表中元素个数:");
      scanf("%d",&m);
      H=CreatList(m);
      printf("\nB链表中的元素为：");
      PrintLlist(H);
      L=meagerlist(L,H);
      S=SortList(L);
      printf("\n合并并排序后的链表：");
      PrintLlist(S);           
      getch();
}

#include"malloc.h"
#include"stdio.h"

typedef struct list{
        int num;
        struct list *next;
        }linklist;

//创建一个链表 
linklist *CreatList(int n)
{
         int x,i;
         linklist *L,*r,*p;
         L=(linklist *)malloc(sizeof(linklist));
         L->next=NULL; 
         r=L;
         for(i=1;i<=n;i++)
         {
             p=(linklist *)malloc(sizeof(linklist));
             printf("\n请输入元素:");
             scanf("%d",&p->num);
             p->next=NULL;/*尾插法*/
             r->next=p;
             r=r->next;
         }
         return(L);
} 

//打印链表中的所有元素 
PrintLlist(linklist *L)
{
      linklist *p,*r;
      r=L;
      if(L->next==NULL)//判断链表是否为空 
      printf("链表为空！\n");
      while(r->next)
      {
                    p=r->next;
                    r=r->next;
                    printf("%d\t",p->num);
      }
}

//合并两个链表 
linklist *meagerlist(linklist *L,linklist *H)
{
         int i; int x;
         linklist *p,*q,*r,*T,*g;
         p=L;
         q=H;
         while(p->next)
         {
               T=(linklist *)malloc(sizeof(linklist));//依次取出链表 A中的数据 
               T->num=p->next->num;
               x=T->num;
               p=p->next;
               for(q=H;q->next;q=q->next)
               {
                    if(q->next->num==x)
                    {
                         r=q->next;
                         q->next=q->next->next;
                         free(r);
                    } 
               }
         }
         p->next=H->next;
         return(L); 
}

//元素的排序 
linklist *SortList(linklist *head)
{
         linklist *p,*q,*small;
         int temp;
         for(p=head->next;p->next!=NULL;p=p->next)
         {
              small=p;                                                                                                           
              for(q=p->next;q;q=q->next)
              if(q->num<small->num) 
              small=q;
              if(small!=p)//采用选择排序的方法 
              {
                   temp=p->num;
                   p->num=small->num;
                   small->num=temp;
              }
         }
         return(head);
}

//********************主函数********************** 
main()
{
      linklist *L,*H,*G,*S;
      int n;int m;int y;
      printf("创建链表 A:\n");
      printf("输入链表中元素个数:");
      scanf("%d",&n);
      L=CreatList(n);
      printf("\nA链表中的元素为：");
      PrintLlist(L); 
      printf("\n创建链表 B:\n");
      printf("输入链表中元素个数:");
      scanf("%d",&m);
      H=CreatList(m);
      printf("\nB链表中的元素为：");
      PrintLlist(H);
      G=meagerlist(L,H);
      S=SortList(G);
      printf("\n合并并排序后的链表：");
      PrintLlist(S);           
      getch();
}

#include<stdio.h>
#include<string.h>
#include<malloc.h> 
#define MAXLEN 100
#define LISTINCREMENT 10


typedef int ElemType;
typedef struct{
        ElemType *elem;
        int length;
        int listsize;
        }SqList;
        
SqList L;//定义一个全局变量 

//初始化顺序表 
int Init_Sq(SqList *L)
{
       L->elem = (ElemType *)malloc(MAXLEN *sizeof(ElemType));
       if(!(L->elem))
       return(0);/*存储分配失败*/
       L->length = 0;
       L->listsize = MAXLEN;
       return 1;
}

//为初始化了的顺序表添加元素 
int Creat_Sq(SqList *L,int n)
{
     int i;
     ElemType *p;
     ElemType e;
     
     for(i=0;i<n;i++)
     {
           printf("\n请输入元素值：");
           scanf("%d",&e);
           p = &(L->elem[i]);
           *p = e;
           L->length++;
     }
     return 1;
}

//打印顺序表中的所有元素 
int Print_Sq(SqList *L)
{
     int i;
     ElemType *p;
     ElemType e;
     for(i=0;i<L->length;i++)
     {
           p = &(L->elem[i]);
           e = *p;
           printf("%d\t",e);
     }
}

//在顺序表中插入一个新元素 
int Insert_Sq(SqList *L)
{
	ElemType *p,*q,*newbase;
	int i,e;
	p = L->elem;
	printf("\n请输入要插入的位置：");
    scanf("%d",&i);
    if(i<1||i>=L->length+1) 
    {
           printf("\n无此位置，插入失败！");
           return 0;
    }
    printf("\n请输入插入的元素值：");
    scanf("%d",&e);
    if(L->length>=L->listsize)
    {
	newbase=(ElemType*)realloc(L->elem,(L->listsize+MAXLEN)*sizeof(ElemType));
		if(!newbase) exit(0);
		L->elem = newbase;
		L->listsize += LISTINCREMENT;
	}
		q=&(L->elem[i-1]);
		for(p=&(L->elem[L->length-1]);p>=q;--p)
		*(p+1)=*p;
		*q=e; 
		++L->length;
		return 1;		
}

//删除顺序表中的某个元素 
int Delete_Sq(SqList *L)
{
        int i;
        int *p,*q;
        printf("\n请输入要删除的位置：");
        scanf("%d",&i);
        if((i<1)||(i>L->length+1))
        {
             printf("\n不存在第%d个位置，删除失败！");
             return(0);
        }
        p = &(L->elem[i-1]);
        q = L->elem+L->length-1;
        for(++p;p<=q;++p)
        *(p-1) = *p;
        --(L->length);
        return 1;
}

//*********************主函数************************* 
main()
{
      int n;
      int k=0;
      SqList L;
      n = Init_Sq(&L);
      printf("\n顺序表初始化成功！");
      printf("\n请输入加入顺序表的元素个数：");
      scanf("%d",&k);
      int c; 
      c = Creat_Sq(&L,k);
      printf("\n顺序表中元素值为："); 
      Print_Sq(&L);
      Insert_Sq(&L);
      printf("\n插入元素后新顺序表中元素值为：");
      Print_Sq(&L);
      Delete_Sq(&L);
      printf("\n删除元素后新顺序表中元素值为：");
      Print_Sq(&L);
      getch();
}

#include<stdio.h>
#include<malloc.h>

typedef struct List{
        int data;
        struct List *next;
        }LinkList;
        
//创建链表 
LinkList *CreatList_L( )
{
         int n,i;
         LinkList *p,*L,*r;
         L = (LinkList *)malloc(sizeof(LinkList));
         L->next = NULL;
         r=L;
         printf("\n请输入元素个数：");
         scanf("%d",&n);
         for(i=1;i<=n;i++)
         {
                          p = (LinkList *)malloc(sizeof(LinkList));
                          printf("\n请输入元素值");
                          scanf("%d",&p->data);
                          p->next = NULL;
                          r->next = p;
                          r = r->next;/*尾插法*/ 
         }
         return (L);
}

//将链表中的元素打印出来 
Print_L(LinkList *L)
{
	LinkList *p,*r;
	r=L;
	if(L->next==NULL)
	   printf("\n没有数据");
	while(r->next)
    {
		p=r->next;
        r=r->next;
        printf("%d\n",p->data);
	}
}

//在链表中插入元素 
Insert_L(LinkList *L)
{
    LinkList *p,*s;
    int i,j,e;
    p=L;
    j=0;
    printf("\n请输入要插入的位置");
    scanf("%d",&i);
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
    {
        printf("\n不存在第%d个结点，插入失败!\n",i);
        return(0);
    }
    printf("\n请输入要插入元素：");
    scanf("%d",&e);
    s = (LinkList *)malloc(sizeof(LinkList));
    s->data = e;
    s->next = p->next;
    p->next = s;
    printf("\n插入成功！");
    return(1);
}

//删除链表中的某个元素 
Delet_L(LinkList *L)
{
    LinkList *p,*q;
    int i,j;
    p=L;
    j=0;
    printf("\n请输入要删除的结点位置");
    scanf("%d",&i);
    while(p->next&&j<i-1)
    {
         p=p->next;
         ++j;
    }
    if(!(p->next)||j>i-1)
    {
       printf("\n无此结点，删除失败！"); 
       return(0);
    }
    q=p->next;
    p->next = q->next;
    free(q);
    printf("\n删除成功！");
    return(1);
}
         
     
//*********************主函数************************* 
main()
{
   LinkList *L;
   L=CreatList_L();
   printf("\n链表中元素为：");
   Print_L(L);
   Insert_L(L);
   printf("\n插入元素后链表中数据为：");
   Print_L(L);
   Delet_L(L);
   printf("\n删除元素后链表中数据为：");
   Print_L(L);
   getch();
}  

#include<stdio.h>
#define NUM 4
struct student
{
	long no;
	char name[10];
	char sex;
	int age;
	int score;
};
main()
{
	struct student stu[NUM];
	int i,n,s,num;
	clrscr();

	printf("The Num of Stu:\n");
	scanf("%d",&num);
	getchar();
	for (i=0;i<num;i++)
	{
		printf("Student%d\n",i+1);
		printf("Number:");
		scanf("%ld",&stu[i].no);
		printf("Name:");
		getchar();
		scanf("%s",stu[i].name);
		printf("Sex:");
		getchar();
		scanf("%c",&stu[i].sex);
		printf("Age:");
		getchar();
		scanf("%d",&stu[i].age);
		printf("Score:");
		getchar();
		scanf("%d",&stu[i].score);
		getchar();
	}
	printf("Number\tName\tSex\tAge\tScore\n\n");
	for (i=0;i<num;i++)
	{
		printf("%d\t",stu[i].no);
		printf("%s\t",stu[i].name);
		printf("%c\t",stu[i].sex);
		printf("%d\t",stu[i].age);
		printf("%d\t\n",stu[i].score);
   }
   getch();
   for(i=0,n=0;i<num;i++)
   {
		if(stu[i].sex=='m')
		n++;
	}
	printf("nan=%d\nnv=%d\n",n,num-n);
	getch();
	for(i=0,s=0;i<num;i++)
	{
		s=s+stu[i].score;
	}
	printf("PJscore=%d\n",s/num);
	getch();
	printf("Di yu PJscore:\n");
	printf("Number\tName\tSex\tAge\tScore\n\n");
	for(i=0;i<num;i++)
	{
		if(stu[i].score<s/num)
		{
			printf("%d\t",stu[i].no);
			printf("%s\t",stu[i].name);
			printf("%c\t",stu[i].sex);
			printf("%d\t",stu[i].age);
			printf("%d\t\n",stu[i].score);
		}
	}
	getch();
}