int main()
{
PNODE pHead = NULL;
int val;
pHead = create_list();
traverse_list(pHead);
insert_list(pHead, 3, 89);
traverse_list(pHead);
delete_list(pHead, 4, &val);
traverse_list(pHead);
//if (is_empty(pHead))
// printf("链表为空\n");
//else
// printf("链表不为空\n");
//printf("链表的长度为:%d\n", length_list(pHead));
//sort_list(pHead);
//traverse_list(pHead);
return 0;
}
int main() {
/* basics of internal representation and operations */
int n = 0xffffffff; /* -1 */
printf("n ==> %i\n", n);
printf("!n ==> %i\n", !n);
printf("-n ==> %i\n", -n);
printf("~n ==> %i\n", ~n);
printf("n ^ n ==> %i\n", n ^ n);
printf("n & n ==> %i\n", n & n);
printf("~n + 1 == -n: %i\n", -n == (~n + 1));
/* Computing what? */
int k = 1;
while ((n = (n << 1)) < 0) {
printf("n: %i\n", n);
k++;
}
printf("k == %i\n", k);
/* Computing what? */
n = 1;
while (n > 0) n = n << 1;
printf("n + 1 == %i\n", -(n + 1));
printf("\n");
int d3[2][3][2];
int* p = (int*) d3;
int i = 1;
while (i < 13) *p++ = i++;
i = 0;
while (i < 12) printf("%i ", ((int*) d3)[i++]);
printf("\n");
/* What's printed? */
int h = sizeof(d3) / 12;
*(((int*) d3) + h) = 0xffffffff;
i = 0;
while (i < 12) printf("%i ", ((int*) d3)[i++]);
printf("\n");
Link head = make_node();
Link node;
node = add_node(head, "Hello, world!");
node = add_node(node, "This is an intermediate node.");
node = add_node(node, "That's all, folks!");
traverse_list(head);
traverse_list(node);
return 0;
}
/**
* 需要对变量结构进行改变的时候才传指针
*/
int main(){
LinkList L=NULL;
//&L是一个指向*node的指针，*node是取指向node的指针的值，两者不同
LinkList la=0,lb=0,lc=0;
test(&la);
traverse_list(la);
printf("---------\n");
test1(&lb);
traverse_list(lb);
printf("---------\n");
merge_list(&la,&lb,&lc);
traverse_list(lc);
return 0;
}
void traverse_list(list_t *l)
{
if(l) {
printf("%jd,",l->val);
traverse_list(l->next);
}
}
void main()
{
int len, pos, *del;
plist pl = NULL;
del = (int*)malloc(sizeof(int));
pl = init_list();
isEmpty_list(pl);
insert_item(pl, 1, 1);
insert_item(pl, 2, 3);
insert_item(pl, 3, 5);
insert_item(pl, 4, 7);
insert_item(pl, 5, 9);
insert_item(pl, 6, 11);
display(pl);
len = len_list(pl);
printf("link list len: %d\n", len);
pos = locate_item(pl, 7);
printf("num 7 pos: %d\n", pos);
delete_item(pl, 3, del);
printf("delete pos 3 num: %d\n", *del);
display(pl);
printf("link list traverse...\n");
pl = traverse_list(pl);
display(pl);
destroy_list(pl);
getch();
}
/* main */
int main(void)
{
link_t head;
head = create_song_list(SONG_DIRECTORY);
traverse_list(print_songname, head);
destroy_list(head);
return 0;
}
int main(void)
{
int len;
int data_del;
PNODE pHead = NULL;
//创建链表并遍历输出
pHead = create_list();
traverse_list(pHead);
//求链表长度，并输出
len = length_list(pHead);
if(!is_empty(pHead))
printf("the length of the list is:%d\n",len);
//向链表中插入数据，并重新遍历输出
if(insert_list(pHead,3,78))
printf("insert succeed,");
else
printf("insert failed,");
traverse_list(pHead);
//从链表中删除数据，并重新遍历输出
if(delete_list(pHead,3,&data_del))
{
printf("delete succeed,the deleted data is:%d\n",data_del);
}
else
printf("delete failed,");
traverse_list(pHead);
//对链表排序，重新遍历输出
sort_list(pHead);
printf("After sorted,");
traverse_list(pHead);
//清空链表，遍历输出（无数据输出）
clear_list(pHead);
printf("After cleared,");
traverse_list(pHead);
return 0;
}
void free_tree(struct tree *t) {
if (t == NULL) {
return;
}
traverse_list(t->children, dec_refcount_child);
free_list(t->children);
if (t->type == TREE) {
dec_refcount(t->data.t);
}
free(t);
}
void recvAPPmsg(int connfd) {
char buf[300];
int buflen, len;
short msgtype;
//返回接收到的数据长度
buflen = recv(connfd, buf, 300, 0);
printf("buf0 = %d\n", buf[0]);
printf("buf1 = %d\n", buf[1]);
memcpy(&msgtype, buf, 2);
printf("buflen = %d\n", buflen);
printf("msgtype = %d\n", msgtype);
if (msgtype == 0x0003) {
//处理来自APP的消息
printf("收到来APP请求设备列表的消息\n");
//send(connfd, "我是网关, 收到请求\n", 200, 0);
traverse_to_app(device_link, connfd);
//======遍历链表回复给APP========
close(connfd);
} else if(msgtype == 0x0005) {
//网关好像不用做什么处理直接转发到设备就行
printf("收到了APP对设备的控制消息\n");
printf("APP控制消息分割线==========================\n");
printf("控制参数的值data = %d~~~~~~~~~~~~\n", buf[69]);
printf("值得倍数times = %d\n", buf[73]);
//关闭原连接
close(connfd);
//通过广播发送控制到设备
int i;
for(i = 0;i<20;i++) {
usleep(5000);
len = sendto(bsockfd, buf, 300, 0, (struct sockaddr*)&c_addr, c_addr_len);
}
printf("客服端地址%s\n", inet_ntoa(c_addr.sin_addr));
printf("UDP发送%s 端口：%d\n", strerror(errno), ntohs(c_addr.sin_port));
printf("len = %d\n", len);
printf("发送消息*************************************************\n");
}
printf("有设备接入，连接id: connfd = %d\n", connfd);
traverse_list(device_link);
}
int main()
{
Sqlist *LA;
LA = (Sqlist *)malloc(sizeof(*LA));
Sqlist *LB;
LB = (Sqlist *)malloc(sizeof(*LB));
Sqlist *LC;
LC = (Sqlist *)malloc(sizeof(*LC));
int pos;
int e;
create_list(LA);
create_list(LB);
printf("Please input the insert position:\n");
scanf("%d", &pos);
printf("Input the number you want to insert:\n");
scanf("%d", &e);
InsList(LA, pos, e);
traverse_list(LA);
printf("Please input the delete position:\n");
scanf("%d", &pos);
delete_list(LA, pos);
traverse_list(LA);
//union_list1(LA,LB);
//traverse_list(LA);
union_list2(LA,LB,LC);
traverse_list(LC);
return 0;
}
int main(void)
{
struct elem *head = NULL;
size_t len = 10;
//
head = init_list(len);
traverse_list(head, 2);
clean_list(head, len);
//
return 0;
}
int main( void ) {
list_node * p_head = create_list() ;
//is_list_empty( p_head ) ;
//sort_list( p_head ) ;
//insert_list( p_head ) ;
//append_list( p_head ) ;
//delete_list( p_head ) ;
//get_list_node_value( p_head ) ;
//get_list_node_index( p_head ) ;
//empty_list( p_head ) ;
alter_list( p_head ) ;
traverse_list( p_head ) ;
return 0 ;
}
void traverse_ttrie(ttrie_t *p, char *buf, int i)
{
if (!p) return;
traverse_ttrie(p->lo,buf,i);
if (p->c) {
buf[i]=p->c;
traverse_ttrie(p->eq,buf,i+1);
}
else {
buf[i]=p->c;
printf("%s:",buf);
traverse_list(p->list);
printf("\n");
}
traverse_ttrie(p->hi,buf,i);
}
int main ()
{
PNODE pHead = NULL; // 等价于 struct Node *pHead = NULL;
int pVal;
pHead = creat_list(); // 创建一个非循环单链表，并将该链表的头结点的地址付给pHead
// insert_list(pHead, 2, 6);
delete_list(pHead, 4, &pVal);
traverse_list(pHead);
// int len = length_list(pHead);
// printf("链表的长度是%d\n",len);
//
// sort_list(pHead);
// traverse_list(pHead);
return 0;
}
int
main(int argn, char *argv[])
{
int i, j, n, m;
llist_t *l = NULL, *p;
n = atoi(argv[1]);
m = atoi(argv[2]);
for(j = 0; j < m; ++j) {
for(i = 0; i < n; ++i) {
insert_list(&l, (i+j)); // random());
}
for(i = 0; i < n; ++i) {
traverse_list(l); putchar('\n');
delete_list(&l, (i+j));
}
empty_list(&l);
}
return 0;
}
int wordPattern(char *pattern, char* str)
{
struct ListNode *alpha[26];
struct ListNode *first = NULL;
struct ListNode *second = NULL;
int i;
int len_pattern;
int ret_val = 1;
int len_token = 0;
char *token;
int index = 0;
len_pattern = strlen(pattern);
for(i=0;i<26;i++) {
alpha[i] = NULL;
}
for(i=0;i<len_pattern;i++) {
insert_list(&alpha[pattern[i]-'a'],i);
}
tok_str = (char**)calloc(len_pattern,sizeof(char*));
token = strtok(str," ");
len_token = strlen(token);
tok_str[index++] = (char*)calloc(len_token+1,sizeof(char));
strcpy(tok_str[index-1],token);
while(token) {
token = strtok(NULL, " ");
if(token) {
len_token = strlen(token);
tok_str[index++] = (char*)calloc(len_token+1,sizeof(char));
strcpy(tok_str[index-1],token);
}
}
if(index != len_pattern) {
return 0;
}
for(i=0;i<index;i++) {
printf("token is %s\n",tok_str[i]);
}
for(i=0;i<26;i++) {
if(alpha[i]) {
display_list(alpha[i]);
printf("\n");
}
}
for(i=0;i<26;i++) {
if(alpha[i]) {
if(!first) {
first = alpha[i];
}else {
second = alpha[i];
}
if(first && second) {
if(!strcmp(tok_str[first->val],tok_str[second->val])) {
return 0;
}
first = second;
second = NULL;
}
}
}
for(i=0;i<26;i++) {
ret_val = ret_val && traverse_list(alpha[i]);
}
return ret_val;
}
int linearlist_test()
{
linearlist *ll = (linearlist *)calloc(1, sizeof(linearlist));
STATUS status = init_list(ll);
if(status != SUCC){
printf("初始化线性表失败 \n");
return -1;
}
append_list(ll, 1);
append_list(ll, 2);
append_list(ll, 3);
insert_list(ll, 2, 10);
append_list(ll, 100);
//遍历线性表
if(!empty_list(ll)){
int _i = 0;
for(; _i<ll->length; _i++){
printf( "list[%d] = %d \n", _i, *(ll->elem+_i) ) ;
}
}
BOOL flag = traverse_list(ll, increment);
if(flag) printf("all complte \n");
else printf("someone not invoke, please check \n");
//遍历线性表
if(!empty_list(ll)){
int _i = 0;
for(; _i<ll->length; _i++){
printf( "list[%d] = %d \n", _i, *(ll->elem+_i) ) ;
}
}
/*
int del_index = 3;
ELE_TYPE r;
status = delete_list(ll, del_index, &r);
if(status == SUCC){
printf("delete index %d ok , the value is %d \n", del_index, r);
//遍历线性表
if(!empty_list(ll)){
int _i = 0;
for(; _i<ll->length; _i++){
printf( "list[%d] = %d \n", _i, *(ll->elem+_i) ) ;
}
}
}
*/
/*
ELE_TYPE r , search = 100;
BOOL flag = prior_elem(ll, search, &r) ;
if(flag)
printf("%d prev is %d \n", search, r);
else
printf("not found or first point %d \n", search);
search = 2;
flag = next_elem(ll, search, &r);
if(flag)
printf("%d next is %d \n", search, r);
else
printf("not found or last point %d \n", search);
*/
/*
//获取一个元素
ELE_TYPE val = 0;
BOOL flag = get_item_list(ll, 2, &val);
if(flag){
printf("%d \n", val);
}
*/
//clear_list(ll);
/*
//获取某值在线性表中首次出现位置
ELE_TYPE search = 20;
printf("please entry a integer : ");
scanf("%d", &search);
int f_index = locate_elem(ll, search, compare_callback);
if(f_index!=0){
printf("%d locate is %d \n", search, f_index);
}else{
printf("%d not found \n", search);
}
*/
destory_list(ll);
return 0;
}
/* main */
int main(void)
{
int buttons_fd;
int key_value;
link_t head;
buttons_fd = open("/dev/key", 0);
if (buttons_fd < 0)
{
perror("open device buttons");
exit(1);
}
head = create_song_list(SONG_DIRECTORY);
if (is_empty_list(head) == 1)
{
printf("The song list is empty !\n");
destroy_list(head);
exit(1);
}
printf("===================================SONG LIST====================================\n");
traverse_list(print_songname, head);
printf("================================================================================\n");
printf("===================================FUNTION======================================\n\n");
printf(" K1:START/PAUSE K2:STOP K3:NEXT K4:PRIOR\n\n");
printf("================================================================================\n");
if ((shmid = shmget(IPC_PRIVATE, 5, PERM)) == -1)
{
perror("shmget");
exit(1);
}
p_addr = shmat(shmid, 0, 0);
memset(p_addr, '\0', 1024);
while (1)
{
fd_set rds;
int ret;
FD_ZERO(&rds);
FD_SET(buttons_fd, &rds);
ret = select(buttons_fd + 1, &rds, NULL, NULL, NULL);
if (ret < 0)
{
perror("select");
exit(1);
}
if (ret == 0)
{
printf("Timeout.\n");
}
else if (FD_ISSET(buttons_fd, &rds))
{
ret = read(buttons_fd, &key_value, sizeof key_value);
if (ret != sizeof key_value)
{
if (errno != EAGAIN)
perror("read buttons\n");
continue;
}
else
{
printf("buttons_value: %d\n", key_value + 1);
if (first_key == 1)
{
switch(key_value)
{
case 0:
startplay(&pid, head->next, head);
first_key = 0;
break;
case 1:
case 2:
case 3:
printf("=======================PRESS K1 TO START PLAY===================\n");
break;
default:
printf("=======================PRESS K1 TO START PLAY===================\n");
break;
} //end switch
}//end if(first_key)
else if(first_key == 0)
{
memcpy(&gradchild, p_addr, sizeof(pid_t));
switch(key_value)
{
case 0:
//printf("play_flag:%d\n",play_flag);
if(play_flag == 1)
{
my_pause(gradchild);
}
else
{
conti_play(gradchild);
}
break;
case 1:
my_stop(gradchild);
first_key = 1;
break;
case 2:
next(gradchild, head);
break;
case 3:
prev(gradchild, head);
break;
default:
break;
} //end switch
}//end if(!first_key)
}
}
}
destroy_list(head);
close(buttons_fd);
return 0;
}
