rev_list.c

#include
#include

#define DEBUG

typedef struct node_s {
struct node_s *next;
int x;
} node_t;

node_t *head = NULL;

void insert_node (int x) {
node_t *tmp = (node_t *) malloc(sizeof(node_t));
tmp->x = x;
tmp->next = NULL;

#ifdef DEBUG
printf("insert node: %d\n", x);
#endif

if (!head)
head = tmp;
else {
tmp->next = head;
head = tmp;
}

return;
}


void delete_node (node_t *p) {
if (!p)
return;

#ifdef DEBUG
printf("delete node: %d\n", p->x);
#endif

if (head == p) {
head = p->next;
p->next = NULL;
free(p);
p = NULL;
} else {
// need the prev pinter:
}

return;
}


void print_node(node_t *he) {
FILE *fp = fopen("node.dump", "rw");

if (!fp) {
#ifdef DEBUG
printf("Open file failed.\n");
#endif

exit (1);
}
node_t *p = he;

while (p) {
#ifdef DEBUG
printf("node: %d\n", p->x);
#endif
p = p->next;
}
}

void rev_list(node_t *he, node_t **new) {
node_t **h = &he;

if (!*h || (*h)->next == NULL) {
return ;
}

if ((*h)->next->next)
rev_list((*h)->next, new);
else
*new = (*h)->next;

(*h)->next->next = *h;
(*h)->next = NULL;
}

void swap(char *p, char *q) {

char tmp = p[0];
p[0] = q[0];
q[0] = tmp;
}


void permute (char *s, int i) {
int j = 0;
if (i == strlen(s))
printf("%s\n", s);
else {
for (j = i; j < strlen(s); ++j) {
swap(&s[i], &s[j]);
permute(s, i+1);
swap(&s[i], &s[j]);
}
}
}

#if 0
void shuffle (int *arr, int n) {
int i = 0;
for (i = 0; i < sizeof(arr), i++) {
int ind = rand(i, sizeof(arr));
swap(&arr[i], &arr[ind]);
}
}

void shuffle(Element* array, int size）{
for (int i=0; i int toSwap = Rand()%size;
if(toSwap!=i) {
Element temp = array[toSwap];
array[toSwap] = array[i];
array[i] = temp;
}
}
}

#endif

char *
baseconv(unsigned int num, int base)
{
int i = 0;
static char retbuf[33];
char *p;

printf("--baseconv\n");
for (i = 0; i < 33; i++) {
printf("retbuf[%d] = %c\n", i, retbuf[i]);
printf("retbuf[%d] = %d\n", i, (int)retbuf[i]);
}

if(base < 2 || base > 16)
return NULL;

p = &retbuf[sizeof(retbuf)-1];
*p = '\0';
do {
*--p = "0123456789abcdef"[num % base];
printf("p=%c\n", *p);
num /= base;
} while(num != 0);

// this is partial array starting from p position in retbuf[]
return p;
}



int main() {
int i = 0;

for (i = 0; i < 6; i++) {
insert_node(i*2);
}

print_node(head);


printf("------\n");
node_t *newhead = NULL;
rev_list(head, &newhead);
print_node(newhead);

printf("-------\n");
char str[] = "1234";
swap(&str[0], &str[4]);
swap(&str[4], &str[0]);

permute(str, 0);

char *base = baseconv(18, 2);
printf("base=%s\n", base);
return 0;
}


//-----------------------------
//-----------------------------
#if 0
void reverseWords( char str[] ){
int start = 0, end = 0, length;

length = strlen(str);
/* Reverse entire string */
reverseString(str, start, length - 1);

while( end < length ){
if( str[end] != ' ' ){ /* Skip non-word characters */

/* Save position of beginning of word */
start = end;

/* Scan to next non-word character */
while( end < length && str[end] != ' ' )
end++;
/* Back up to end of word */
end--;

/* Reverse word */
reverseString( str, start, end );
}
end++; /* Advance to next token */
}
}

void reverseString( char str[], int start, int end ){
char temp;
while( end > start ){
/* Exchange characters */
temp = str[start];
str[start] = str[end];
str[end] = temp;

/* Move indices towards middle */
start++; end--;
}
}

void dedupe(char *str)
{
int length = strlen(str);
int i=0,j=0;
char flag[256];
for(i=0; i<256; i++)
{
flag[i] = 0;
}
for(i=0; i{
if(flag[str[i]] == 0)
{
flag[str[i]] = 1;
str[j] = str[i];
j++;
}
}
str[j] = '\0';

}

#include /* for CHAR_BIT */

#define BITMASK(b) (1 << ((b) % CHAR_BIT))
#define BITSLOT(b) ((b) / CHAR_BIT)
#define BITSET(a, b) ((a)[BITSLOT(b)] |= BITMASK(b))
#define BITCLEAR(a, b) ((a)[BITSLOT(b)] &= ~BITMASK(b))
#define BITTEST(a, b) ((a)[BITSLOT(b)] & BITMASK(b))
#define BITNSLOTS(nb) ((nb + CHAR_BIT - 1) / CHAR_BIT)

//---------------------
//---------------------
//---------------------
#endif